context-mcp-server 1.0.7 → 1.1.0

package/src/tools/context.js

@@ -25,33 +25,34 @@ 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', 'note', 'code', 'bug', 'architecture', 'config', 'summary', 'error'] },
+      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'] },
       files:         { type: 'array', items: { type: 'object' } },
       codeRefs:      { type: 'array', items: { type: 'object' } },
-      relations:     { type: 'array', items: { type: 'object' } },
       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'],
   },
@@ -79,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, '/');
@@ -104,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
@@ -117,7 +126,7 @@ export async function handle(args, state) {
 
       return {
         recentEntries:      entries,
-        activeDiscussions:  discussions,
+        activePlans:        discussions,
         restoredDiscussion: discussions.length === 1 ? { id: discussions[0].id, name: discussions[0].name } : null,
         codegraph:          graphStatus,
         digest:             digest || undefined,
@@ -128,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.',
       };
     }
@@ -136,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) {
@@ -147,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); });
@@ -163,24 +170,33 @@ 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,
-          relations: args.relations || dupe.relations,
         });
         fireAutoLink(updated.id, state);
         return { success: true, id: updated.id, deduplicated: true,
           message: `Updated existing entry "${updated.title || updated.id}" (auto-dedup).` };
       }
-      const entry = saveContext({ ...args });
+      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/gitTools.js

