context-mcp-server 1.0.8 → 1.1.0

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,18 @@ 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'],
     },
   },
 ];
@@ -103,46 +106,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.`,
       };
     }
 

package/uv.lock

@@ -168,7 +168,7 @@ wheels = [
 
 [[package]]
 name = "codegraph-mcp"
-version = "1.0.8"
+version = "1.1.0"
 source = { editable = "." }
 dependencies = [
     { name = "mcp" },

package/src/migrator.js

@@ -1,124 +0,0 @@
-/**
- * migrator.js — one-time migration from flat JSON files to per-project directory structure.
- *
- * Old layout:
- *   ~/.context-mcp/contexts.json      all entries flat
- *   ~/.context-mcp/discussions.json   all discussions flat
- *   ~/.context-mcp/graphs.json        all graph build records flat
- *
- * New layout:
- *   ~/.context-mcp/projects/<slug>/context.json
- *   ~/.context-mcp/projects/<slug>/graph.json     { build, entries[] }
- *   ~/.context-mcp/projects/<slug>/summary.json
- *   ~/.context-mcp/projects/<slug>/discussions.json
- */
-
-import { readFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-
-function normPath(p) {
-  return p ? p.toLowerCase().replace(/\\/g, '/').replace(/\/$/, '') : '';
-}
-
-function treeFor(entry) {
-  if (entry.type === 'compaction') return 'summary';
-  return 'context';
-}
-
-function readArr(filePath, key) {
-  if (!existsSync(filePath)) return [];
-  try {
-    const d = JSON.parse(readFileSync(filePath, 'utf8'));
-    return Array.isArray(d[key]) ? d[key] : (Array.isArray(d) ? d : []);
-  } catch { return []; }
-}
-
-/**
- * Run migration if legacy flat files are present.
- * @param {object} opts
- * @param {string}   opts.dataDir       - base data dir (~/.context-mcp)
- * @param {string}   opts.projectsDir   - projects sub-dir
- * @param {string}   opts.projectsPath  - path to projects.json
- * @param {Function} opts.slugify       - name → filesystem slug
- * @param {Function} opts.flushFile     - (filePath, content) atomic write
- * @param {Array}    opts.projectsIndex - current projects.json array (mutated in place)
- */
-export function runMigration({ dataDir, projectsDir, projectsPath, slugify, flushFile, projectsIndex }) {
-  const legacyContexts    = join(dataDir, 'contexts.json');
-  const legacyDiscussions = join(dataDir, 'discussions.json');
-  const legacyGraphs      = join(dataDir, 'graphs.json');
-
-  const hasLegacy = existsSync(legacyContexts)
-    || existsSync(legacyDiscussions)
-    || existsSync(legacyGraphs);
-
-  if (!hasLegacy) return false;
-
-  const oldContexts    = readArr(legacyContexts,    'contexts');
-  const oldDiscussions = readArr(legacyDiscussions,  'discussions');
-  const oldGraphs      = readArr(legacyGraphs,       'graphs');
-
-  // Remap legacy type names to current 4-type schema
-  const TYPE_MAP = { architecture: 'note', code: 'note', error: 'bug', summary: 'compaction' };
-  const remapType = entry => {
-    if (TYPE_MAP[entry.type]) entry.type = TYPE_MAP[entry.type];
-    return entry;
-  };
-
-  // Group everything by project name
-  const byProject = {};
-  const ensure = name => {
-    if (!byProject[name]) byProject[name] = {
-      context: [], graph: { build: null }, summary: [], discussions: [],
-    };
-    return byProject[name];
-  };
-
-  for (const entry of oldContexts) {
-    remapType(entry);
-    const p = entry.project || 'global';
-    const d = ensure(p);
-    if (treeFor(entry) === 'summary') d.summary.push(entry);
-    else d.context.push(entry);
-  }
-
-  for (const disc of oldDiscussions) {
-    ensure(disc.project || 'global').discussions.push(disc);
-  }
-
-  // Match graph build records to projects via rootPath
-  for (const graph of oldGraphs) {
-    const proj = projectsIndex.find(p => normPath(p.rootPath) === normPath(graph.path));
-    const name = proj ? proj.name : 'global';
-    const d = ensure(name);
-    d.graph.build = {
-      path: graph.path, nodes: graph.nodes, edges: graph.edges,
-      communities: graph.communities, cached: graph.cached || 0,
-      changed: graph.changed || 0, time_ms: graph.time_ms || 0,
-      summary: graph.summary || '', builtAt: graph.builtAt,
-    };
-  }
-
-  // Write per-project files
-  for (const [name, data] of Object.entries(byProject)) {
-    const dir = join(projectsDir, slugify(name));
-    mkdirSync(dir, { recursive: true });
-    flushFile(join(dir, 'context.json'),     { entries: data.context });
-    flushFile(join(dir, 'graph.json'),       data.graph);
-    flushFile(join(dir, 'summary.json'),     { entries: data.summary });
-    flushFile(join(dir, 'discussions.json'), { discussions: data.discussions });
-  }
-
-  // Stamp dataDir onto each project record
-  for (const proj of projectsIndex) {
-    if (!proj.dataDir) proj.dataDir = `projects/${slugify(proj.name)}`;
-  }
-  flushFile(projectsPath, { projects: projectsIndex });
-
-  // Remove legacy flat files
-  try { unlinkSync(legacyContexts);    } catch {}
-  try { unlinkSync(legacyDiscussions); } catch {}
-  try { unlinkSync(legacyGraphs);      } catch {}
-
-  return true;
-}