@jussmor/commit-memory-mcp 0.3.5 → 0.3.6

package/dist/db/client.d.ts

@@ -1,7 +1,13 @@
 import Database from "better-sqlite3";
-import type { CommitChunk } from "../types.js";
+import type { CommitChunk, PullRequestCommentRecord, PullRequestDecisionRecord, PullRequestRecord, PullRequestReviewRecord, WorktreeSessionRecord } 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;
+export declare function upsertPullRequest(db: RagDatabase, pr: PullRequestRecord): void;
+export declare function replacePullRequestComments(db: RagDatabase, repoOwner: string, repoName: string, prNumber: number, comments: PullRequestCommentRecord[]): void;
+export declare function replacePullRequestReviews(db: RagDatabase, repoOwner: string, repoName: string, prNumber: number, reviews: PullRequestReviewRecord[]): void;
+export declare function replacePullRequestDecisions(db: RagDatabase, repoOwner: string, repoName: string, prNumber: number, decisions: PullRequestDecisionRecord[]): void;
+export declare function touchPullRequestSyncState(db: RagDatabase, repoOwner: string, repoName: string): void;
+export declare function upsertWorktreeSession(db: RagDatabase, session: WorktreeSessionRecord): void;

package/dist/db/client.js

@@ -39,6 +39,76 @@ export function openDatabase(dbPath) {
       id INTEGER PRIMARY KEY CHECK (id = 1),
       last_indexed_at TEXT NOT NULL
     );
+
+    CREATE TABLE IF NOT EXISTS prs (
+      repo_owner TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      pr_number INTEGER NOT NULL,
+      title TEXT NOT NULL,
+      body TEXT NOT NULL,
+      author TEXT NOT NULL,
+      state TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      merged_at TEXT,
+      url TEXT NOT NULL,
+      PRIMARY KEY (repo_owner, repo_name, pr_number)
+    );
+
+    CREATE TABLE IF NOT EXISTS pr_comments (
+      id TEXT PRIMARY KEY,
+      repo_owner TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      pr_number INTEGER NOT NULL,
+      author TEXT NOT NULL,
+      body TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      url TEXT NOT NULL,
+      FOREIGN KEY (repo_owner, repo_name, pr_number)
+        REFERENCES prs(repo_owner, repo_name, pr_number)
+    );
+
+    CREATE TABLE IF NOT EXISTS pr_reviews (
+      id TEXT PRIMARY KEY,
+      repo_owner TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      pr_number INTEGER NOT NULL,
+      author TEXT NOT NULL,
+      state TEXT NOT NULL,
+      body TEXT NOT NULL,
+      submitted_at TEXT NOT NULL,
+      FOREIGN KEY (repo_owner, repo_name, pr_number)
+        REFERENCES prs(repo_owner, repo_name, pr_number)
+    );
+
+    CREATE TABLE IF NOT EXISTS pr_decisions (
+      id TEXT PRIMARY KEY,
+      repo_owner TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      pr_number INTEGER NOT NULL,
+      source TEXT NOT NULL,
+      author TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      severity TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      FOREIGN KEY (repo_owner, repo_name, pr_number)
+        REFERENCES prs(repo_owner, repo_name, pr_number)
+    );
+
+    CREATE TABLE IF NOT EXISTS pr_sync_state (
+      repo_owner TEXT NOT NULL,
+      repo_name TEXT NOT NULL,
+      last_synced_at TEXT NOT NULL,
+      PRIMARY KEY (repo_owner, repo_name)
+    );
+
+    CREATE TABLE IF NOT EXISTS worktree_sessions (
+      path TEXT PRIMARY KEY,
+      branch TEXT NOT NULL,
+      base_branch TEXT NOT NULL,
+      last_synced_at TEXT NOT NULL
+    );
   `);
     return db;
 }
@@ -90,3 +160,113 @@ export function touchIndexState(db) {
         last_indexed_at = excluded.last_indexed_at
     `).run(now);
 }
