@jussmor/commit-memory-mcp 0.4.2 → 0.5.0

package/dist/db/client.d.ts

@@ -25,8 +25,46 @@ 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;
 }): number;
+export interface FeatureResumeOptions {
+    feature: string;
+    domain?: string;
+    limit?: number;
+}
+export declare function getFeatureResume(db: RagDatabase, options: FeatureResumeOptions): string;
+export declare function listLearnedFeatures(db: RagDatabase, options?: {
+    domain?: string;
+    status?: string;
+}): Array<{
+    feature: string;
+    domain: string;
+    branch: string;
+    confidence: number;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    title: string;
+    contentLength: number;
+}>;
+export declare function listAvailableBranches(db: RagDatabase, options?: {
+    domain?: string;
+    feature?: string;
+}): Array<{
+    branch: string;
+    feature: string;
+    domain: string;
+    factCount: number;
+    lastUpdated: string;
+    topConfidence: number;
+}>;

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,75 @@ 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.
+    // Always include learned features regardless of parameter filters.
+    let learnedFacts = [];
+    if (options.feature) {
+        // Search for learned knowledge about the specific feature
+        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 scope_feature = ? AND status = 'promoted'
+        ORDER BY updated_at DESC, priority DESC
+        LIMIT ?
+      `).all(options.feature, Math.max(3, Math.floor(options.limit * 0.2)));
+    }
+    else {
+        // Auto-discover recently learned features when no specific feature is requested
+        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 +584,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();
@@ -555,3 +676,163 @@ export function archiveFeatureContext(db, options) {
     const result = tx();
     return Number(result.changes ?? 0);
 }
+export function getFeatureResume(db, options) {
+    const feature = String(options.feature ?? "").trim();
+    const domain = String(options.domain ?? "").trim();
+    const limit = Number(options.limit ?? 20);
+    if (!feature) {
+        return "# Feature Resume\n\nError: feature parameter is required.";
+    }
+    // Query learned feature facts
+    const learnedFacts = db
+        .prepare(`
+        SELECT
+          title,
+          content,
+          confidence,
+          updated_at
+        FROM context_facts
+        WHERE source_type = 'feature-agent'
+          AND scope_feature = ?
+          AND status = 'promoted'
+        ORDER BY updated_at DESC
+        LIMIT 1
+      `)
+        .all(feature);
+    // Query PR metadata related to the feature
+    const prFacts = db
+        .prepare(`
+        SELECT
+          title,
+          content,
+          source_ref,
+          confidence,
+          updated_at
+        FROM context_facts
+        WHERE source_type LIKE 'pr_%'
+          AND (scope_feature = ? OR scope_branch LIKE ?)
+          AND status = 'promoted'
+        ORDER BY updated_at DESC
+        LIMIT ?
+      `)
+        .all(feature, `%${feature}%`, limit);
+    // Build markdown document
+    const markdown = [];
+    markdown.push(`# Feature Resume: ${feature}`);
+    markdown.push("");
+    // Add learned knowledge section
+    if (learnedFacts.length > 0) {
+        const learned = learnedFacts[0];
+        markdown.push("## 📚 Feature Knowledge");
+        markdown.push(`**Confidence:** ${(learned.confidence * 100).toFixed(0)}%`);
+        markdown.push(`**Last Updated:** ${new Date(learned.updated_at).toLocaleString()}`);
+        markdown.push("");
+        markdown.push(learned.content);
+        markdown.push("");
+    }
+    else {
+        markdown.push("## 📚 Feature Knowledge");
+        markdown.push("*(No learned knowledge yet. Run `learn_feature` to seed context.)*");
+        markdown.push("");
+    }
+    // Add PR metadata section
+    if (prFacts.length > 0) {
+        markdown.push("## 🔗 Related Pull Requests");
+        markdown.push("");
+        for (const pr of prFacts) {
+            const confidence = (pr.confidence * 100).toFixed(0);
+            const ref = pr.source_ref || "unknown";
+            markdown.push(`- **${pr.title}** (${ref}) — ${confidence}% confidence`);
+            if (pr.content && pr.content.length < 200) {
+                markdown.push(`  > ${pr.content}`);
+            }
+        }
+        markdown.push("");
+    }
+    // Add recommendations
+    markdown.push("## 💡 Recommendations");
+    if (learnedFacts.length === 0) {
+        markdown.push('- Run `learn_feature({ featureBranch: "${feature}", agentContent: "..." })` to seed knowledge');
+    }
+    if (prFacts.length === 0) {
+        markdown.push("- Sync PR context with `pre_plan_sync_brief` to see related PRs");
+    }
+    markdown.push("- Use this resume alongside your active worktree for complete context");
+    return markdown.join("\n");
+}
+export function listLearnedFeatures(db, options) {
+    const clauses = ["source_type = 'feature-agent'"];
+    const values = [];
+    if (options?.domain) {
+        clauses.push("scope_domain = ?");
+        values.push(options.domain);
+    }
+    if (options?.status) {
+        clauses.push("status = ?");
+        values.push(options.status);
+    }
+    else {
+        clauses.push("status = 'promoted'");
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db.prepare(`
+      SELECT DISTINCT
+        scope_feature as feature,
+        scope_domain as domain,
+        scope_branch as branch,
+        confidence,
+        status,
+        created_at,
+        updated_at,
+        title,
+        LENGTH(content) as contentLength
+      FROM context_facts
+      ${where}
+      ORDER BY updated_at DESC
+    `).all(...values);
+    return rows.map((row) => ({
+        feature: String(row.feature ?? ""),
+        domain: String(row.domain ?? ""),
+        branch: String(row.branch ?? ""),
+        confidence: Number(row.confidence ?? 0),
+        status: String(row.status ?? ""),
+        createdAt: String(row.created_at ?? ""),
+        updatedAt: String(row.updated_at ?? ""),
+        title: String(row.title ?? ""),
+        contentLength: Number(row.contentLength ?? 0),
+    }));
+}
+export function listAvailableBranches(db, options) {
+    const clauses = ["status = 'promoted'"];
+    const values = [];
+    if (options?.domain) {
+        clauses.push("scope_domain = ?");
+        values.push(options.domain);
+    }
+    if (options?.feature) {
+        clauses.push("scope_feature = ?");
+        values.push(options.feature);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    const rows = db.prepare(`
+      SELECT
+        scope_branch as branch,
+        scope_feature as feature,
+        scope_domain as domain,
+        COUNT(*) as factCount,
+        MAX(updated_at) as lastUpdated,
+        MAX(confidence) as topConfidence
+      FROM context_facts
+      ${where}
+      GROUP BY scope_branch, scope_feature, scope_domain
+      ORDER BY updated_at DESC
+    `).all(...values);
+    return rows.map((row) => ({
+        branch: String(row.branch ?? ""),
+        feature: String(row.feature ?? ""),
+        domain: String(row.domain ?? ""),
+        factCount: Number(row.factCount ?? 0),
+        lastUpdated: String(row.lastUpdated ?? ""),
+        topConfidence: Number(row.topConfidence ?? 0),
+    }));
+}

package/dist/mcp/server.js

@@ -6,7 +6,7 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-import { archiveFeatureContext, buildContextPack, openDatabase, promoteContextFacts, upsertContextFact, upsertWorktreeSession, } from "../db/client.js";
+import { archiveFeatureContext, buildContextPack, getFeatureResume, listLearnedFeatures, listAvailableBranches, openDatabase, promoteContextFacts, upsertContextFact, upsertWorktreeSession, } from "../db/client.js";
 import { commitDetails, explainPathActivity, extractFeatureBranchCommits, latestCommitForFile, mainBranchOvernightBrief, resumeFeatureSessionBrief, whoChangedFile, } from "../git/insights.js";
 import { listActiveWorktrees } from "../git/worktree.js";
 import { syncPullRequestContext } from "../pr/sync.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: [],
                 },
@@ -326,6 +334,49 @@ export async function startMcpServer() {
                     required: ["featureBranch"],
                 },
             },
