@jussmor/commit-memory-mcp 0.3.1

package/README.md

@@ -0,0 +1,49 @@
+# @jussmor/commit-memory-mcp
+
+Local commit-aware RAG package powered by sqlite-vec with MCP tool endpoints.
+
+## Features
+
+- Indexes git commits across branches into commit-file chunks
+- Embeds chunks using a local embedding source (Ollama when configured)
+- Stores vectors in sqlite-vec (SQLite)
+- Exposes MCP tools for agent workflows
+
+## MCP tools
+
+- `search_related_commits`
+- `explain_commit_match`
+- `get_commit_diff`
+
+## Quick start
+
+```bash
+npm install @jussmor/commit-memory-mcp
+npx commit-memory-index --repo /path/to/repo --db /path/to/repo/.commit-rag.db --limit 400
+npx commit-memory-mcp
+```
+
+## Publish
+
+```bash
+npm run build
+npm publish --access public
+mcp-publisher login github
+mcp-publisher publish
+```
+
+## VS Code MCP registration
+
+Copy `mcp.config.example.json` entries into your user MCP config and adjust paths/env values.
+
+For MCP Registry publication, keep `package.json` `mcpName` and `server.json` `name` in sync.
+
+## Environment
+
+- `COMMIT_RAG_REPO` default repository path for MCP
+- `COMMIT_RAG_DB` sqlite db path
+- `COMMIT_RAG_LIMIT` max commits to index per run
+- `OLLAMA_BASE_URL` local ollama URL (default `http://127.0.0.1:11434`)
+- `OLLAMA_EMBED_MODEL` local embedding model name
+
+If `OLLAMA_EMBED_MODEL` is not set, the package uses deterministic local fallback embeddings.

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+import path from "node:path";
+import { indexRepository } from "../indexer.js";
+function parseArgs(argv) {
+    const args = {
+        repoPath: process.cwd(),
+        dbPath: path.resolve(process.cwd(), ".commit-rag.db"),
+        limit: 400,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg === "--repo") {
+            args.repoPath = path.resolve(argv[i + 1] ?? process.cwd());
+            i += 1;
+            continue;
+        }
+        if (arg === "--db") {
+            args.dbPath = path.resolve(argv[i + 1] ?? ".commit-rag.db");
+            i += 1;
+            continue;
+        }
+        if (arg === "--limit") {
+            const value = Number.parseInt(argv[i + 1] ?? "", 10);
+            if (!Number.isFinite(value) || value <= 0) {
+                throw new Error("Invalid --limit value");
+            }
+            args.limit = value;
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return args;
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    const summary = await indexRepository(args);
+    process.stdout.write(`${JSON.stringify(summary, null, 2)}\n`);
+}
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    process.stderr.write(`${message}\n`);
+    process.exitCode = 1;
+});

package/dist/db/client.d.ts

@@ -0,0 +1,7 @@
+import Database from "better-sqlite3";
+import type { CommitChunk } from "../types.js";
+export type RagDatabase = Database.Database;
+export declare function openDatabase(dbPath: string): RagDatabase;
+export declare function hasChunk(db: RagDatabase, chunkId: string): boolean;
+export declare function upsertChunk(db: RagDatabase, chunk: CommitChunk, embedding: number[]): void;
+export declare function touchIndexState(db: RagDatabase): void;

package/dist/db/client.js

