context-mcp-server 1.1.0 → 1.1.2

package/src/templates/gemini/commands/context-resume.toml

@@ -0,0 +1,15 @@
+# Invoked via: /context-resume [project]
+description = "Resume project memory + ContextGraph from context-mcp"
+
+prompt = """
+Call the `context` MCP tool with `action: "resume"`, `project: "{{args}}"` (if no argument given, infer the project name from the current working directory name), and `rootPath: "<absolute path to the project root / git repo root>"`.
+
+Both `project` and `rootPath` are required: `project` names the memory bucket, `rootPath` enables exact graph lookup and file sandboxing.
+
+This loads:
+- Recent decisions, bugs, and notes from past sessions
+- Active plans
+- ContextGraph status (built or not)
+
+If `codegraph.built` is false in the response, immediately call `codegraph_build` on the project path before proceeding.
+"""

package/src/templates/gemini/commands/graph-build.toml

@@ -0,0 +1,14 @@
+# Invoked via: /graph-build [path]
+description = "Build the ContextGraph (AST knowledge graph) for a project"
+
+prompt = """
+Call `codegraph_build` with the path `{{args}}`.
+
+If no argument is given, use the current working directory.
+
+This builds the ContextGraph for the project by parsing source files into an AST
+knowledge graph. Once built, use `codegraph_query` to answer structural questions
+about the codebase before reading files directly.
+
+After the build completes, report total nodes, edges, and communities.
+"""

package/src/templates/gemini/commands/save-context.toml

@@ -0,0 +1,24 @@
+# Invoked via: /save-context <what to remember>
+description = "Save a note/decision/bug to context-mcp project memory"
+
+prompt = """
+Call the `context` MCP tool with `action: "save"` to store a note for the
+current project.
+
+Parse the following arguments to determine the fields: {{args}}
+
+- `project`: infer from current working directory name if not specified.
+- `title`: first sentence or phrase, up to 120 chars.
+- `why`: why it mattered, what problem it solved, or what constraint it revealed.
+- `outcome`: what changed, what was verified, what shipped, and which files were affected.
+- `files`: list of files changed, required for task/bug types.
+- `content`: full argument text.
+- `type`: auto-detect:
+  - bug/fix/error -> `"bug"`
+  - task/done/complete/shipped/implemented -> `"task"`
+  - decision/chose/decided/approach -> `"decision"`
+  - config/env/secret/deploy -> `"config"`
+  - otherwise -> `"note"`
+
+Confirm to the user: title, type, why, outcome, and project.
+"""

package/src/templates/gemini/hooks/context-mcp-after-tool.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI AfterTool hook for context-mcp.
+ *
+ * Input (stdin JSON): { session_id, cwd, hook_event_name: "AfterTool",
+ *   tool_name, tool_input: { command }, tool_response }
+ *
+ * Saves failed run_shell_command invocations to context-mcp so the next
+ * session can see what broke. Exits silently when the command succeeded
+ * or the exit code cannot be determined.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  const toolResult = typeof event.tool_response === 'object' && event.tool_response !== null
+    ? event.tool_response
+    : {};
+  const command = toolInput.command || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], {
+    encoding: 'utf8',
+    shell: true,
+    stdio: 'ignore',
+  });
+});

package/src/templates/gemini/hooks/context-mcp-before-tool.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+/**
+ * Gemini CLI BeforeTool hook for context-mcp.
+ *
+ * Input (stdin JSON): { session_id, cwd, hook_event_name: "BeforeTool",
+ *   tool_name, tool_input }
+ *
+ * This hook is intentionally conservative. It validates the hook pipeline
+ * runs before run_shell_command but never blocks (exit 0 with no decision =
+ * allow). Keep policy decisions in GEMINI.md or a dedicated security hook
+ * if your team needs blocking (print {"decision":"deny","reason":"..."}).
+ */
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  try {
+    if (input.trim()) JSON.parse(input);
+  } catch {
+    // Do not interrupt the user's command because hook input changed.
+  }
+});

package/src/templates/vscode/commands/context-resume.prompt.md