@@ -26,10 +26,8 @@ function autoDetectRoot(fromDir) {
 }
 
 function resolveCwd(args, state) {
-  // Auto-detect project root on first use if not already configured.
   if (!state.projectRootPath) {
-    const detected = autoDetectRoot(args.cwd ? pathResolve(args.cwd) : process.cwd());
-    state.projectRootPath = detected || process.cwd();
+    throw new Error('No project root configured. Call context.resume with rootPath before using git tools.');
   }
   const raw = args.cwd ? pathResolve(args.cwd) : state.projectRootPath;
   return guardPath(raw, state.projectRootPath);

package/src/tools/plan.js

@@ -0,0 +1,133 @@
+import { writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import {
+  saveDiscussion, getDiscussion, listDiscussions,
+  deleteDiscussion, updateDiscussion,
+} from '../db.js';
+
+function writePlanFile(planDir, name, content, title) {
+  if (!planDir) return null;
+  const dir = resolve(planDir);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  const filePath = join(dir, `${slug}.md`);
+  const md = `# ${title || name}\n\n${content || ''}\n`;
+  writeFileSync(filePath, md, 'utf8');
+  return filePath;
+}
+
+export const definition = {
+  name: 'plan',
+  description:
+    `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: {
+      action:  { type: 'string', enum: ['save', 'get', 'list', 'update', 'delete'] },
+      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: 'Plan title' },
+      content: { type: 'string', description: 'Full plan summary in markdown' },
+      status:  { type: 'string', enum: ['active', 'done'] },
+      tags:    { type: 'array', items: { type: 'string' } },
+      planDir: { type: 'string', description: 'Absolute path to the folder where .md plan files are written. Pass the path for your AI platform (e.g. ~/.claude/plans/ for Claude Code).' },
+    },
+    required: ['action'],
+  },
+  outputSchema: {
+    type: 'object',
+    properties: {
+      success:  { type: 'boolean' },
+      id:       { type: 'string' },
+      name:     { type: 'string' },
+      filePath: { type: 'string' },
+      plan:     { type: 'object' },
+      plans:    { type: 'array' },
+      message:  { type: 'string' },
+    },
+  },
+};
+
+export async function handle(args, state) {
+  if (!args.project && state.sessionProject) args = { ...args, project: state.sessionProject };
+
+  switch (args.action) {
+    case 'save': {
+      if (!args.name)    throw new Error('name is required for save');
+      if (!args.content) throw new Error('content is required for save');
+      const plan = saveDiscussion({
+        name:        args.name,
+        title:       args.title || args.name,
+        content:     args.content,
+        project:     args.project,
+        tags:        args.tags,
+        type:        'plan',
+        status:      args.status || 'active',
+        sessionId:   state.sessionId || null,
+      });
+      if (plan.status === 'active') state.discussionId = plan.id;
+      const filePath = writePlanFile(args.planDir, args.name, args.content, args.title);
+      return {
+        success: true, id: plan.id, name: plan.name,
+        filePath: filePath || undefined,
+        message: `Plan "${plan.name}" saved.${filePath ? ` Written to ${filePath}` : ''}`,
+      };
+    }
+
+    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,
+        title:   args.title,
+        content: args.content,
+        status:  args.status,
+        tags:    args.tags,
+      });
+      if (!updated) throw new Error(`No plan found for "${args.name || args.id}".`);
+      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,
+        filePath: filePath || undefined,
+        message: `Plan "${updated.name}" updated.`,
+      };
+    }
+
+    case 'get': {
+      if (!args.name && !args.id) throw new Error('name or id is required for get');
+      const plan = getDiscussion({ name: args.name, id: args.id, project: args.project });
+      return plan
+        ? { plan }
+        : { plan: null, message: `No plan found for "${args.name || args.id}".` };
+    }
+
+    case 'list': {
+      const plans = listDiscussions({ project: args.project, status: args.status });
+      return { plans };
+    }
+
+    case 'delete': {
+      if (!args.name && !args.id) throw new Error('name or id is required for delete');
+      const result = deleteDiscussion({ name: args.name, id: args.id });
+      if (state.discussionId && (args.id === state.discussionId || result.deleted > 0)) {
+        state.discussionId = null;
+      }
+      return { ...result, message: `Deleted ${result.deleted} plan(s).` };
+    }
+
+    default:
+      throw new Error(`Unknown plan action: ${args.action}`);
+  }
+}

package/uv.lock

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

package/src/tools/discussion.js

@@ -1,123 +0,0 @@
-import {
-  saveDiscussion, getDiscussion, listDiscussions, deleteDiscussion,
-  updateDiscussion, updateDiscussionStep, clearDiscussionLink,
-} from '../db.js';
-
-export const definition = {
-  name: 'discussion',
-  description:
-    `Forward-looking thinking space — plans, research, ideas, design.\n` +
-    `• "save"        — Create or update a discussion.\n` +
-    `• "update"      — Patch specific fields without touching the rest.\n` +
-    `• "get"         — Retrieve by name or id (full content + steps).\n` +
-    `• "list"        — List discussions (filterable). Header + stepsSummary only.\n` +
-    `• "delete"      — Remove by name or id.\n` +
-    `• "update_step" — Mark a step done/in-progress. Auto-closes when all done.`,
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action:           { type: 'string', enum: ['save', 'get', 'list', 'delete', 'update', 'update_step'] },
-      name:             { type: 'string' },
-      id:               { type: 'string' },
-      project:          { type: 'string' },
-      title:            { type: 'string' },
-      description:      { type: 'string' },
-      content:          { type: 'string' },
-      type:             { type: 'string', enum: ['plan', 'research', 'idea', 'design', 'implementation', 'review', 'thread'] },
-      status:           { type: 'string', enum: ['active', 'done'] },
-      tags:             { type: 'array', items: { type: 'string' } },
-      parentId:         { type: 'string' },
-      linkedContextIds: { type: 'array', items: { type: 'string' } },
-      steps:            { type: 'array', items: { type: 'object' } },
-      stepId:           { type: 'string' },
-      stepStatus:       { type: 'string', enum: ['pending', 'in-progress', 'done', 'skipped'] },
-      linkedContextId:  { type: 'string' },
-      filterStatus:     { type: 'string' },
-      filterType:       { type: 'string' },
-    },
-    required: ['action'],
-  },
-  outputSchema: {
-    type: 'object',
-    properties: {
-      success:     { type: 'boolean' },
-      id:          { type: 'string' },
-      name:        { type: 'string' },
-      discussion:  { type: 'object' },
-      discussions: { type: 'array' },
-      step:        { type: 'object' },
-      message:     { type: 'string' },
-    },
-  },
-};
-
-export async function handle(args, state) {
-  switch (args.action) {
-    case 'save': {
-      if (!args.name) throw new Error('name is required for save');
-      const disc = saveDiscussion({ ...args, sessionId: args.sessionId || state.sessionId });
-      if (disc.status === 'active')                                  state.discussionId = disc.id;
-      else if (state.discussionId === disc.id)                       state.discussionId = null;
-      return { success: true, id: disc.id, name: disc.name,
-        message: `Discussion "${disc.name}" saved (${disc.type}, ${disc.status}).` };
-    }
-
-    case 'get': {
-      if (!args.name && !args.id) throw new Error('name or id is required for get');
-      const disc = getDiscussion({ name: args.name, id: args.id, project: args.project });
-      return disc
-        ? { discussion: disc }
-        : { discussion: null, message: `No discussion found for "${args.name || args.id}".` };
-    }
-
-    case 'update': {
-      if (!args.name && !args.id) throw new Error('name or id is required for update');
-      const updated = updateDiscussion({ ...args });
-      if (!updated) throw new Error(`No discussion 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;
-      return { success: true, id: updated.id, name: updated.name, status: updated.status,
-        message: `Discussion "${updated.name}" updated (${updated.status}).` };
-    }
-
-    case 'list': {
-      return { discussions: listDiscussions({ project: args.project, status: args.filterStatus, type: args.filterType }) };
-    }
-
-    case 'delete': {
-      if (!args.name && !args.id) throw new Error('name or id is required for delete');
-      const toDelete = getDiscussion({ name: args.name, id: args.id });
-      if (toDelete) {
-        for (const ctxId of (toDelete.linkedContextIds || [])) clearDiscussionLink(ctxId);
-      }
-      const del = deleteDiscussion({ name: args.name, id: args.id });
-      if (state.discussionId) {
-        const matchById   = args.id   && args.id   === state.discussionId;
-        const matchByName = args.name && del.deleted > 0;
-        if (matchById || matchByName) state.discussionId = null;
-      }
-      return { ...del, message: `Deleted ${del.deleted} discussion(s).` };
-    }
-
-    case 'update_step': {
-      if (!args.name && !args.id) throw new Error('name or id is required for update_step');
-      if (!args.stepId) throw new Error('stepId is required for update_step');
-      const updated = updateDiscussionStep({
-        discussionName:  args.name,
-        discussionId:    args.id,
-        stepId:          args.stepId,
-        status:          args.stepStatus,
-        linkedContextId: args.linkedContextId,
-      });
-      if (!updated) throw new Error('Discussion or step not found.');
-      if (updated.discussion.status === 'done' && state.discussionId === updated.discussion.id) {
-        state.discussionId = null;
-      }
-      return { success: true, step: updated.step, discussionStatus: updated.discussion.status,
-        message: `Step updated. Discussion "${updated.discussion.name}" is now "${updated.discussion.status}".` };
-    }
-
-    default:
-      throw new Error(`Unknown discussion action: ${args.action}`);
-  }
-}