@@ -0,0 +1,92 @@
+import Database from "better-sqlite3";
+import fs from "node:fs";
+import path from "node:path";
+import { load } from "sqlite-vec";
+export function openDatabase(dbPath) {
+    const resolved = path.resolve(dbPath);
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    const db = new Database(resolved);
+    load(db);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS commits (
+      sha TEXT PRIMARY KEY,
+      author TEXT NOT NULL,
+      date TEXT NOT NULL,
+      subject TEXT NOT NULL,
+      body TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS commit_chunks (
+      chunk_id TEXT PRIMARY KEY,
+      sha TEXT NOT NULL,
+      file_path TEXT NOT NULL,
+      hunk_text TEXT NOT NULL,
+      indexed_text TEXT NOT NULL,
+      FOREIGN KEY (sha) REFERENCES commits(sha)
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS chunk_vectors USING vec0(
+      embedding FLOAT[384]
+    );
+
+    CREATE TABLE IF NOT EXISTS chunk_vector_map (
+      chunk_id TEXT PRIMARY KEY,
+      vec_rowid INTEGER NOT NULL UNIQUE,
+      FOREIGN KEY (chunk_id) REFERENCES commit_chunks(chunk_id)
+    );
+
+    CREATE TABLE IF NOT EXISTS index_state (
+      id INTEGER PRIMARY KEY CHECK (id = 1),
+      last_indexed_at TEXT NOT NULL
+    );
+  `);
+    return db;
+}
+export function hasChunk(db, chunkId) {
+    const row = db
+        .prepare("SELECT 1 AS ok FROM commit_chunks WHERE chunk_id = ? LIMIT 1")
+        .get(chunkId);
+    return Boolean(row?.ok);
+}
+export function upsertChunk(db, chunk, embedding) {
+    db.prepare(`
+      INSERT INTO commits (sha, author, date, subject, body)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(sha) DO UPDATE SET
+        author = excluded.author,
+        date = excluded.date,
+        subject = excluded.subject,
+        body = excluded.body
+    `).run(chunk.sha, chunk.author, chunk.date, chunk.subject, chunk.body);
+    db.prepare(`
+      INSERT INTO commit_chunks (chunk_id, sha, file_path, hunk_text, indexed_text)
+      VALUES (?, ?, ?, ?, ?)
+      ON CONFLICT(chunk_id) DO UPDATE SET
+        sha = excluded.sha,
+        file_path = excluded.file_path,
+        hunk_text = excluded.hunk_text,
+        indexed_text = excluded.indexed_text
+    `).run(chunk.chunkId, chunk.sha, chunk.filePath, chunk.hunkText, chunk.indexedText);
+    const existing = db
+        .prepare("SELECT vec_rowid FROM chunk_vector_map WHERE chunk_id = ?")
+        .get(chunk.chunkId);
+    const embeddingJson = JSON.stringify(embedding);
+    if (existing) {
+        db.prepare("UPDATE chunk_vectors SET embedding = ? WHERE rowid = ?").run(embeddingJson, existing.vec_rowid);
+        return;
+    }
+    const result = db
+        .prepare("INSERT INTO chunk_vectors (embedding) VALUES (?)")
+        .run(embeddingJson);
+    const rowid = Number(result.lastInsertRowid);
+    db.prepare("INSERT INTO chunk_vector_map (chunk_id, vec_rowid) VALUES (?, ?)").run(chunk.chunkId, rowid);
+}
+export function touchIndexState(db) {
+    const now = new Date().toISOString();
+    db.prepare(`
+      INSERT INTO index_state (id, last_indexed_at)
+      VALUES (1, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        last_indexed_at = excluded.last_indexed_at
+    `).run(now);
+}

package/dist/git/extract.d.ts

@@ -0,0 +1,2 @@
+import type { CommitChunk } from "../types.js";
+export declare function extractCommitChunks(repoPath: string, limit: number): CommitChunk[];

package/dist/git/extract.js

@@ -0,0 +1,97 @@
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+function runGit(repoPath, args) {
+    return execFileSync("git", ["-C", repoPath, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function getChangedLines(patch) {
+    return patch
+        .split("\n")
+        .filter((line) => (line.startsWith("+") || line.startsWith("-")) &&
+        !line.startsWith("+++") &&
+        !line.startsWith("---"))
+        .slice(0, 120);
+}
+function createChunkId(sha, filePath, text) {
+    const hash = crypto
+        .createHash("sha256")
+        .update(text)
+        .digest("hex")
+        .slice(0, 16);
+    return `${sha}:${filePath}:${hash}`;
+}
+export function extractCommitChunks(repoPath, limit) {
+    const shaOutput = runGit(repoPath, [
+        "log",
+        "--all",
+        "--format=%H",
+        `-n${limit}`,
+    ]).trim();
+    if (!shaOutput) {
+        return [];
+    }
+    const shas = shaOutput
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const chunks = [];
+    for (const sha of shas) {
+        const meta = runGit(repoPath, [
+            "show",
+            "--no-color",
+            "--format=%an%x1f%aI%x1f%s%x1f%b",
+            "--no-patch",
+            sha,
+        ]).trimEnd();
+        const [author = "", date = "", subject = "", body = ""] = meta.split("\x1f");
+        const filesRaw = runGit(repoPath, [
+            "show",
+            "--no-color",
+            "--pretty=format:",
+            "--name-only",
+            sha,
+        ]).trim();
+        const files = Array.from(new Set(filesRaw
+            .split("\n")
+            .map((line) => line.trim())
+            .filter(Boolean)));
+        for (const filePath of files) {
+            const patch = runGit(repoPath, [
+                "show",
+                "--no-color",
+                "--pretty=format:",
+                "--unified=0",
+                sha,
+                "--",
+                filePath,
+            ]).trim();
+            const changedLines = getChangedLines(patch);
+            const hunkText = changedLines.join("\n");
+            if (!hunkText) {
+                continue;
+            }
+            const indexedText = [
+                `subject: ${subject}`,
+                `body: ${body}`,
+                `file: ${filePath}`,
+                "changes:",
+                hunkText,
+            ].join("\n");
+            const chunkId = createChunkId(sha, filePath, indexedText);
+            chunks.push({
+                chunkId,
+                sha,
+                author,
+                date,
+                subject,
+                body,
+                filePath,
+                hunkText,
+                indexedText,
+            });
+        }
+    }
+    return chunks;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { openDatabase } from "./db/client.js";
+export { indexRepository } from "./indexer.js";
+export { explainCommitMatch, searchRelatedCommits } from "./search/query.js";
+export type { CommitChunk, IndexSummary, SearchResult } from "./types.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export { openDatabase } from "./db/client.js";
+export { indexRepository } from "./indexer.js";
+export { explainCommitMatch, searchRelatedCommits } from "./search/query.js";

package/dist/indexer.d.ts

@@ -0,0 +1,6 @@
+import type { IndexSummary } from "./types.js";
+export declare function indexRepository(options: {
+    repoPath: string;
+    dbPath: string;
+    limit: number;
+}): Promise<IndexSummary>;

package/dist/indexer.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { hasChunk, openDatabase, touchIndexState, upsertChunk, } from "./db/client.js";
+import { extractCommitChunks } from "./git/extract.js";
+import { embedText } from "./search/embeddings.js";
+export async function indexRepository(options) {
+    const repoPath = path.resolve(options.repoPath);
+    const dbPath = path.resolve(options.dbPath);
+    const chunks = extractCommitChunks(repoPath, options.limit);
+    const db = openDatabase(dbPath);
+    let indexedChunks = 0;
+    let skippedChunks = 0;
+    const indexedCommits = new Set();
+    const pendingInserts = [];
+    for (const chunk of chunks) {
+        if (hasChunk(db, chunk.chunkId)) {
+            skippedChunks += 1;
+            continue;
+        }
+        const embedding = await embedText(chunk.indexedText);
+        pendingInserts.push({ chunk, embedding });
+        indexedChunks += 1;
+        indexedCommits.add(chunk.sha);
+    }
+    const writeTransaction = db.transaction((rows) => {
+        for (const row of rows) {
+            upsertChunk(db, row.chunk, row.embedding);
+        }
+    });
+    writeTransaction(pendingInserts);
+    touchIndexState(db);
+    db.close();
+    return {
+        indexedCommits: indexedCommits.size,
+        indexedChunks,
+        skippedChunks,
+    };
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { openDatabase } from "../db/client.js";
+import { indexRepository } from "../indexer.js";
+import { explainCommitMatch, searchRelatedCommits } from "../search/query.js";
+function runGitDiff(repoPath, sha) {
+    return execFileSync("git", ["-C", repoPath, "show", "--no-color", "--stat", "--patch", sha], {
+        encoding: "utf8",
+    });
+}
+function getConfig() {
+    const repoPath = path.resolve(process.env.COMMIT_RAG_REPO ?? process.cwd());
+    const dbPath = path.resolve(process.env.COMMIT_RAG_DB ?? path.join(repoPath, ".commit-rag.db"));
+    const limit = Number.parseInt(process.env.COMMIT_RAG_LIMIT ?? "", 10) || 400;
+    return { repoPath, dbPath, limit };
+}
+export async function startMcpServer() {
+    const server = new Server({
+        name: "commit-memory-mcp",
+        version: "0.3.1",
+    }, {
+        capabilities: {
+            tools: {},
+        },
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            {
+                name: "search_related_commits",
+                description: "Find commit chunks semantically related to current work context.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        query: { type: "string" },
+                        activeFile: { type: "string" },
+                        limit: { type: "number" },
+                    },
+                    required: ["query"],
+                },
+            },
+            {
+                name: "explain_commit_match",
+                description: "Return contextual details for a chunk match.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        chunkId: { type: "string" },
+                    },
+                    required: ["chunkId"],
+                },
+            },
+            {
+                name: "get_commit_diff",
+                description: "Get full git show output for a commit SHA.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        sha: { type: "string" },
+                    },
+                    required: ["sha"],
+                },
+            },
+            {
+                name: "reindex_commits",
+                description: "Refresh commit index from git history.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        limit: { type: "number" },
+                    },
+                    required: [],
+                },
+            },
+        ],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { repoPath, dbPath, limit: defaultLimit } = getConfig();
+        if (request.params.name === "reindex_commits") {
+            const limit = Number(request.params.arguments?.limit ?? defaultLimit);
+            const summary = await indexRepository({ repoPath, dbPath, limit });
+            return {
+                content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+            };
+        }
+        const db = openDatabase(dbPath);
+        try {
+            if (request.params.name === "search_related_commits") {
+                const query = String(request.params.arguments?.query ?? "").trim();
+                const activeFile = request.params.arguments?.activeFile
+                    ? String(request.params.arguments.activeFile)
+                    : undefined;
+                const limit = Number(request.params.arguments?.limit ?? 8);
+                if (!query) {
+                    return {
+                        content: [{ type: "text", text: "query is required" }],
+                        isError: true,
+                    };
+                }
+                const results = await searchRelatedCommits(db, query, limit, activeFile);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                };
+            }
+            if (request.params.name === "explain_commit_match") {
+                const chunkId = String(request.params.arguments?.chunkId ?? "").trim();
+                if (!chunkId) {
+                    return {
+                        content: [{ type: "text", text: "chunkId is required" }],
+                        isError: true,
+                    };
+                }
+                const result = explainCommitMatch(db, chunkId);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                };
+            }
+            if (request.params.name === "get_commit_diff") {
+                const sha = String(request.params.arguments?.sha ?? "").trim();
+                if (!sha) {
+                    return {
+                        content: [{ type: "text", text: "sha is required" }],
+                        isError: true,
+                    };
+                }
+                const output = runGitDiff(repoPath, sha);
+                return {
+                    content: [{ type: "text", text: output }],
+                };
+            }
+            return {
+                content: [
+                    { type: "text", text: `Unknown tool: ${request.params.name}` },
+                ],
+                isError: true,
+            };
+        }
+        finally {
+            db.close();
+        }
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    startMcpServer().catch((error) => {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 1;
+    });
+}

package/dist/search/embeddings.d.ts

@@ -0,0 +1,2 @@
+export declare function embedText(text: string): Promise<number[]>;
+export declare function getExpectedDimension(): number;

package/dist/search/embeddings.js

@@ -0,0 +1,60 @@
+const FALLBACK_DIMENSION = 384;
+function hashToken(token) {
+    let hash = 2166136261;
+    for (let i = 0; i < token.length; i += 1) {
+        hash ^= token.charCodeAt(i);
+        hash +=
+            (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+    return Math.abs(hash >>> 0);
+}
+function normalize(values) {
+    const magnitude = Math.sqrt(values.reduce((sum, value) => sum + value * value, 0));
+    if (!Number.isFinite(magnitude) || magnitude === 0) {
+        return values;
+    }
+    return values.map((value) => value / magnitude);
+}
+function fallbackEmbedding(text) {
+    const vector = new Array(FALLBACK_DIMENSION).fill(0);
+    const tokens = text
+        .toLowerCase()
+        .split(/[^a-z0-9_]+/)
+        .filter(Boolean);
+    for (const token of tokens) {
+        const index = hashToken(token) % FALLBACK_DIMENSION;
+        vector[index] += 1;
+    }
+    return normalize(vector);
+}
+export async function embedText(text) {
+    const model = process.env.OLLAMA_EMBED_MODEL;
+    if (!model) {
+        return fallbackEmbedding(text);
+    }
+    const baseUrl = process.env.OLLAMA_BASE_URL ?? "http://127.0.0.1:11434";
+    const response = await fetch(`${baseUrl}/api/embeddings`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            model,
+            prompt: text,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Embedding request failed: ${response.status}`);
+    }
+    const payload = (await response.json());
+    if (!payload.embedding || !Array.isArray(payload.embedding)) {
+        throw new Error("Embedding response missing vector");
+    }
+    return normalize(payload.embedding);
+}
+export function getExpectedDimension() {
+    return process.env.OLLAMA_EMBED_MODEL
+        ? Number.parseInt(process.env.COMMIT_RAG_DIMENSION ?? "", 10) ||
+            FALLBACK_DIMENSION
+        : FALLBACK_DIMENSION;
+}

package/dist/search/query.d.ts

@@ -0,0 +1,4 @@
+import type { Database } from "better-sqlite3";
+import type { SearchResult } from "../types.js";
+export declare function searchRelatedCommits(db: Database, query: string, limit: number, activeFile?: string): Promise<SearchResult[]>;
+export declare function explainCommitMatch(db: Database, chunkId: string): SearchResult | null;

package/dist/search/query.js

@@ -0,0 +1,115 @@
+import { embedText } from "./embeddings.js";
+function scoreWithBoost(base, row, activeFile) {
+    let score = base;
+    if (activeFile && row.file_path === activeFile) {
+        score += 0.2;
+    }
+    if (activeFile) {
+        const parent = activeFile.split("/").slice(0, -1).join("/");
+        if (parent && row.file_path.startsWith(parent)) {
+            score += 0.05;
+        }
+    }
+    return score;
+}
+function createPreview(hunkText) {
+    return hunkText.split("\n").slice(0, 6).join("\n");
+}
+export async function searchRelatedCommits(db, query, limit, activeFile) {
+    const embedding = await embedText(query);
+    const embeddingJson = JSON.stringify(embedding);
+    try {
+        const rows = db
+            .prepare(`
+        SELECT
+          v.distance AS distance,
+          c.chunk_id AS chunk_id,
+          c.sha AS sha,
+          c.file_path AS file_path,
+          cm.subject AS subject,
+          cm.date AS date,
+          cm.author AS author,
+          c.hunk_text AS hunk_text
+        FROM chunk_vectors v
+        JOIN chunk_vector_map m ON m.vec_rowid = v.rowid
+        JOIN commit_chunks c ON c.chunk_id = m.chunk_id
+        JOIN commits cm ON cm.sha = c.sha
+        WHERE v.embedding MATCH ? AND k = ?
+      `)
+            .all(embeddingJson, limit);
+        return rows.map((row) => {
+            const base = 1 / (1 + Math.max(0, row.distance));
+            const score = scoreWithBoost(base, row, activeFile);
+            return {
+                chunkId: row.chunk_id,
+                sha: row.sha,
+                filePath: row.file_path,
+                subject: row.subject,
+                score,
+                date: row.date,
+                author: row.author,
+                preview: createPreview(row.hunk_text),
+            };
+        });
+    }
+    catch {
+        const rows = db
+            .prepare(`
+        SELECT
+          c.chunk_id AS chunk_id,
+          c.sha AS sha,
+          c.file_path AS file_path,
+          cm.subject AS subject,
+          cm.date AS date,
+          cm.author AS author,
+          c.hunk_text AS hunk_text
+        FROM commit_chunks c
+        JOIN commits cm ON cm.sha = c.sha
+        WHERE c.indexed_text LIKE ?
+        ORDER BY cm.date DESC
+        LIMIT ?
+      `)
+            .all(`%${query}%`, limit);
+        return rows.map((row, idx) => ({
+            chunkId: row.chunk_id,
+            sha: row.sha,
+            filePath: row.file_path,
+            subject: row.subject,
+            score: scoreWithBoost(Math.max(0.01, 1 - idx / (limit + 1)), row, activeFile),
+            date: row.date,
+            author: row.author,
+            preview: createPreview(row.hunk_text),
+        }));
+    }
+}
+export function explainCommitMatch(db, chunkId) {
+    const row = db
+        .prepare(`
+      SELECT
+        c.chunk_id AS chunk_id,
+        c.sha AS sha,
+        c.file_path AS file_path,
+        cm.subject AS subject,
+        cm.date AS date,
+        cm.author AS author,
+        c.hunk_text AS hunk_text
+      FROM commit_chunks c
+      JOIN commits cm ON cm.sha = c.sha
+      WHERE c.chunk_id = ?
+      LIMIT 1
+    `)
+        .get(chunkId);
+    if (!row) {
+        return null;
+    }
+    return {
+        chunkId: row.chunk_id,
+        sha: row.sha,
+        filePath: row.file_path,
+        subject: row.subject,
+        score: 1,
+        date: row.date,
+        author: row.author,
+        preview: createPreview(row.hunk_text),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export type CommitChunk = {
+    chunkId: string;
+    sha: string;
+    author: string;
+    date: string;
+    subject: string;
+    body: string;
+    filePath: string;
+    hunkText: string;
+    indexedText: string;
+};
+export type SearchResult = {
+    chunkId: string;
+    sha: string;
+    filePath: string;
+    subject: string;
+    score: number;
+    date: string;
+    author: string;
+    preview: string;
+};
+export type IndexSummary = {
+    indexedCommits: number;
+    indexedChunks: number;
+    skippedChunks: number;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@jussmor/commit-memory-mcp",
+  "version": "0.3.1",
+  "mcpName": "io.github.jussmor/commit-memory",
+  "description": "Commit-aware RAG with sqlite-vec and MCP tools for local agent workflows",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/JussMor/commit-memory-mcp.git"
+  },
+  "homepage": "https://github.com/JussMor/commit-memory-mcp",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp/server.d.ts",
+      "import": "./dist/mcp/server.js"
+    }
+  },
+  "bin": {
+    "commit-memory-mcp": "./dist/mcp/server.js",
+    "commit-memory-index": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist",
+    "server.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.11.0",
+    "better-sqlite3": "^11.10.0",
+    "sqlite-vec": "^0.1.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.15.3",
+    "typescript": "^5.8.3"
+  }
+}