+export function upsertPullRequest(db, pr) {
+    db.prepare(`
+      INSERT INTO prs (
+        repo_owner,
+        repo_name,
+        pr_number,
+        title,
+        body,
+        author,
+        state,
+        created_at,
+        updated_at,
+        merged_at,
+        url
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(repo_owner, repo_name, pr_number) DO UPDATE SET
+        title = excluded.title,
+        body = excluded.body,
+        author = excluded.author,
+        state = excluded.state,
+        created_at = excluded.created_at,
+        updated_at = excluded.updated_at,
+        merged_at = excluded.merged_at,
+        url = excluded.url
+    `).run(pr.repoOwner, pr.repoName, pr.number, pr.title, pr.body, pr.author, pr.state, pr.createdAt, pr.updatedAt, pr.mergedAt, pr.url);
+}
+export function replacePullRequestComments(db, repoOwner, repoName, prNumber, comments) {
+    db.prepare(`
+      DELETE FROM pr_comments
+      WHERE repo_owner = ? AND repo_name = ? AND pr_number = ?
+    `).run(repoOwner, repoName, prNumber);
+    const insert = db.prepare(`
+      INSERT INTO pr_comments (
+        id,
+        repo_owner,
+        repo_name,
+        pr_number,
+        author,
+        body,
+        created_at,
+        updated_at,
+        url
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const comment of comments) {
+        insert.run(comment.id, repoOwner, repoName, prNumber, comment.author, comment.body, comment.createdAt, comment.updatedAt, comment.url);
+    }
+}
+export function replacePullRequestReviews(db, repoOwner, repoName, prNumber, reviews) {
+    db.prepare(`
+      DELETE FROM pr_reviews
+      WHERE repo_owner = ? AND repo_name = ? AND pr_number = ?
+    `).run(repoOwner, repoName, prNumber);
+    const insert = db.prepare(`
+      INSERT INTO pr_reviews (
+        id,
+        repo_owner,
+        repo_name,
+        pr_number,
+        author,
+        state,
+        body,
+        submitted_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const review of reviews) {
+        insert.run(review.id, repoOwner, repoName, prNumber, review.author, review.state, review.body, review.submittedAt);
+    }
+}
+export function replacePullRequestDecisions(db, repoOwner, repoName, prNumber, decisions) {
+    db.prepare(`
+      DELETE FROM pr_decisions
+      WHERE repo_owner = ? AND repo_name = ? AND pr_number = ?
+    `).run(repoOwner, repoName, prNumber);
+    const insert = db.prepare(`
+      INSERT INTO pr_decisions (
+        id,
+        repo_owner,
+        repo_name,
+        pr_number,
+        source,
+        author,
+        summary,
+        severity,
+        created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    for (const decision of decisions) {
+        insert.run(decision.id, repoOwner, repoName, prNumber, decision.source, decision.author, decision.summary, decision.severity, decision.createdAt);
+    }
+}
+export function touchPullRequestSyncState(db, repoOwner, repoName) {
+    db.prepare(`
+      INSERT INTO pr_sync_state (repo_owner, repo_name, last_synced_at)
+      VALUES (?, ?, ?)
+      ON CONFLICT(repo_owner, repo_name) DO UPDATE SET
+        last_synced_at = excluded.last_synced_at
+    `).run(repoOwner, repoName, new Date().toISOString());
+}
+export function upsertWorktreeSession(db, session) {
+    db.prepare(`
+      INSERT INTO worktree_sessions (path, branch, base_branch, last_synced_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT(path) DO UPDATE SET
+        branch = excluded.branch,
+        base_branch = excluded.base_branch,
+        last_synced_at = excluded.last_synced_at
+    `).run(session.path, session.branch, session.baseBranch, session.lastSyncedAt);
+}

package/dist/git/insights.d.ts

@@ -0,0 +1,51 @@
+export declare function whoChangedFile(options: {
+    repoPath: string;
+    filePath: string;
+    limit: number;
+}): {
+    filePath: string;
+    commits: Array<{
+        sha: string;
+        author: string;
+        date: string;
+        subject: string;
+    }>;
+    authors: Array<{
+        author: string;
+        commitCount: number;
+        lastCommitAt: string;
+    }>;
+};
+export declare function latestCommitForFile(repoPath: string, filePath: string): string | null;
+export declare function commitDetails(repoPath: string, sha: string): {
+    sha: string;
+    author: string;
+    date: string;
+    subject: string;
+    body: string;
+};
+export declare function mainBranchOvernightBrief(options: {
+    repoPath: string;
+    baseBranch: string;
+    sinceHours: number;
+    limit: number;
+}): {
+    baseBranch: string;
+    sinceHours: number;
+    commits: Array<{
+        sha: string;
+        author: string;
+        date: string;
+        subject: string;
+    }>;
+};
+export declare function resumeFeatureSessionBrief(options: {
+    worktreePath: string;
+    baseBranch: string;
+}): {
+    worktreePath: string;
+    branch: string;
+    ahead: number;
+    behind: number;
+    overlapFiles: string[];
+};

package/dist/git/insights.js

@@ -0,0 +1,146 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+function runGit(repoPath, args) {
+    return execFileSync("git", ["-C", repoPath, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+export function whoChangedFile(options) {
+    const repoPath = path.resolve(options.repoPath);
+    const output = runGit(repoPath, [
+        "log",
+        `-n${options.limit}`,
+        "--format=%H%x1f%an%x1f%aI%x1f%s",
+        "--",
+        options.filePath,
+    ]).trim();
+    if (!output) {
+        return { filePath: options.filePath, commits: [], authors: [] };
+    }
+    const commits = output.split("\n").map((line) => {
+        const [sha = "", author = "", date = "", subject = ""] = line.split("\x1f");
+        return { sha, author, date, subject };
+    });
+    const authorMap = new Map();
+    for (const commit of commits) {
+        const existing = authorMap.get(commit.author);
+        if (!existing) {
+            authorMap.set(commit.author, {
+                commitCount: 1,
+                lastCommitAt: commit.date,
+            });
+            continue;
+        }
+        existing.commitCount += 1;
+        if (commit.date > existing.lastCommitAt) {
+            existing.lastCommitAt = commit.date;
+        }
+    }
+    const authors = Array.from(authorMap.entries())
+        .map(([author, value]) => ({ author, ...value }))
+        .sort((a, b) => b.commitCount - a.commitCount);
+    return {
+        filePath: options.filePath,
+        commits,
+        authors,
+    };
+}
+export function latestCommitForFile(repoPath, filePath) {
+    const output = runGit(path.resolve(repoPath), [
+        "log",
+        "-n1",
+        "--format=%H",
+        "--",
+        filePath,
+    ]).trim();
+    return output || null;
+}
+export function commitDetails(repoPath, sha) {
+    const output = runGit(path.resolve(repoPath), [
+        "show",
+        "--no-color",
+        "--format=%H%x1f%an%x1f%aI%x1f%s%x1f%b",
+        "--no-patch",
+        sha,
+    ]).trimEnd();
+    const [commitSha = sha, author = "", date = "", subject = "", body = ""] = output.split("\x1f");
+    return { sha: commitSha, author, date, subject, body };
+}
+export function mainBranchOvernightBrief(options) {
+    const repoPath = path.resolve(options.repoPath);
+    const since = `${Math.max(1, options.sinceHours)} hours ago`;
+    const output = runGit(repoPath, [
+        "log",
+        `-n${Math.max(1, options.limit)}`,
+        `--since=${since}`,
+        "--format=%H%x1f%an%x1f%aI%x1f%s",
+        `origin/${options.baseBranch}`,
+    ]).trim();
+    if (!output) {
+        return {
+            baseBranch: options.baseBranch,
+            sinceHours: options.sinceHours,
+            commits: [],
+        };
+    }
+    const commits = output.split("\n").map((line) => {
+        const [sha = "", author = "", date = "", subject = ""] = line.split("\x1f");
+        return { sha, author, date, subject };
+    });
+    return {
+        baseBranch: options.baseBranch,
+        sinceHours: options.sinceHours,
+        commits,
+    };
+}
+export function resumeFeatureSessionBrief(options) {
+    const worktreePath = path.resolve(options.worktreePath);
+    const branch = runGit(worktreePath, [
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]).trim();
+    const countRaw = runGit(worktreePath, [
+        "rev-list",
+        "--left-right",
+        "--count",
+        `origin/${options.baseBranch}...HEAD`,
+    ]).trim();
+    const [behindRaw = "0", aheadRaw = "0"] = countRaw.split(/\s+/);
+    const behind = Number.parseInt(behindRaw, 10) || 0;
+    const ahead = Number.parseInt(aheadRaw, 10) || 0;
+    const mergeBase = runGit(worktreePath, [
+        "merge-base",
+        "HEAD",
+        `origin/${options.baseBranch}`,
+    ]).trim();
+    const baseFilesRaw = runGit(worktreePath, [
+        "diff",
+        "--name-only",
+        `${mergeBase}..origin/${options.baseBranch}`,
+    ]).trim();
+    const featureFilesRaw = runGit(worktreePath, [
+        "diff",
+        "--name-only",
+        `${mergeBase}..HEAD`,
+    ]).trim();
+    const baseFiles = new Set(baseFilesRaw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const featureFiles = new Set(featureFilesRaw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean));
+    const overlapFiles = Array.from(featureFiles)
+        .filter((file) => baseFiles.has(file))
+        .slice(0, 40);
+    return {
+        worktreePath,
+        branch,
+        ahead,
+        behind,
+        overlapFiles,
+    };
+}

package/dist/git/worktree.d.ts

@@ -0,0 +1,3 @@
+import type { WorktreeRecord } from "../types.js";
+export declare function listActiveWorktrees(repoPath: string): WorktreeRecord[];
+export declare function currentBranch(repoPath: string): string;

package/dist/git/worktree.js

@@ -0,0 +1,52 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+function runGit(repoPath, args) {
+    return execFileSync("git", ["-C", repoPath, ...args], {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+export function listActiveWorktrees(repoPath) {
+    const root = path.resolve(repoPath);
+    const output = runGit(root, ["worktree", "list", "--porcelain"]);
+    const records = [];
+    const blocks = output
+        .split("\n\n")
+        .map((block) => block.trim())
+        .filter(Boolean);
+    for (const block of blocks) {
+        const lines = block.split("\n");
+        let recordPath = "";
+        let headSha = "";
+        let branch = "detached";
+        for (const line of lines) {
+            if (line.startsWith("worktree ")) {
+                recordPath = line.slice("worktree ".length).trim();
+            }
+            if (line.startsWith("HEAD ")) {
+                headSha = line.slice("HEAD ".length).trim();
+            }
+            if (line.startsWith("branch ")) {
+                const fullRef = line.slice("branch ".length).trim();
+                branch = fullRef.replace("refs/heads/", "");
+            }
+        }
+        if (!recordPath) {
+            continue;
+        }
+        records.push({
+            path: recordPath,
+            branch,
+            headSha,
+            isCurrent: path.resolve(recordPath) === root,
+        });
+    }
+    return records;
+}
+export function currentBranch(repoPath) {
+    return runGit(path.resolve(repoPath), [
+        "rev-parse",
+        "--abbrev-ref",
+        "HEAD",
+    ]).trim();
+}

package/dist/mcp/server.js

@@ -6,14 +6,59 @@ import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
-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",
+import { openDatabase, upsertWorktreeSession } from "../db/client.js";
+import { commitDetails, latestCommitForFile, mainBranchOvernightBrief, resumeFeatureSessionBrief, whoChangedFile, } from "../git/insights.js";
+import { listActiveWorktrees } from "../git/worktree.js";
+import { syncPullRequestContext } from "../pr/sync.js";
+function fetchRemote(repoPath) {
+    execFileSync("git", ["-C", repoPath, "fetch", "--all", "--prune"], {
+        stdio: ["ignore", "pipe", "pipe"],
     });
 }
+function detectReferencedPrNumber(text) {
+    const match = text.match(/#(\d{1,8})\b/);
+    if (!match) {
+        return null;
+    }
+    const value = Number.parseInt(match[1] ?? "", 10);
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
+function loadPullRequestContext(db, prNumber, repoOwner, repoName) {
+    const pr = repoOwner && repoName
+        ? (db
+            .prepare(`
+            SELECT repo_owner, repo_name, pr_number, title, body, author, state, created_at, updated_at, merged_at, url
+            FROM prs
+            WHERE repo_owner = ? AND repo_name = ? AND pr_number = ?
+            LIMIT 1
+          `)
+            .get(repoOwner, repoName, prNumber) ?? null)
+        : (db
+            .prepare(`
+            SELECT repo_owner, repo_name, pr_number, title, body, author, state, created_at, updated_at, merged_at, url
+            FROM prs
+            WHERE pr_number = ?
+            ORDER BY updated_at DESC
+            LIMIT 1
+          `)
+            .get(prNumber) ?? null);
+    if (!pr) {
+        return { pr: null, decisions: [] };
+    }
+    const decisions = db
+        .prepare(`
+      SELECT id, source, author, summary, severity, created_at
+      FROM pr_decisions
+      WHERE repo_owner = ? AND repo_name = ? AND pr_number = ?
+      ORDER BY created_at DESC
+      LIMIT 50
+    `)
+        .all(pr.repo_owner, pr.repo_name, pr.pr_number);
+    return { pr, decisions };
+}
 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"));
@@ -23,7 +68,7 @@ function getConfig() {
 export async function startMcpServer() {
     const server = new Server({
         name: "commit-memory-mcp",
-        version: "0.3.1",
+        version: "0.4.0",
     }, {
         capabilities: {
             tools: {},
@@ -32,117 +77,309 @@ export async function startMcpServer() {
     server.setRequestHandler(ListToolsRequestSchema, async () => ({
         tools: [
             {
-                name: "search_related_commits",
-                description: "Find commit chunks semantically related to current work context.",
+                name: "sync_pr_context",
+                description: "Sync pull request description/comments/reviews from GitHub CLI into local context DB.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        query: { type: "string" },
-                        activeFile: { type: "string" },
+                        owner: { type: "string" },
+                        repo: { type: "string" },
+                        prNumbers: {
+                            type: "array",
+                            items: { type: "number" },
+                        },
                         limit: { type: "number" },
                     },
-                    required: ["query"],
+                    required: ["owner", "repo"],
+                },
+            },
+            {
+                name: "list_active_worktrees",
+                description: "List active git worktrees for multi-session feature work.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        baseBranch: { type: "string" },
+                    },
+                    required: [],
                 },
             },
             {
-                name: "explain_commit_match",
-                description: "Return contextual details for a chunk match.",
+                name: "who_changed_this",
+                description: "Show who changed a file recently and summarize top authors.",
                 inputSchema: {
                     type: "object",
                     properties: {
-                        chunkId: { type: "string" },
+                        filePath: { type: "string" },
+                        limit: { type: "number" },
                     },
-                    required: ["chunkId"],
+                    required: ["filePath"],
                 },
             },
             {
-                name: "get_commit_diff",
-                description: "Get full git show output for a commit SHA.",
+                name: "why_was_this_changed",
+                description: "Explain intent for a commit or file using git history and synced PR decisions.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         sha: { type: "string" },
+                        filePath: { type: "string" },
+                        owner: { type: "string" },
+                        repo: { type: "string" },
                     },
-                    required: ["sha"],
+                    required: [],
                 },
             },
             {
-                name: "reindex_commits",
-                description: "Refresh commit index from git history.",
+                name: "get_main_branch_overnight_brief",
+                description: "Summarize what changed recently on main branch while you were offline.",
                 inputSchema: {
                     type: "object",
                     properties: {
+                        baseBranch: { type: "string" },
+                        sinceHours: { type: "number" },
                         limit: { type: "number" },
                     },
                     required: [],
                 },
             },
+            {
+                name: "resume_feature_session_brief",
+                description: "Brief branch divergence and overlap risk for a feature worktree.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        worktreePath: { type: "string" },
+                        baseBranch: { type: "string" },
+                    },
+                    required: [],
+                },
+            },
+            {
+                name: "pre_plan_sync_brief",
+                description: "Run sync + overnight + feature resume analysis before planning work.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        owner: { type: "string" },
+                        repo: { type: "string" },
+                        baseBranch: { type: "string" },
+                        worktreePath: { type: "string" },
+                        filePath: { type: "string" },
+                        sinceHours: { type: "number" },
+                        limit: { type: "number" },
+                    },
+                    required: ["owner", "repo"],
+                },
+            },
         ],
     }));
     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 });
+        if (request.params.name === "sync_pr_context") {
+            const owner = String(request.params.arguments?.owner ?? "").trim();
+            const repo = String(request.params.arguments?.repo ?? "").trim();
+            if (!owner || !repo) {
+                return {
+                    content: [{ type: "text", text: "owner and repo are required" }],
+                    isError: true,
+                };
+            }
+            const numbersRaw = request.params.arguments?.prNumbers;
+            const prNumbers = Array.isArray(numbersRaw)
+                ? numbersRaw
+                    .map((value) => Number(value))
+                    .filter((value) => Number.isFinite(value) && value > 0)
+                : undefined;
+            const limit = Number(request.params.arguments?.limit ?? 25);
+            const summary = await syncPullRequestContext({
+                repoPath,
+                dbPath,
+                repoOwner: owner,
+                repoName: repo,
+                prNumbers,
+                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,
-                    };
+        if (request.params.name === "list_active_worktrees") {
+            const baseBranch = String(request.params.arguments?.baseBranch ?? "").trim() || "main";
+            const worktrees = listActiveWorktrees(repoPath);
+            const db = openDatabase(dbPath);
+            try {
+                for (const worktree of worktrees) {
+                    upsertWorktreeSession(db, {
+                        path: worktree.path,
+                        branch: worktree.branch,
+                        baseBranch,
+                        lastSyncedAt: new Date().toISOString(),
+                    });
                 }
-                const results = await searchRelatedCommits(db, query, limit, activeFile);
+            }
+            finally {
+                db.close();
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(worktrees, null, 2) }],
+            };
+        }
+        if (request.params.name === "who_changed_this") {
+            const filePath = String(request.params.arguments?.filePath ?? "").trim();
+            const limit = Number(request.params.arguments?.limit ?? 20);
+            if (!filePath) {
                 return {
-                    content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+                    content: [{ type: "text", text: "filePath is required" }],
+                    isError: true,
                 };
             }
-            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);
+            const output = whoChangedFile({
+                repoPath,
+                filePath,
+                limit: Number.isFinite(limit) && limit > 0 ? limit : 20,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(output, null, 2) }],
+            };
+        }
+        if (request.params.name === "why_was_this_changed") {
+            const owner = String(request.params.arguments?.owner ?? "").trim();
+            const repo = String(request.params.arguments?.repo ?? "").trim();
+            const filePath = String(request.params.arguments?.filePath ?? "").trim();
+            const rawSha = String(request.params.arguments?.sha ?? "").trim();
+            const sha = rawSha || (filePath ? latestCommitForFile(repoPath, filePath) : null);
+            if (!sha) {
                 return {
-                    content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+                    content: [
+                        {
+                            type: "text",
+                            text: "Provide sha or a filePath that has commit history.",
+                        },
+                    ],
+                    isError: true,
                 };
             }
-            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 commit = commitDetails(repoPath, sha);
+            const prNumber = detectReferencedPrNumber(`${commit.subject}\n${commit.body}`);
+            let prContext = { pr: null, decisions: [] };
+            if (prNumber) {
+                const db = openDatabase(dbPath);
+                try {
+                    prContext = loadPullRequestContext(db, prNumber, owner || undefined, repo || undefined);
                 }
-                const output = runGitDiff(repoPath, sha);
+                finally {
+                    db.close();
+                }
+            }
+            const result = {
+                filePath: filePath || null,
+                commit,
+                referencedPullRequestNumber: prNumber,
+                pullRequest: prContext.pr,
+                decisions: prContext.decisions,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        if (request.params.name === "get_main_branch_overnight_brief") {
+            const baseBranch = String(request.params.arguments?.baseBranch ?? "").trim() || "main";
+            const sinceHours = Number(request.params.arguments?.sinceHours ?? 12);
+            const limit = Number(request.params.arguments?.limit ?? defaultLimit);
+            fetchRemote(repoPath);
+            const brief = mainBranchOvernightBrief({
+                repoPath,
+                baseBranch,
+                sinceHours: Number.isFinite(sinceHours) ? sinceHours : 12,
+                limit: Number.isFinite(limit) ? limit : defaultLimit,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify(brief, null, 2) }],
+            };
+        }
+        if (request.params.name === "resume_feature_session_brief") {
+            const worktreePath = String(request.params.arguments?.worktreePath ?? "").trim() || repoPath;
+            const baseBranch = String(request.params.arguments?.baseBranch ?? "").trim() || "main";
+            fetchRemote(repoPath);
+            const brief = resumeFeatureSessionBrief({
+                worktreePath,
+                baseBranch,
+            });
+            const db = openDatabase(dbPath);
+            try {
+                upsertWorktreeSession(db, {
+                    path: brief.worktreePath,
+                    branch: brief.branch,
+                    baseBranch,
+                    lastSyncedAt: new Date().toISOString(),
+                });
+            }
+            finally {
+                db.close();
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(brief, null, 2) }],
+            };
+        }
+        if (request.params.name === "pre_plan_sync_brief") {
+            const owner = String(request.params.arguments?.owner ?? "").trim();
+            const repo = String(request.params.arguments?.repo ?? "").trim();
+            const baseBranch = String(request.params.arguments?.baseBranch ?? "").trim() || "main";
+            const worktreePath = String(request.params.arguments?.worktreePath ?? "").trim() || repoPath;
+            const filePath = String(request.params.arguments?.filePath ?? "").trim();
+            const sinceHours = Number(request.params.arguments?.sinceHours ?? 12);
+            const limit = Number(request.params.arguments?.limit ?? 25);
+            if (!owner || !repo) {
                 return {
-                    content: [{ type: "text", text: output }],
+                    content: [{ type: "text", text: "owner and repo are required" }],
+                    isError: true,
                 };
             }
-            return {
-                content: [
-                    { type: "text", text: `Unknown tool: ${request.params.name}` },
+            fetchRemote(repoPath);
+            const syncSummary = await syncPullRequestContext({
+                repoPath,
+                dbPath,
+                repoOwner: owner,
+                repoName: repo,
+                limit,
+            });
+            const overnight = mainBranchOvernightBrief({
+                repoPath,
+                baseBranch,
+                sinceHours: Number.isFinite(sinceHours) ? sinceHours : 12,
+                limit,
+            });
+            const resume = resumeFeatureSessionBrief({
+                worktreePath,
+                baseBranch,
+            });
+            const fileFocus = filePath
+                ? whoChangedFile({
+                    repoPath,
+                    filePath,
+                    limit: 10,
+                })
+                : null;
+            const prePlan = {
+                syncSummary,
+                overnight,
+                resume,
+                fileFocus,
+                recommendations: [
+                    "Review blocker-level decisions from synced PR context first.",
+                    "Rebase or merge main if behind is non-zero before coding.",
+                    "Resolve overlap files before expanding feature scope.",
                 ],
-                isError: true,
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(prePlan, null, 2) }],
             };
         }
-        finally {
-            db.close();
-        }
+        return {
+            content: [{ type: "text", text: `Unknown tool: ${request.params.name}` }],
+            isError: true,
+        };
     });
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/pr/sync.d.ts

@@ -0,0 +1,9 @@
+import type { PullRequestSyncSummary } from "../types.js";
+export declare function syncPullRequestContext(options: {
+    repoPath: string;
+    dbPath: string;
+    repoOwner: string;
+    repoName: string;
+    prNumbers?: number[];
+    limit?: number;
+}): Promise<PullRequestSyncSummary>;

package/dist/pr/sync.js

@@ -0,0 +1,201 @@
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { openDatabase, replacePullRequestComments, replacePullRequestDecisions, replacePullRequestReviews, touchPullRequestSyncState, upsertPullRequest, } from "../db/client.js";
+function runGh(repoPath, args) {
+    return execFileSync("gh", args, {
+        cwd: repoPath,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function summarize(text) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    if (!compact) {
+        return "No summary available.";
+    }
+    if (compact.length <= 280) {
+        return compact;
+    }
+    return `${compact.slice(0, 277)}...`;
+}
+function classifySeverity(text) {
+    if (/\b(block|blocking|must|required|cannot|can't|broken|fail)\b/i.test(text)) {
+        return "blocker";
+    }
+    if (/\b(should|consider|follow\s*up|todo|risk|later)\b/i.test(text)) {
+        return "warning";
+    }
+    return "info";
+}
+function isDecisionSignal(text) {
+    return /\b(decision|decide|decided|agreed|resolved|approved|final|ship|merged?)\b/i.test(text);
+}
+function parseComments(prNumber, comments) {
+    if (!Array.isArray(comments)) {
+        return [];
+    }
+    return comments.map((comment, index) => ({
+        id: String(comment.id ?? `${prNumber}-comment-${index + 1}`),
+        prNumber,
+        author: comment.author?.login ?? "unknown",
+        body: comment.body?.trim() ?? "",
+        createdAt: comment.createdAt ?? new Date(0).toISOString(),
+        updatedAt: comment.updatedAt ?? comment.createdAt ?? new Date(0).toISOString(),
+        url: comment.url ?? "",
+    }));
+}
+function parseReviews(prNumber, reviews) {
+    if (!Array.isArray(reviews)) {
+        return [];
+    }
+    return reviews.map((review, index) => ({
+        id: String(review.id ?? `${prNumber}-review-${index + 1}`),
+        prNumber,
+        author: review.author?.login ?? "unknown",
+        state: review.state ?? "COMMENTED",
+        body: review.body?.trim() ?? "",
+        submittedAt: review.submittedAt ?? new Date(0).toISOString(),
+    }));
+}
+function createDecisionRecords(options) {
+    const decisions = [];
+    if (options.pr.body.trim()) {
+        decisions.push({
+            id: `pr-${options.pr.number}-description`,
+            prNumber: options.pr.number,
+            source: "description",
+            author: options.pr.author,
+            summary: summarize(options.pr.body),
+            severity: classifySeverity(options.pr.body),
+            createdAt: options.pr.updatedAt,
+        });
+    }
+    for (const review of options.reviews) {
+        if (!review.body && review.state === "COMMENTED") {
+            continue;
+        }
+        if (review.state === "CHANGES_REQUESTED" ||
+            review.state === "APPROVED" ||
+            isDecisionSignal(review.body)) {
+            const text = [review.state, review.body].filter(Boolean).join(" - ");
+            decisions.push({
+                id: `pr-${options.pr.number}-review-${review.id}`,
+                prNumber: options.pr.number,
+                source: "review",
+                author: review.author,
+                summary: summarize(text),
+                severity: review.state === "CHANGES_REQUESTED"
+                    ? "blocker"
+                    : classifySeverity(text),
+                createdAt: review.submittedAt,
+            });
+        }
+    }
+    for (const comment of options.comments) {
+        if (!comment.body || !isDecisionSignal(comment.body)) {
+            continue;
+        }
+        decisions.push({
+            id: `pr-${options.pr.number}-comment-${comment.id}`,
+            prNumber: options.pr.number,
+            source: "comment",
+            author: comment.author,
+            summary: summarize(comment.body),
+            severity: classifySeverity(comment.body),
+            createdAt: comment.updatedAt,
+        });
+    }
+    return decisions;
+}
+function parsePullRequest(repoOwner, repoName, raw) {
+    const number = Number(raw.number ?? 0);
+    if (!Number.isFinite(number) || number <= 0) {
+        throw new Error("Invalid pull request number returned by gh");
+    }
+    const pr = {
+        repoOwner,
+        repoName,
+        number,
+        title: raw.title?.trim() ?? "",
+        body: raw.body?.trim() ?? "",
+        author: raw.author?.login ?? "unknown",
+        state: raw.state ?? "UNKNOWN",
+        createdAt: raw.createdAt ?? new Date(0).toISOString(),
+        updatedAt: raw.updatedAt ?? raw.createdAt ?? new Date(0).toISOString(),
+        mergedAt: raw.mergedAt ?? null,
+        url: raw.url ?? "",
+    };
+    const comments = parseComments(number, raw.comments);
+    const reviews = parseReviews(number, raw.reviews);
+    const decisions = createDecisionRecords({ pr, comments, reviews });
+    return { pr, comments, reviews, decisions };
+}
+function listRecentPullRequestNumbers(repoPath, repoOwner, repoName, limit) {
+    const output = runGh(repoPath, [
+        "pr",
+        "list",
+        "-R",
+        `${repoOwner}/${repoName}`,
+        "--state",
+        "merged",
+        "--limit",
+        String(limit),
+        "--json",
+        "number",
+    ]);
+    const rows = JSON.parse(output);
+    return rows
+        .map((row) => Number(row.number ?? 0))
+        .filter((value) => Number.isFinite(value) && value > 0);
+}
+function fetchPullRequest(repoPath, repoOwner, repoName, prNumber) {
+    const output = runGh(repoPath, [
+        "pr",
+        "view",
+        String(prNumber),
+        "-R",
+        `${repoOwner}/${repoName}`,
+        "--json",
+        "number,title,body,author,state,createdAt,updatedAt,mergedAt,url,comments,reviews",
+    ]);
+    return JSON.parse(output);
+}
+export async function syncPullRequestContext(options) {
+    const repoPath = path.resolve(options.repoPath);
+    const dbPath = path.resolve(options.dbPath);
+    const limit = Number.isFinite(options.limit) ? Number(options.limit) : 20;
+    const prNumbers = options.prNumbers && options.prNumbers.length > 0
+        ? options.prNumbers
+        : listRecentPullRequestNumbers(repoPath, options.repoOwner, options.repoName, limit);
+    const db = openDatabase(dbPath);
+    let syncedPrs = 0;
+    let syncedComments = 0;
+    let syncedReviews = 0;
+    let promotedDecisions = 0;
+    const tx = db.transaction(() => {
+        for (const prNumber of prNumbers) {
+            const raw = fetchPullRequest(repoPath, options.repoOwner, options.repoName, prNumber);
+            const parsed = parsePullRequest(options.repoOwner, options.repoName, raw);
+            upsertPullRequest(db, parsed.pr);
+            replacePullRequestComments(db, options.repoOwner, options.repoName, parsed.pr.number, parsed.comments);
+            replacePullRequestReviews(db, options.repoOwner, options.repoName, parsed.pr.number, parsed.reviews);
+            replacePullRequestDecisions(db, options.repoOwner, options.repoName, parsed.pr.number, parsed.decisions);
+            syncedPrs += 1;
+            syncedComments += parsed.comments.length;
+            syncedReviews += parsed.reviews.length;
+            promotedDecisions += parsed.decisions.length;
+        }
+        touchPullRequestSyncState(db, options.repoOwner, options.repoName);
+    });
+    tx();
+    db.close();
+    return {
+        syncedPrs,
+        syncedComments,
+        syncedReviews,
+        promotedDecisions,
+        repoOwner: options.repoOwner,
+        repoName: options.repoName,
+        syncedAt: new Date().toISOString(),
+    };
+}

package/dist/types.d.ts

@@ -24,3 +24,63 @@ export type IndexSummary = {
     indexedChunks: number;
     skippedChunks: number;
 };
+export type PullRequestRecord = {
+    repoOwner: string;
+    repoName: string;
+    number: number;
+    title: string;
+    body: string;
+    author: string;
+    state: string;
+    createdAt: string;
+    updatedAt: string;
+    mergedAt: string | null;
+    url: string;
+};
+export type PullRequestCommentRecord = {
+    id: string;
+    prNumber: number;
+    author: string;
+    body: string;
+    createdAt: string;
+    updatedAt: string;
+    url: string;
+};
+export type PullRequestReviewRecord = {
+    id: string;
+    prNumber: number;
+    author: string;
+    state: string;
+    body: string;
+    submittedAt: string;
+};
+export type PullRequestDecisionRecord = {
+    id: string;
+    prNumber: number;
+    source: "description" | "comment" | "review";
+    author: string;
+    summary: string;
+    severity: "info" | "warning" | "blocker";
+    createdAt: string;
+};
+export type PullRequestSyncSummary = {
+    syncedPrs: number;
+    syncedComments: number;
+    syncedReviews: number;
+    promotedDecisions: number;
+    repoOwner: string;
+    repoName: string;
+    syncedAt: string;
+};
+export type WorktreeRecord = {
+    path: string;
+    branch: string;
+    headSha: string;
+    isCurrent: boolean;
+};
+export type WorktreeSessionRecord = {
+    path: string;
+    branch: string;
+    lastSyncedAt: string;
+    baseBranch: string;
+};

package/package.json

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