context-mcp-server 1.0.8 → 1.1.1

package/src/tools/codegraph.js

@@ -6,6 +6,7 @@
 import { spawnSync } from 'node:child_process';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { saveGraph, saveContext, updateContext, getContext, flushToDisk } from '../db.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REPO_ROOT  = join(__dirname, '..', '..');
@@ -82,16 +83,55 @@ export const definitions = [
     },
   },
   {
-    name: 'codegraph_path',
-    description: 'Find the shortest relationship path between two concepts in the graph.',
+    name: 'codegraph_arch',
+    description:
+      'Return a module map of the project — every file with its exported functions/classes and its imports. ' +
+      'Use this to understand project structure without reading any files. ' +
+      'Call after codegraph_build. Much faster than reading each file individually.',
     inputSchema: {
       type: 'object',
       properties: {
-        path: { type: 'string' },
-        from: { type: 'string' },
-        to:   { type: 'string' },
+        path:  { type: 'string', description: 'Project root' },
+        limit: { type: 'integer', description: 'Max files in output (default 100)' },
       },
-      required: ['path', 'from', 'to'],
+      required: ['path'],
+    },
+  },
+  {
+    name: 'codegraph_affected',
+    description:
+      'BFS traversal: given a node name, find every node that would be affected if you change it — ' +
+      'callers, importers, inheritors, etc. Use before refactoring to understand blast radius. ' +
+      'Returns affected nodes with file paths, relation types, and traversal depth.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path:  { type: 'string', description: 'Project root' },
+        node:  { type: 'string', description: 'Node name, ID, or file path to start from' },
+        depth: { type: 'integer', description: 'BFS depth (default 2, max 5)' },
+      },
+      required: ['path', 'node'],
+    },
+  },
+  {
+    name: 'codegraph_html',
+    description:
+      'Generate interactive visualizations from the knowledge graph. ' +
+      'Outputs: graph.html (vis.js force graph, dark theme, search, community toggle), ' +
+      'tree.html (D3 collapsible file tree), callflow.html (Mermaid architecture diagrams), ' +
+      'graph.graphml (Gephi/yEd), obsidian/ vault (per-node .md with wikilinks). ' +
+      'Run after codegraph_build. Pass formats array to select specific outputs.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path:    { type: 'string', description: 'Project root' },
+        formats: {
+          type: 'array',
+          items: { type: 'string', enum: ['html', 'tree', 'callflow', 'graphml', 'obsidian'] },
+          description: 'Formats to generate (default: all)',
+        },
+      },
+      required: ['path'],
     },
   },
 ];
