nanogit Development Assistant

Expert assistant for working with nanogit, a lightweight, HTTPS-only Git implementation written in Go by Grafana. Designed for cloud-native environments with pluggable storage backends and minimal dependencies.

What This Skill Does

This skill helps you work effectively with the nanogit codebase by:

Project Context

**nanogit** is a minimal Git implementation optimized for server-side usage in multitenant cloud services. It provides essential Git operations over HTTPS only, with no local .git directory dependency and pluggable storage backends.

**Key Differences from go-git:**

Instructions

1. Understand the User's Request

Identify whether the user wants to:

2. Code Quality Tasks

**Format code:**

```bash

make fmt

```

**Run linters:**

```bash

make lint

make lint-staticcheck

```

**Generate mocks:**

```bash

make generate

```

3. Testing Tasks

**Quick unit tests (no Docker required):**

```bash

make test-unit

```

**Integration tests (requires Docker):**

```bash

make test-integration

```

**All tests:**

```bash

make test

```

**Provider compatibility tests:**

```bash

make test-providers

```

**Coverage reports:**

```bash

make test-coverage # Generate reports

make test-coverage-html # View in browser

```

4. Performance Testing

Navigate to `perf/` directory for performance operations:

**One-time setup:**

```bash

cd perf && make test-perf-setup

```

**Quick consistency tests:**

```bash

cd perf && make test-perf-simple

```

**Full benchmark suite:**

```bash

cd perf && make test-perf-all

```

**Profiling workflow:**

```bash

cd perf && make profile-baseline # Create baseline before changes

Make your code changes

cd perf && make profile-cpu # Profile CPU performance

cd perf && make profile-mem # Profile memory usage

cd perf && make profile-compare # Compare against baseline

```

**See all performance targets:**

```bash

cd perf && make help

```

5. Architecture Understanding

When explaining code or design decisions, reference these key components:

**Core Interfaces** (`client.go`, `writer.go`):

**Protocol Layer** (`protocol/`):

**Storage System** (`storage/`):

6. Code Style Standards

Ensure all contributions follow:

7. Testing Frameworks

**Unit Tests:**

**Integration Tests** (`tests/`):

**Performance Tests** (`perf/`):

8. Dependencies

Examples

**Example 1: User asks to run tests before committing**

```bash

make fmt

make lint

make test-unit

```

**Example 2: User wants to add a new feature with tests**

1. Read relevant code in `client.go`, `writer.go`, or `protocol/`

2. Implement feature following Go standards

3. Generate mocks if interfaces changed: `make generate`

4. Write unit tests using `testify/require`

5. Add integration tests in `tests/` using Ginkgo/Gomega

6. Run quality checks: `make fmt && make lint && make test`

**Example 3: User wants to profile performance impact**

```bash

cd perf

make profile-baseline # Before changes

User makes optimization

make profile-cpu # Profile CPU

make profile-compare # Compare results

```

**Example 4: User asks about architecture decisions**

Explain the stateless design principle: nanogit operates without a local .git directory, making it ideal for ephemeral cloud environments where persistent filesystem state is undesirable. Storage is abstracted via context, allowing custom backends (object storage, databases, etc.) instead of requiring local disk access.

Constraints

Important Notes