+            {
+                name: "get_feature_resume",
+                description: "Combine learned feature knowledge with PR metadata and return as markdown. Does NOT require a git worktree. Use this to review a feature's complete context: what we learned about it + related PR activity.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        feature: {
+                            type: "string",
+                            description: "e.g. messaging",
+                        },
+                        domain: { type: "string" },
+                        limit: { type: "number" },
+                    },
+                    required: ["feature"],
+                },
+            },
+            {
+                name: "list_learned_features",
+                description: "List all learned features stored in the knowledge database with confidence levels and timestamps.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        domain: { type: "string" },
+                        status: {
+                            type: "string",
+                            description: "Filter by status (promoted, draft, etc). Defaults to promoted.",
+                        },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "list_available_branches",
+                description: "List all available branches and features with knowledge context available for each.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        domain: { type: "string" },
+                        feature: { type: "string" },
+                    },
+                    required: [],
+                },
+            },
             {
                 name: "pre_plan_sync_brief",
                 description: "Run sync + overnight + feature resume analysis before planning work.",
@@ -390,6 +441,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 +452,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) }],
@@ -626,6 +681,125 @@ export async function startMcpServer() {
                 content: [{ type: "text", text: JSON.stringify(brief, null, 2) }],
             };
         }
+        if (request.params.name === "get_feature_resume") {
+            const feature = String(request.params.arguments?.feature ?? "").trim();
+            const domain = String(request.params.arguments?.domain ?? "").trim();
+            const limit = Number(request.params.arguments?.limit ?? 20);
+            if (!feature) {
+                return {
+                    content: [{ type: "text", text: "feature parameter is required" }],
+                    isError: true,
+                };
+            }
+            const db = openDatabase(dbPath);
+            try {
+                const resume = getFeatureResume(db, {
+                    feature,
+                    domain: domain || undefined,
+                    limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+                });
+                return {
+                    content: [{ type: "text", text: resume }],
+                };
+            }
+            finally {
+                db.close();
+            }
+        }
+        if (request.params.name === "list_learned_features") {
+            const domain = String(request.params.arguments?.domain ?? "").trim();
+            const status = String(request.params.arguments?.status ?? "").trim();
+            const db = openDatabase(dbPath);
+            try {
+                const features = listLearnedFeatures(db, {
+                    domain: domain || undefined,
+                    status: status || undefined,
+                });
+                const markdown = [
+                    "# Learned Features",
+                    "",
+                    features.length === 0
+                        ? "*(No learned features yet)*"
+                        : `${features.length} feature(s) available:`,
+                    "",
+                ];
+                if (features.length > 0) {
+                    markdown.push("| Feature | Domain | Branch | Confidence | Status | Last Updated |");
+                    markdown.push("|---------|--------|--------|------------|--------|--------------|");
+                    for (const feat of features) {
+                        const confidence = (feat.confidence * 100).toFixed(0);
+                        const lastUpdated = new Date(feat.updatedAt).toLocaleDateString();
+                        markdown.push(`| **${feat.feature}** | ${feat.domain} | ${feat.branch} | ${confidence}% | ${feat.status} | ${lastUpdated} |`);
+                    }
+                    markdown.push("");
+                    markdown.push("## Feature Details");
+                    markdown.push("");
+                    for (const feat of features) {
+                        markdown.push(`### ${feat.feature}`);
+                        markdown.push(`- **Confidence:** ${(feat.confidence * 100).toFixed(0)}%`);
+                        markdown.push(`- **Domain:** ${feat.domain}`);
+                        markdown.push(`- **Branch:** ${feat.branch}`);
+                        markdown.push(`- **Status:** ${feat.status}`);
+                        markdown.push(`- **Created:** ${new Date(feat.createdAt).toLocaleString()}`);
+                        markdown.push(`- **Updated:** ${new Date(feat.updatedAt).toLocaleString()}`);
+                        markdown.push(`- **Title:** ${feat.title}`);
+                        markdown.push(`- **Content size:** ${feat.contentLength} bytes`);
+                        markdown.push("");
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: markdown.join("\n") }],
+                };
+            }
+            finally {
+                db.close();
+            }
+        }
+        if (request.params.name === "list_available_branches") {
+            const domain = String(request.params.arguments?.domain ?? "").trim();
+            const feature = String(request.params.arguments?.feature ?? "").trim();
+            const db = openDatabase(dbPath);
+            try {
+                const branches = listAvailableBranches(db, {
+                    domain: domain || undefined,
+                    feature: feature || undefined,
+                });
+                const markdown = [
+                    "# Available Branches and Features",
+                    "",
+                    branches.length === 0
+                        ? "*(No branches with knowledge available)*"
+                        : `${branches.length} branch/feature combination(s):`,
+                    "",
+                ];
+                if (branches.length > 0) {
+                    markdown.push("| Branch | Feature | Domain | Facts | Confidence | Last Updated |");
+                    markdown.push("|--------|---------|--------|-------|------------|--------------|");
+                    for (const branch of branches) {
+                        const confidence = (branch.topConfidence * 100).toFixed(0);
+                        const lastUpdated = new Date(branch.lastUpdated).toLocaleDateString();
+                        markdown.push(`| **${branch.branch}** | ${branch.feature} | ${branch.domain} | ${branch.factCount} | ${confidence}% | ${lastUpdated} |`);
+                    }
+                    markdown.push("");
+                    markdown.push("## Branch Details");
+                    markdown.push("");
+                    for (const branch of branches) {
+                        markdown.push(`### ${branch.branch} (${branch.feature})`);
+                        markdown.push(`- **Domain:** ${branch.domain}`);
+                        markdown.push(`- **Facts stored:** ${branch.factCount}`);
+                        markdown.push(`- **Top confidence:** ${(branch.topConfidence * 100).toFixed(0)}%`);
+                        markdown.push(`- **Last updated:** ${new Date(branch.lastUpdated).toLocaleString()}`);
+                        markdown.push("");
+                    }
+                }
+                return {
+                    content: [{ type: "text", text: markdown.join("\n") }],
+                };
+            }
+            finally {
+                db.close();
+            }
+        }
         if (request.params.name === "pre_plan_sync_brief") {
             const owner = String(request.params.arguments?.owner ?? "").trim();
             const repo = String(request.params.arguments?.repo ?? "").trim();

package/package.json

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