@@ -0,0 +1,15 @@
+---
+mode: agent
+description: "Resume project memory + ContextGraph from context-mcp"
+---
+
+Call the `context` MCP tool with `action: "resume"`, infer `project` from the current working directory name, and pass `rootPath` as the absolute path to the git repo root.
+
+Both `project` and `rootPath` are required: `project` names the memory bucket, `rootPath` enables exact graph lookup and file sandboxing.
+
+This loads:
+- Recent decisions, bugs, and notes from past sessions
+- Active plans
+- ContextGraph status (built or not)
+
+If `codegraph.built` is false in the response, immediately call `codegraph_build` on the project path before proceeding.

package/src/templates/vscode/commands/graph-build.prompt.md

@@ -0,0 +1,10 @@
+---
+mode: agent
+description: "Build the ContextGraph (AST knowledge graph) for the current project"
+---
+
+Call `codegraph_build` with the current working directory as the path (or a path provided by the user).
+
+This builds the ContextGraph for the project by parsing source files into an AST knowledge graph. Once built, use `codegraph_query` to answer structural questions about the codebase before reading files directly.
+
+After the build completes, report total nodes, edges, and communities.

package/src/templates/vscode/commands/save-context.prompt.md

@@ -0,0 +1,16 @@
+---
+mode: agent
+description: "Save a note/decision/bug to context-mcp project memory"
+argument-hint: "What to remember (e.g. 'fixed auth bug in src/auth.js')"
+---
+
+Call the `context` MCP tool with `action: "save"` to store a note for the current project.
+
+Infer `project` from the current working directory name. Auto-detect `type`:
+- bug/fix/error → `"bug"`
+- task/done/complete/shipped/implemented → `"task"`
+- decision/chose/decided/approach → `"decision"`
+- config/env/secret/deploy → `"config"`
+- otherwise → `"note"`
+
+Fill in `title` (up to 120 chars), `why`, `outcome`, and `files`. Confirm back to the user: title, type, why, outcome, and project.

package/src/templates/vscode/hooks/context-mcp-post-tool-use.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * VS Code Copilot PostToolUse hook for context-mcp.
+ *
+ * Input (stdin JSON): { hook_event_name: "PostToolUse", tool_name,
+ *   tool_input: { command }, tool_output: { exit_code, stdout, stderr }, cwd }
+ *
+ * Saves failed shell commands to context-mcp so the next session can see
+ * what broke. Exits silently when the command succeeded or exit code is unknown.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  // VS Code uses tool_output (not tool_response) for the result object
+  const toolResult = typeof event.tool_output === 'object' && event.tool_output !== null
+    ? event.tool_output
+    : typeof event.tool_response === 'object' && event.tool_response !== null
+      ? event.tool_response
+      : {};
+  const command = toolInput.command || toolInput.cmd || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code
+    ?? event.exit_code ?? event.exitCode;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], { encoding: 'utf8', shell: true, stdio: 'ignore' });
+});

package/src/templates/windsurf/hooks/context-mcp-post-run-command.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+
+/**
+ * Windsurf post_run_command hook for context-mcp.
+ *
+ * Input (stdin JSON): { hook_event_name: "post_run_command", tool_name,
+ *   tool_input: { command }, tool_response: { exit_code, stdout, stderr }, cwd }
+ *
+ * Saves failed shell commands to context-mcp so the next session can see
+ * what broke. Exits silently when the command succeeded or exit code is unknown.
+ */
+
+import { spawnSync } from 'node:child_process';
+
+process.stdin.resume();
+process.stdin.setEncoding('utf8');
+
+let input = '';
+process.stdin.on('data', chunk => { input += chunk; });
+process.stdin.on('end', () => {
+  let event = {};
+  try {
+    event = input.trim() ? JSON.parse(input) : {};
+  } catch {
+    return;
+  }
+
+  const toolInput = event.tool_input || {};
+  const toolResult = typeof event.tool_response === 'object' && event.tool_response !== null
+    ? event.tool_response
+    : typeof event.tool_output === 'object' && event.tool_output !== null
+      ? event.tool_output
+      : {};
+  const command = toolInput.command || toolInput.cmd || event.command || '';
+  const exitCode = toolResult.exit_code ?? toolResult.exitCode ?? toolResult.code
+    ?? event.exit_code ?? event.exitCode;
+
+  if (!command || exitCode === undefined || Number(exitCode) === 0) return;
+
+  const output = String(
+    toolResult.stderr || toolResult.stdout || toolResult.output || '',
+  ).trim();
+
+  const content = [
+    `Command: ${command}`,
+    `Exit code: ${exitCode}`,
+    output ? `Output:\n${output.slice(0, 4000)}` : null,
+  ].filter(Boolean).join('\n\n');
+
+  spawnSync('ctx', [
+    'save',
+    '--project', (event.cwd || process.cwd()).split(/[\\/]/).pop() || 'default',
+    '--type', 'bug',
+    '--title', `Failed shell command: ${command.slice(0, 80)}`,
+    '--content', content,
+  ], { encoding: 'utf8', shell: true, stdio: 'ignore' });
+});

