@jussmor/commit-memory-mcp 0.4.2 → 0.4.3

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,6 +374,14 @@ 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";
@@ -463,6 +475,49 @@ export function buildContextPack(db, options) {
             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({
@@ -503,7 +558,47 @@ export function buildContextPack(db, options) {
             includeBranch: false,
         }));
     }
-    return pack;
+    // 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.2",
+  "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",