@@ -103,46 +143,46 @@ export function handle(name, args, state) {
 
   // Persist graph metadata + save/update a context entry as a visible build record
   if (name === 'codegraph_build' && result.success) {
-    import('../db.js').then(({ saveGraph, saveContext, updateContext, getContext }) => {
-      saveGraph({
-        path:        args.path,
-        nodes:       result.nodes,
-        edges:       result.edges,
-        communities: result.communities,
-        cached:      result.cached,
-        changed:     result.changed,
-        time_ms:     result.time_ms,
-        summary:     result.summary || '',
-      });
+    saveGraph({
+      path:        args.path,
+      nodes:       result.nodes,
+      edges:       result.edges,
+      communities: result.communities,
+      cached:      result.cached,
+      changed:     result.changed,
+      time_ms:     result.time_ms,
+      summary:     result.summary || '',
+    });
+    flushToDisk(); // write graph.json to disk immediately so ctx list sees it
 
-      const inferredProject = args.path
-        ? args.path.replace(/\\/g, '/').replace(/\/$/, '').split('/').pop()
-        : null;
-      const project = state?.sessionProject || inferredProject || null;
-      const title   = `CodeGraph — ${args.path}`;
-      const content = [
-        `nodes: ${result.nodes} | edges: ${result.edges} | communities: ${result.communities}`,
-        `cached: ${result.cached} | changed: ${result.changed} | time: ${result.time_ms}ms`,
-        result.summary || '',
-      ].filter(Boolean).join('\n');
+    const inferredProject = args.path
+      ? args.path.replace(/\\/g, '/').replace(/\/$/, '').split('/').pop()
+      : null;
+    const project = state?.sessionProject || inferredProject || null;
+    const title   = `ContextGraph built — ${args.path}`;
+    const content = [
+      `nodes: ${result.nodes} | edges: ${result.edges} | communities: ${result.communities}`,
+      `cached: ${result.cached} | changed: ${result.changed} | time: ${result.time_ms}ms`,
+      result.summary || '',
+    ].filter(Boolean).join('\n');
 
-      const existing = getContext({ project, tags: ['codegraph'], limit: 100 })
-        .find(e => e.title === title);
+    // Search all projects — same path always produces same title regardless of session
+    const existing = getContext({ tags: ['codegraph'], limit: 100 })
+      .find(e => e.title === title);
 
-      if (existing) {
-        updateContext({ id: existing.id, content, status: 'active' });
-      } else {
-        saveContext({
-          project,
-          sessionId: state?.sessionId || null,
-          title,
-          content,
-          type:   'architecture',
-          source: 'auto',
-          tags:   ['codegraph', 'graph-build'],
-        });
-      }
-    }).catch(() => {});
+    if (existing) {
+      updateContext({ id: existing.id, content, status: 'active' });
+    } else {
+      saveContext({
+        project,
+        sessionId: state?.sessionId || null,
+        title,
+        content,
+        type:   'note',
+        source: 'auto',
+        tags:   ['codegraph', 'graph-build'],
+      });
+    }
   }
 
   return result;

package/src/tools/context.js

@@ -25,22 +25,24 @@ function autoDigest(entries, project) {
 export const definition = {
   name: 'context',
   description:
-    `Factual memory — record what happened, what was decided, what broke, what was built.\n` +
-    `• "resume"       — START HERE every conversation. Loads recent context, active discussions, and graph status for a project.\n` +
-    `• "save"         — Store a note, decision, bug, or code snippet. Auto-deduplicates.\n` +
-    `• "get"          — Load entries. Pass id/ids to fetch specific ones, or project/tags/limit for recent.\n` +
-    `• "update"       — Edit an existing entry by id (any field).\n` +
-    `• "delete"       — Remove one entry (id) or multiple at once (ids: [...]).\n` +
-    `• "list_projects"— Show all projects and entry counts.`,
+    `Factual memory — decisions, bugs, notes, discoveries.\n` +
+    `• "resume"       — call first every session. Returns recent entries, active plans, graph status.\n` +
+    `• "save"         — store an entry. Auto-deduplicates by content similarity.\n` +
+    `• "get"          — fetch by id/ids, or filter by project/tags/limit.\n` +
+    `• "update"       — edit an entry by id.\n` +
+    `• "delete"       — remove one entry (id) or several (ids: [...]).\n` +
+    `• "list_projects"— list all projects and entry counts.`,
   inputSchema: {
     type: 'object',
     properties: {
       action:        { type: 'string', enum: ['resume', 'save', 'get', 'update', 'delete', 'list_projects'] },
       content:       { type: 'string' },
-      title:         { type: 'string' },
+      title:         { type: 'string', description: 'Up to 120 chars' },
+      why:           { type: 'string', description: 'Why it mattered' },
+      outcome:       { type: 'string', description: 'What the result was' },
       project:       { type: 'string' },
       rootPath:      { type: 'string', description: 'Absolute path to the project root directory. Stored on first call and used to sandbox file/git tool access.' },
-      type:          { type: 'string', enum: ['decision', 'bug', 'note', 'config'] },
+      type:          { type: 'string', enum: ['note', 'compaction'] },
       status:        { type: 'string', enum: ['active', 'archived'] },
       tags:          { type: 'array', items: { type: 'string' } },
       source:        { type: 'string', enum: ['user', 'ai-summary', 'file', 'web', 'cli', 'auto'] },
@@ -49,8 +51,8 @@ export const definition = {
       expiresAt:     { type: 'string' },
       limit:         { type: 'number' },
       includeArchived: { type: 'boolean' },
-      id:            { type: 'string', description: 'Single entry ID (get/update/delete)' },
-      ids:           { type: 'array', items: { type: 'string' }, description: 'Multiple entry IDs — fetch or delete several at once' },
+      id:            { type: 'string', description: 'Single entry ID' },
+      ids:           { type: 'array', items: { type: 'string' }, description: 'Multiple entry IDs' },
     },
     required: ['action'],
   },
@@ -78,18 +80,27 @@ export async function handle(args, state) {
       const proj = args.project || null;
       archiveExpired(proj);
 
-      // Set project on state so autoLink works for subsequent saves
       if (proj) state.sessionProject = proj;
 
-      // Store rootPath with project (first time only) and load it onto session state.
-      // Auto-detect from git if neither provided nor previously stored.
       const storedRoot = proj ? getProjectRoot(proj) : null;
       const resolvedRoot = args.rootPath || storedRoot || detectGitRoot() || null;
       if (proj) ensureProject(proj, resolvedRoot || undefined);
       state.projectRootPath = resolvedRoot;
 
-      const entries       = getContext({ project: proj, limit: 15, compact: true })
+      const rawEntries    = getContext({ project: proj, limit: 15, compact: false })
         .filter(e => e.status !== 'archived');
+      // Newest 5 get full content; older entries get a lightweight preview
+      const entries = rawEntries.map((e, i) => {
+        if (i < 5) return e;
+        return {
+          id: e.id, project: e.project, title: e.title, type: e.type,
+          status: e.status, tags: e.tags, source: e.source,
+          createdAt: e.createdAt, updatedAt: e.updatedAt,
+          ...(e.why     ? { why: e.why }         : {}),
+          ...(e.outcome ? { outcome: e.outcome }  : {}),
+          preview: (e.content || '').slice(0, 200),
+        };
+      });
       const discussions   = listDiscussions({ project: proj, status: 'active' });
       const allGraphs     = listGraphs();
       const np = p => (p || '').toLowerCase().replace(/\\/g, '/');
@@ -103,7 +114,6 @@ export async function handle(args, state) {
           : null;
       const totalEntries  = countContext(proj);
 
-      // Auto-restore single active discussion
       if (discussions.length === 1) state.discussionId = discussions[0].id;
 
       const digest = totalEntries > 10
@@ -127,7 +137,7 @@ export async function handle(args, state) {
           ? `All file and git operations are sandboxed to: ${state.projectRootPath} — do not use paths outside this root.`
           : 'No project root configured — pass rootPath to restrict file/git access to a directory.',
         hint: graphStatus.built
-          ? `Graph ready (${graphStatus.nodes} nodes). Use codegraph_query for structural questions.`
+          ? `Graph ready (${graphStatus.nodes} nodes). Use codegraph_arch for module map, codegraph_query for specific symbol lookups.`
           : 'No graph built yet. Call codegraph_build on the project root to enable graph queries.',
       };
     }
@@ -135,7 +145,6 @@ export async function handle(args, state) {
     case 'save': {
       if (!args.content) throw new Error('content is required for save');
       if (!args.project && state.sessionProject) args = { ...args, project: state.sessionProject };
-      // Auto-detect and store project root if not yet configured
       if (args.project) {
         const existing = getProjectRoot(args.project);
         if (!existing) {
@@ -146,7 +155,6 @@ export async function handle(args, state) {
           }
         }
       }
-      // Validate file paths in files[] and codeRefs[] stay within project root
       if (state.projectRootPath) {
         if (Array.isArray(args.files)) {
           args.files.forEach(f => { if (f.path) guardPath(f.path, state.projectRootPath); });
@@ -162,6 +170,8 @@ export async function handle(args, state) {
           id: dupe.id, content: args.content,
           title: args.title || dupe.title, tags: args.tags || dupe.tags,
           type: args.type || dupe.type, status: args.status || dupe.status,
+          why: args.why !== undefined ? args.why : dupe.why,
+          outcome: args.outcome !== undefined ? args.outcome : dupe.outcome,
           expiresAt: args.expiresAt !== undefined ? args.expiresAt : dupe.expiresAt,
           files: args.files || dupe.files, codeRefs: args.codeRefs || dupe.codeRefs,
         });
@@ -172,13 +182,21 @@ export async function handle(args, state) {
       const entry = saveContext({ ...args, rootPath: state.projectRootPath || undefined });
       fireAutoLink(entry.id, state);
 
-      // Auto-compact when too many entries accumulate
+      // Auto-compact when too many entries accumulate.
+      // If the AI just saved a compaction entry, use that content as the summary
+      // instead of running TF-IDF on top of it.
       let compaction = null;
       if (shouldCompact(entry.project)) {
-        const old = getContext({ project: entry.project, limit: 500 });
-        const { summarizeEntries: summarize } = await import('../summarizer.js');
-        const cs = summarize(old.slice(old.length - 30), { project: entry.project || 'global', sessionLabel: 'auto-compaction', topN: 5 });
-        compaction = compactProject(entry.project, cs);
+        if (entry.type === 'compaction') {
+          // AI wrote a proper summary — compact old entries without creating a duplicate summary
+          compaction = compactProject(entry.project, entry.content, { skipSummaryEntry: true });
+        } else {
+          // AI didn't write a summary — fall back to TF-IDF extractive summarization
+          const old = getContext({ project: entry.project, limit: 500 });
+          const { summarizeEntries: summarize } = await import('../summarizer.js');
+          const summaryContent = summarize(old.slice(old.length - 30), { project: entry.project || 'global', sessionLabel: 'auto-compaction', topN: 5 });
+          compaction = compactProject(entry.project, summaryContent);
+        }
       }
 
       return { success: true, id: entry.id, deduplicated: false,

package/src/tools/plan.js

@@ -19,13 +19,12 @@ function writePlanFile(planDir, name, content, title) {
 export const definition = {
   name: 'plan',
   description:
-    `AI plan storage — auto-call this tool whenever you create any kind of plan.\n` +
-    `Saves a summary of the plan to the project store and writes a .md file to planDir.\n` +
-    `• "save"   — Store a new plan or overwrite an existing one by name. Pass planDir to write a file.\n` +
-    `• "update" — Patch title/content/status on an existing plan.\n` +
-    `• "get"    — Retrieve a plan by name or id (full content).\n` +
-    `• "list"   — List all plans for the project.\n` +
-    `• "delete" — Remove a plan by name or id.`,
+    `Plan storage — saves to project store, optionally writes a .md file to planDir.\n` +
+    `• "save"   — store a new plan or overwrite by name.\n` +
+    `• "update" — patch title/content/status.\n` +
+    `• "get"    — retrieve a plan by name or id.\n` +
+    `• "list"   — list all plans for the project.\n` +
+    `• "delete" — remove a plan by name or id.`,
   inputSchema: {
     type: 'object',
     properties: {
@@ -33,7 +32,7 @@ export const definition = {
       name:    { type: 'string', description: 'Short slug-style identifier for the plan, e.g. "auth-refactor"' },
       id:      { type: 'string' },
       project: { type: 'string' },
-      title:   { type: 'string', description: 'Human-readable plan title' },
+      title:   { type: 'string', description: 'Plan title' },
       content: { type: 'string', description: 'Full plan summary in markdown' },
       status:  { type: 'string', enum: ['active', 'done'] },
       tags:    { type: 'array', items: { type: 'string' } },
@@ -83,6 +82,11 @@ export async function handle(args, state) {
 
     case 'update': {
       if (!args.name && !args.id) throw new Error('name or id is required for update');
+      if (args.status === 'done') {
+        const result = deleteDiscussion({ name: args.name, id: args.id });
+        state.discussionId = null;
+        return { success: true, message: `Plan "${args.name || args.id}" completed and removed.` };
+      }
       const updated = updateDiscussion({
         name:    args.name,
         id:      args.id,
@@ -92,13 +96,12 @@ export async function handle(args, state) {
         tags:    args.tags,
       });
       if (!updated) throw new Error(`No plan found for "${args.name || args.id}".`);
-      if (updated.status !== 'active' && state.discussionId === updated.id) state.discussionId = null;
       if (updated.status === 'active') state.discussionId = updated.id;
       const filePath = writePlanFile(args.planDir, updated.name, updated.content, updated.title);
       return {
-        success: true, id: updated.id, name: updated.name, status: updated.status,
+        success: true, id: updated.id, name: updated.name,
         filePath: filePath || undefined,
-        message: `Plan "${updated.name}" updated (${updated.status}).`,
+        message: `Plan "${updated.name}" updated.`,
       };
     }