package/src/templates/{windsurf-rules.md → windsurf/windsurf-rules.md}

@@ -64,10 +64,12 @@ Call `search` before asking user to re-explain past work.
 ## 6. ContextGraph Tools
 
 ```
-codegraph_arch(path)          → module map (files, exports, imports)
-codegraph_query(path, ...)    → find specific function/class/file
-codegraph_nodes(path, type)   → list all nodes of a type
-codegraph_report(path)        → structural analysis
+codegraph_arch(path)                   → module map (files, exports, imports)
+codegraph_query(path, ...)             → find specific function/class/file
+codegraph_nodes(path, type)            → list all nodes of a type
+codegraph_report(path)                 → structural analysis
+codegraph_affected(path, node, depth?) → blast radius — what breaks if X changes?
+codegraph_html(path, formats?)         → regenerate visualizations (auto on every build)
 ```
 
 Use `codegraph_arch` first. Never read files for structure questions.

package/src/templates/windsurf/workflows/context-resume.md

@@ -0,0 +1,11 @@
+# context-resume
+
+Resume project memory and ContextGraph from context-mcp before starting any work.
+
+1. Call the `context` MCP tool with `action: "resume"`, infer `project` from the current working directory name, and pass `rootPath` as the absolute path to the git repo root.
+
+2. Read the returned `recentEntries` (last 15 entries), `activePlans`, and `codegraph` status.
+
+3. If `codegraph.built` is false, call `codegraph_build` on the project path immediately before proceeding.
+
+4. If `stats.totalEntries` is 20 or more, save a compaction summary before starting any new work.

package/src/templates/windsurf/workflows/graph-build.md

@@ -0,0 +1,11 @@
+# graph-build
+
+Build the ContextGraph (AST knowledge graph) for the current project.
+
+1. Call `codegraph_build` with the current working directory as the path (or a path provided by the user).
+
+2. Wait for the build to complete.
+
+3. Report total nodes, edges, and communities found.
+
+4. Once built, use `codegraph_query` to answer structural questions about the codebase instead of reading files directly.

package/src/templates/windsurf/workflows/save-context.md

@@ -0,0 +1,18 @@
+# save-context
+
+Save a note, decision, bug, or task to context-mcp project memory.
+
+1. Call the `context` MCP tool with `action: "save"`.
+
+2. Infer `project` from the current working directory name.
+
+3. Auto-detect `type` from the user's description:
+   - bug/fix/error → `"bug"`
+   - task/done/complete/shipped/implemented → `"task"`
+   - decision/chose/decided/approach → `"decision"`
+   - config/env/secret/deploy → `"config"`
+   - otherwise → `"note"`
+
+4. Fill in `title` (up to 120 chars), `why`, `outcome`, and `files`.
+
+5. Confirm back to the user: title, type, why, outcome, and project name.

package/src/tools/codegraph.js

@@ -97,6 +97,43 @@ export const definitions = [
       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'],
+    },
+  },
 ];
 
 export const TOOL_NAMES = new Set(definitions.map(d => d.name));