Initial commit

Author: chrislloyd

.github/workflows/main.yml

@@ -0,0 +1,35 @@
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+  workflow_dispatch:
+
+jobs:
+  main:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.14.0
+
+      - name: Install dependencies (Ubuntu)
+        if: matrix.os == 'ubuntu-latest'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y sqlite3 libsqlite3-dev libgit2-dev
+
+      - name: Install dependencies (macOS)
+        if: matrix.os == 'macos-latest'
+        run: |
+          brew install sqlite libgit2
+
+      - run: zig build
+
+      - run: zig build test

.gitignore

@@ -0,0 +1,3 @@
+.zig-cache
+zig-out
+.claude

CLAUDE.md

@@ -0,0 +1,14 @@
+# CLAUDE.md
+
+This file provides guidance to [Claude Code](https://claude.ai/code) when working with code in [this repository](https://github.com/chrislloyd/git-remote-sqlite).
+
+Refer to:
+
+* @docs/development.md
+* @docs/style.md
+
+Some tips:
+
+* Any time you make something consistent, please document the decision in @docs/style.md.
+* Always write in a terse, to the point style.
+* The tests are fast and easy to run (`zig build test`) - always run them after refactoring.

LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2025 Chris Lloyd <chris@chrislloyd.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,198 @@
+# git-remote-sqlite
+
+- [Latest release](https://github.com/chrislloyd/git-remote-sqlite/releases/latest)
+- [Latest changes](https://github.com/chrislloyd/git-remote-sqlite/commits/main)
+- [Source code](https://github.com/chrislloyd/git-remote-sqlite)
+
+---
+
+**git-remote-sqlite(1)** is a [Git protocol helper](https://git-scm.com/docs/gitremote-helpers) that helps you store a Git repository in a [SQLite](https://www.sqlite.org) database. Why would you want to do this?
+
+1. **Simple Git hosting**. Hosting git repositories typically involves using a third-party forge like GitHub or Sourcehut. These provide value by automating hosting NFS mounts and providing a web interface for collaboration.
+2. **Self-contained application bundle**. It serves as both a Git repository hosting alternative and enables Lisp/Smalltalk-style development images where code and its runtime state coexist.
+3. **(Advanced) More control over automation**. Leveraging Git hooks lets you transactionally automate tasks like migrations.
+4. **(Advanced) Build your own workflows**. An application can be built that is self-updating - you don't need to rely on pull-requests or emails etc. to update your application, you can easily build updating itself into your application.
+
+## Installation
+
+### Prerequisites
+
+- Git (version 2.25+)
+- SQLite (version 3.30+)
+- Zig (version 0.14.0) - only needed if building from source
+
+### Using Pre-built Binaries (Recommended)
+
+1. Download the latest release for your platform:
+
+   ```bash
+   # macOS
+   curl -L https://github.com/chrislloyd/git-remote-sqlite/releases/latest/download/git-remote-sqlite-macos -o git-remote-sqlite
+
+   # Linux
+   curl -L https://github.com/chrislloyd/git-remote-sqlite/releases/latest/download/git-remote-sqlite-linux -o git-remote-sqlite
+   ```
+
+2. Make the binary executable:
+
+   ```bash
+   chmod +x git-remote-sqlite
+   ```
+
+3. Move the binary to your `$PATH`:
+
+   ```bash
+   sudo mv git-remote-sqlite /usr/local/bin/
+   ```
+
+4. The installation is complete. The binary functions as both a standalone command and as a Git remote helper.
+
+### Building from Source
+
+1. Clone the repository:
+
+   ```bash
+   git clone https://github.com/chrislloyd/git-remote-sqlite.git
+   cd git-remote-sqlite
+   ```
+
+2. Build the binary using Zig:
+
+   ```bash
+   zig build
+   ```
+
+3. Copy the binary to your path:
+
+   ```bash
+   sudo cp zig-out/bin/git-remote-sqlite /usr/local/bin/
+   ```
+
+4. The installation is complete. The binary functions as both a standalone command and as a Git remote helper.
+
+## Basic Usage
+
+### 1. Configure Repository Settings
+
+You can configure server-side git settings stored in the SQLite database:
+
+```bash
+# Set configuration variables (similar to editing server-side git config)
+git-remote-sqlite config myapp.db receive.denyDeletes true
+git-remote-sqlite config myapp.db receive.denyNonFastForwards true
+
+# List all configured settings
+git-remote-sqlite config myapp.db --list
+
+# Get a specific setting value
+git-remote-sqlite config myapp.db --get receive.denyDeletes
+
+# Remove a setting
+git-remote-sqlite config myapp.db --unset receive.denyDeletes
+```
+
+These settings are stored in the `git_config` table and affect how git operations are processed when interacting with the SQLite repository.
+
+### 2. Push Code to the Database (Coming Soon)
+
+Push your code to the SQLite database:
+
+```bash
+git push sqlite://myapp.db main
+```
+
+### 3. Use as a Git Remote (Coming Soon)
+
+Add the database as a git remote:
+
+```bash
+# In your existing git repository
+git remote add origin sqlite://myapp.db
+
+# Note: 'origin' is just a name for the remote - you can use any name you prefer
+```
+
+### 4. Checkout Code from the Database (Coming Soon)
+
+Checkout a specific commit from the database:
+
+```bash
+git checkout sqlite://myapp.db main
+```
+
+This will extract the specified commit to the current directory.
+
+## Development Status
+
+Currently implemented:
+- [x] Configuration management (set, get, list, unset)
+- [ ] Git remote helper protocol (push/pull functionality)
+- [ ] Git hooks
+- [ ] Pack file management (tables defined but not yet implemented)
+
+## Database Schema
+
+**git_objects**: Stores git objects (blobs, trees, commits, tags)
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `sha` | TEXT | PRIMARY KEY, CHECK(length(sha) = 40 AND sha GLOB '[0-9a-f]*') | Object SHA hash |
+| `type` | TEXT | NOT NULL, CHECK(type IN ('blob', 'tree', 'commit', 'tag')) | Object type (blob, tree, commit, tag) |
+| `data` | BLOB | NOT NULL | Object content |
+
+*Indexes:*
+- `CREATE INDEX idx_git_objects_type ON git_objects(type);` - For efficient queries by object type
+
+**git_refs**: Stores git references
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `name` | TEXT | PRIMARY KEY, CHECK(name GLOB 'refs/*') | Reference name (e.g., 'refs/heads/main') |
+| `sha` | TEXT | NOT NULL, FOREIGN KEY REFERENCES git_objects(sha) | Commit SHA the ref points to |
+| `type` | TEXT | NOT NULL, CHECK(type IN ('branch', 'tag', 'remote')) | Reference type (branch, tag, remote) |
+
+*Indexes:*
+- `CREATE INDEX idx_git_refs_sha ON git_refs(sha);` - For finding all refs pointing to a specific commit
+
+**git_symbolic_refs**: Stores symbolic references (like HEAD)
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `name` | TEXT | PRIMARY KEY | Symbolic reference name (e.g., 'HEAD') |
+| `target` | TEXT | NOT NULL, FOREIGN KEY REFERENCES git_refs(name) | Target reference path |
+
+**git_packs**: Stores git pack files *(pending implementation)*
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `id` | INTEGER | PRIMARY KEY | Unique pack identifier |
+| `name` | TEXT | NOT NULL, UNIQUE | Pack name/identifier |
+| `data` | BLOB | NOT NULL | Pack file binary data |
+| `index_data` | BLOB | NOT NULL | Pack index binary data |
+
+*Indexes:*
+- `CREATE INDEX idx_git_packs_name ON git_packs(name);` - For efficient lookups by pack name
+
+**git_pack_entries**: Maps objects to packs for faster lookups *(pending implementation)*
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `pack_id` | INTEGER | NOT NULL, FOREIGN KEY REFERENCES git_packs(id) | Reference to the pack |
+| `sha` | TEXT | NOT NULL, FOREIGN KEY REFERENCES git_objects(sha) | Object SHA contained in the pack |
+| `offset` | INTEGER | NOT NULL | Offset position within the pack |
+| PRIMARY KEY | | (pack_id, sha) | Composite primary key |
+
+*Indexes:*
+- `CREATE INDEX idx_git_pack_entries_sha ON git_pack_entries(sha);` - For finding which pack contains a specific object
+
+
+**git_config**: Stores git configuration settings
+
+| Column | Type | Constraints | Description |
+|--|--|--|--|
+| `key` | TEXT | PRIMARY KEY | Configuration key |
+| `value` | TEXT | NOT NULL | Configuration value |
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

build.zig

@@ -0,0 +1,121 @@
+const std = @import("std");
+const builtin = @import("builtin");
+
+comptime {
+    const expected_zig_version = std.SemanticVersion{
+        .major = 0,
+        .minor = 14,
+        .patch = 0,
+    };
+    const actual_zig_version = builtin.zig_version;
+    if (actual_zig_version.order(expected_zig_version).compare(.lt)) {
+        @compileError(std.fmt.comptimePrint(
+            "unsupported zig version: expected {}, found {}",
+            .{ expected_zig_version, actual_zig_version },
+        ));
+    }
+}
+
+pub fn build(b: *std.Build) void {
+    const steps = .{
+        .run = b.step("run", "Run git-remote-sqlite"),
+        .@"test" = b.step("test", "Run tests"),
+        .test_unit = b.step("test:unit", "Run unit tests"),
+        .test_integration = b.step("test:integration", "Run integration tests"),
+    };
+
+    const target = b.standardTargetOptions(.{});
+    const optimize = b.standardOptimizeOption(.{});
+
+    build_git_remote_sqlite(b, .{
+        .run = steps.run,
+        .install = b.getInstallStep(),
+    }, .{ .target = target, .optimize = optimize });
+
+    build_test(b, .{ .@"test" = steps.@"test", .test_unit = steps.test_unit, .test_integration = steps.test_integration }, .{ .target = target, .optimize = optimize });
+}
+
+fn build_git_remote_sqlite(b: *std.Build, steps: struct {
+    run: *std.Build.Step,
+    install: *std.Build.Step,
+}, options: struct {
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+}) void {
+    // Create a module for our main entry point
+    const main_mod = b.createModule(.{
+        .root_source_file = b.path("src/main.zig"),
+        .target = options.target,
+        .optimize = options.optimize,
+    });
+
+    // Create an executable from our module
+    const exe = b.addExecutable(.{
+        .name = "git-remote-sqlite",
+        .root_module = main_mod,
+    });
+
+    // Add system library linkage
+    exe.linkSystemLibrary("sqlite3");
+    exe.linkSystemLibrary("git2");
+
+    // This declares intent for the executable to be installed into the
+    // standard location when the user invokes the "install" step (the default
+    // step when running `zig build`).
+    b.installArtifact(exe);
+
+    // This *creates* a Run step in the build graph, to be executed when another
+    // step is evaluated that depends on it. The next line below will establish
+    // such a dependency.
+    const run_cmd = b.addRunArtifact(exe);
+
+    // By making the run step depend on the install step, it will be run from the
+    // installation directory rather than directly from within the cache directory.
+    // This is not necessary, however, if the application depends on other installed
+    // files, this ensures they will be present and in the expected location.
+    run_cmd.step.dependOn(b.getInstallStep());
+
+    // This allows the user to pass arguments to the application in the build
+    // command itself, like this: `zig build run -- arg1 arg2 etc`
+    if (b.args) |args| {
+        run_cmd.addArgs(args);
+    }
+
+    // This creates a build step. It will be visible in the `zig build --help` menu,
+    // and can be selected like this: `zig build run`
+    // This will evaluate the `run` step rather than the default, which is "install".
+    // const run_step = b.step("run", "Run the app");
+    steps.run.dependOn(&run_cmd.step);
+}
+
+fn build_test(b: *std.Build, steps: struct {
+    @"test": *std.Build.Step,
+    test_unit: *std.Build.Step,
+    test_integration: *std.Build.Step,
+}, options: struct {
+    target: std.Build.ResolvedTarget,
+    optimize: std.builtin.OptimizeMode,
+}) void {
+    const unit_mod = b.createModule(.{
+        .root_source_file = b.path("src/tests.zig"),
+        .target = options.target,
+        .optimize = options.optimize,
+    });
+    const unit = b.addTest(.{
+        .root_module = unit_mod,
+    });
+    unit.linkSystemLibrary("sqlite3");
+    unit.linkSystemLibrary("git2");
+
+    const run_unit = b.addRunArtifact(unit);
+    steps.test_unit.dependOn(&run_unit.step);
+
+    // Integration tests - run the e2e script
+    const integration_cmd = b.addSystemCommand(&[_][]const u8{ "bash", "src/e2e.sh", b.getInstallPath(.bin, "git-remote-sqlite") });
+    integration_cmd.step.dependOn(b.getInstallStep()); // Ensure binary is built first
+    steps.test_integration.dependOn(&integration_cmd.step);
+
+    // Main test step runs both unit and integration tests
+    steps.@"test".dependOn(&run_unit.step);
+    steps.@"test".dependOn(&integration_cmd.step);
+}