@jussmor/commit-memory-mcp 0.4.3 → 0.5.0

package/dist/db/client.d.ts

@@ -37,3 +37,34 @@ 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

@@ -477,9 +477,35 @@ export function buildContextPack(db, options) {
     };
     // 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(`
+    // 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,
@@ -500,24 +526,24 @@ export function buildContextPack(db, options) {
         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);
     }
+    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({
@@ -650,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";
@@ -334,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.",
@@ -638,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.3",
+  "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",