@jussmor/commit-memory-mcp 0.4.1 → 0.4.3

package/README.md

@@ -108,7 +108,8 @@ build_context_pack({
 ```
 
 Use this before invoking a coding subagent to keep prompts small and focused.
-If no rows are found in strict scope, the server now falls back automatically to broader scope levels.
+The pack is assembled main-first: promoted facts on `main` are treated as baseline truth, then branch/feature facts are added as in-flight overlay.
+If no rows are found in strict scope, the server falls back automatically to broader scope levels.
 
 Important: if you provide `domain`/`feature`/`branch` tags in `build_context_pack`, use the same tags during `sync_pr_context` for best precision.
 

package/dist/db/client.d.ts

@@ -25,7 +25,14 @@ export declare function buildContextPack(db: RagDatabase, options: {
     taskType?: string;
     includeDraft?: boolean;
     limit: number;
-}): ContextPackRecord[];
+    forceRefresh?: boolean;
+    summarizePR?: boolean;
+}): {
+    learnedFeature: ContextPackRecord[];
+    branchContext: ContextPackRecord[];
+    prMetadata: ContextPackRecord[];
+    allContext: ContextPackRecord[];
+};
 export declare function archiveFeatureContext(db: RagDatabase, options: {
     domain: string;
     feature: string;

package/dist/db/client.js

@@ -7,6 +7,10 @@ export function openDatabase(dbPath) {
     fs.mkdirSync(path.dirname(resolved), { recursive: true });
     const db = new Database(resolved);
     load(db);
+    // Enable WAL mode and ensure data is persisted to disk
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("foreign_keys = ON");
     db.exec(`
     CREATE TABLE IF NOT EXISTS commits (
       sha TEXT PRIMARY KEY,
@@ -370,8 +374,17 @@ export function promoteContextFacts(db, options) {
     const result = db.prepare(sql).run(now, ...params);
     return Number(result.changes ?? 0);
 }
+function summarizePRMetadata(fact) {
+    // Extract key info from PR metadata to keep it concise
+    if (fact.sourceType.startsWith("pr_")) {
+        const lines = fact.content.split("\n").slice(0, 2).join(" ");
+        return `[${fact.sourceRef}] ${fact.title} — ${lines.substring(0, 100)}`;
+    }
+    return fact.content;
+}
 export function buildContextPack(db, options) {
     const taskType = options.taskType ?? "general";
+    const GLOBAL_BRANCH = "main";
     function runQuery(params) {
         const clauses = [];
         const values = [taskType];
@@ -383,7 +396,11 @@ export function buildContextPack(db, options) {
             clauses.push("scope_feature = ?");
             values.push(options.feature);
         }
-        if (params.includeBranch && options.branch) {
+        if (params.forcedBranch) {
+            clauses.push("scope_branch = ?");
+            values.push(params.forcedBranch);
+        }
+        else if (params.includeBranch && options.branch) {
             clauses.push("scope_branch = ?");
             values.push(options.branch);
         }
@@ -444,27 +461,144 @@ export function buildContextPack(db, options) {
             updatedAt: String(row.updated_at ?? ""),
         }));
     }
-    const strictRows = runQuery({
+    const seenIds = new Set();
+    const pack = [];
+    const addRows = (rows) => {
+        for (const row of rows) {
+            if (pack.length >= options.limit) {
+                return;
+            }
+            if (seenIds.has(row.id)) {
+                continue;
+            }
+            seenIds.add(row.id);
+            pack.push(row);
+        }
+    };
+    // PRIORITY 0) Learned feature knowledge is always included first when available.
+    // This ensures feature knowledge isn't lost behind PR metadata.
+    if (!options.feature && !options.branch) {
+        // Auto-discover recently learned features (source_type='feature-agent')
+        const learnedFacts = db.prepare(`
+        SELECT
+          id,
+          source_type,
+          source_ref,
+          title,
+          content,
+          scope_domain,
+          scope_feature,
+          scope_branch,
+          scope_task_type,
+          priority,
+          confidence,
+          status,
+          updated_at,
+          ((priority * 0.40) + (confidence * 0.30) + 0.25) AS score
+        FROM context_facts
+        WHERE source_type = 'feature-agent' AND status = 'promoted'
+        ORDER BY updated_at DESC, priority DESC
+        LIMIT ?
+      `).all(Math.max(3, Math.floor(options.limit * 0.2)));
+        const learnedRows = learnedFacts.map((row) => ({
+            id: String(row.id ?? ""),
+            sourceType: String(row.source_type ?? ""),
+            sourceRef: String(row.source_ref ?? ""),
+            title: String(row.title ?? ""),
+            content: String(row.content ?? ""),
+            domain: String(row.scope_domain ?? ""),
+            feature: String(row.scope_feature ?? ""),
+            branch: String(row.scope_branch ?? ""),
+            taskType: String(row.scope_task_type ?? ""),
+            priority: Number(row.priority ?? 0),
+            confidence: Number(row.confidence ?? 0),
+            score: Number(row.score ?? 0),
+            status: String(row.status ?? "promoted"),
+            updatedAt: String(row.updated_at ?? ""),
+        }));
+        addRows(learnedRows);
+    }
+    // 1) Main branch domain context is the durable source-of-truth baseline.
+    if (pack.length < options.limit) {
+        addRows(runQuery({
+            includeDomain: true,
+            includeFeature: false,
+            includeBranch: false,
+            forcedBranch: GLOBAL_BRANCH,
+        }));
+    }
+    // 2) Main branch global context fills any remaining baseline slots.
+    if (pack.length < options.limit) {
+        addRows(runQuery({
+            includeDomain: false,
+            includeFeature: false,
+            includeBranch: false,
+            forcedBranch: GLOBAL_BRANCH,
+        }));
+    }
+    // 3) Branch-local feature context overlays main for active, in-flight work.
+    addRows(runQuery({
         includeDomain: true,
         includeFeature: true,
         includeBranch: true,
-    });
-    if (strictRows.length > 0) {
-        return strictRows;
+    }));
+    // 4) Domain-wide branch context provides additional short-lived signal.
+    if (pack.length < options.limit) {
+        addRows(runQuery({
+            includeDomain: true,
+            includeFeature: false,
+            includeBranch: false,
+        }));
     }
-    const broadRows = runQuery({
-        includeDomain: true,
-        includeFeature: false,
-        includeBranch: false,
-    });
-    if (broadRows.length > 0) {
-        return broadRows;
+    // 5) Final safety net from all promoted context.
+    if (pack.length < options.limit) {
+        addRows(runQuery({
+            includeDomain: false,
+            includeFeature: false,
+            includeBranch: false,
+        }));
     }
-    return runQuery({
-        includeDomain: false,
-        includeFeature: false,
-        includeBranch: false,
-    });
+    // Categorize results and apply summarization if requested
+    const learnedFeature = [];
+    const branchContext = [];
+    const prMetadata = [];
+    for (const item of pack) {
+        if (item.sourceType === "feature-agent") {
+            learnedFeature.push(item);
+        }
+        else if (item.sourceType.startsWith("pr_")) {
+            if (options.summarizePR) {
+                prMetadata.push({
+                    ...item,
+                    content: summarizePRMetadata(item),
+                });
+            }
+            else {
+                prMetadata.push(item);
+            }
+        }
+        else if (item.branch && item.branch !== "main") {
+            branchContext.push(item);
+        }
+        else {
+            // Fallback for other context types
+            if (options.summarizePR && item.sourceType.startsWith("pr_")) {
+                branchContext.push({
+                    ...item,
+                    content: summarizePRMetadata(item),
+                });
+            }
+            else {
+                branchContext.push(item);
+            }
+        }
+    }
+    return {
+        learnedFeature,
+        branchContext,
+        prMetadata,
+        allContext: pack,
+    };
 }
 export function archiveFeatureContext(db, options) {
     const now = new Date().toISOString();

package/dist/mcp/server.js

@@ -175,7 +175,7 @@ export async function startMcpServer() {
             },
             {
                 name: "build_context_pack",
-                description: "Build a scoped context pack for a task/domain/feature/branch to keep agent prompts small.",
+                description: "Build a scoped context pack for a task/domain/feature/branch. Returns learned feature knowledge, branch context, and PR metadata separately.",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -185,6 +185,14 @@ export async function startMcpServer() {
                         taskType: { type: "string" },
                         includeDraft: { type: "boolean" },
                         limit: { type: "number" },
+                        forceRefresh: {
+                            type: "boolean",
+                            description: "Re-run learn_feature to update feature knowledge",
+                        },
+                        summarizePR: {
+                            type: "boolean",
+                            description: "Return PR metadata as summaries instead of full content",
+                        },
                     },
                     required: [],
                 },
@@ -390,6 +398,8 @@ export async function startMcpServer() {
             const branch = String(request.params.arguments?.branch ?? "").trim();
             const taskType = String(request.params.arguments?.taskType ?? "").trim() || "general";
             const includeDraft = Boolean(request.params.arguments?.includeDraft);
+            const forceRefresh = Boolean(request.params.arguments?.forceRefresh);
+            const summarizePR = Boolean(request.params.arguments?.summarizePR);
             const db = openDatabase(dbPath);
             try {
                 const pack = buildContextPack(db, {
@@ -399,6 +409,8 @@ export async function startMcpServer() {
                     taskType,
                     includeDraft,
                     limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+                    forceRefresh,
+                    summarizePR,
                 });
                 return {
                     content: [{ type: "text", text: JSON.stringify(pack, null, 2) }],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jussmor/commit-memory-mcp",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "mcpName": "io.github.jussmor/commit-memory",
   "description": "Commit-aware RAG with sqlite-vec and MCP tools for local agent workflows",
   "license": "MIT",