package/server.json

@@ -0,0 +1,58 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.jussmor/commit-memory",
+  "description": "Local commit-aware RAG MCP server for semantic git history search using SQLite vectors.",
+  "repository": {
+    "url": "https://github.com/JussMor/commit-memory-mcp",
+    "source": "github"
+  },
+  "version": "0.3.1",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "@jussmor/commit-memory-mcp",
+      "version": "0.3.1",
+      "transport": {
+        "type": "stdio"
+      },
+      "runtimeHint": "npx",
+      "environmentVariables": [
+        {
+          "name": "COMMIT_RAG_REPO",
+          "description": "Absolute path to the target git repository.",
+          "format": "string",
+          "isRequired": true,
+          "isSecret": false
+        },
+        {
+          "name": "COMMIT_RAG_DB",
+          "description": "Absolute path to the SQLite database file.",
+          "format": "string",
+          "isRequired": false,
+          "isSecret": false
+        },
+        {
+          "name": "COMMIT_RAG_LIMIT",
+          "description": "Maximum number of commits to index per run.",
+          "format": "string",
+          "isRequired": false,
+          "isSecret": false
+        },
+        {
+          "name": "OLLAMA_BASE_URL",
+          "description": "Ollama base URL for embedding requests.",
+          "format": "string",
+          "isRequired": false,
+          "isSecret": false
+        },
+        {
+          "name": "OLLAMA_EMBED_MODEL",
+          "description": "Embedding model name to use with Ollama.",
+          "format": "string",
+          "isRequired": false,
+          "isSecret": false
+        }
+      ]
+    }
+  ]
+}