context-mcp-server 1.0.1 → 1.0.2

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "context-mcp-server",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Persistent AI memory + codebase knowledge graph MCP server. Works across Claude Code, Cursor, Gemini CLI, Codex, Windsurf, VS Code Copilot, Claude.ai, and ChatGPT.",
   "type": "module",
   "bin": {
     "context-mcp": "./src/index.js",
+    "context-mcp-server": "./src/index.js",
     "context-mcp-http": "./src/http.js",
     "ctx": "./src/cli.js"
   },

package/src/cli.js

@@ -119,9 +119,11 @@ function printUsage() {
   cmd('ctx discuss [project]',      'show discussions');
   cmd('ctx benchmark',              'token savings report (memory + graph)');
   console.log('');
+  cmd('ctx install --initial',          'install / update Node.js + Python (codegraph) deps');
   cmd('ctx install --<platform>',      'write MCP config + instruction file for an AI platform');
   cmd('ctx install --all',             'install for all platforms at once');
   cmd('ctx online [--port N]',         'start HTTP server + show credentials for Claude.ai / ChatGPT');
+  cmd('ctx online --close',            'stop the running HTTP server');
   cmd('ctx settings',                  'view and edit config (port, host, client id/secret)');
   console.log('');
   cmd('ctx help',                      'show this screen');
@@ -586,10 +588,8 @@ const PLATFORMS = {
   windsurf: {
     label: 'Windsurf',
     install(cwd) {
-      // Local rule file
       const rules = _tpl('windsurf-rules.md');
       if (rules) _writeFile(join(cwd, '.windsurf', 'rules', 'context-mcp.md'), rules, '.windsurf/rules/context-mcp.md');
-      // Global Windsurf config
       const globalCfgPath = join(homedir(), '.codeium', 'windsurf', 'mcp_config.json');
       let existing = {};
       try { existing = JSON.parse(readFileSync(globalCfgPath, 'utf8')); } catch {}
@@ -602,12 +602,57 @@ const PLATFORMS = {
 
 function cmdInstall(args) {
   const flags = new Set(args.map(a => a.replace(/^--/, '')));
-  const all   = flags.has('all');
+  const all     = flags.has('all');
+  const initial = flags.has('initial');
   const keys  = all ? Object.keys(PLATFORMS) : Object.keys(PLATFORMS).filter(k => flags.has(k));
 
+  if (initial) {
+    printSection('Install', 'install / update');
+    console.log('');
+
+    const __dirname_init = dirname(fileURLToPath(import.meta.url));
+    const pkgRootInit = join(__dirname_init, '..');
+
+    // Node.js packages
+    console.log(`  ${bold(lblue('Node.js packages'))}`);
+    const npmInstall = spawnSync('npm', ['install', '--omit=dev'], {
+      cwd: pkgRootInit, encoding: 'utf8', shell: true,
+    });
+    if (npmInstall.status !== 0) {
+      console.log(`  ${bad('✗')} npm install failed:\n${faint((npmInstall.stderr || npmInstall.stdout || '').trim())}`);
+    } else {
+      console.log(`  ${ok('✓')} Node.js dependencies installed`);
+    }
+    console.log('');
+
+    // Python / uv (codegraph)
+    console.log(`  ${bold(lblue('Python Codegraph'))}`);
+    const uvCheck2 = spawnSync('uv', ['--version'], { encoding: 'utf8', shell: true });
+    if (uvCheck2.error || uvCheck2.status !== 0) {
+      console.log(`  ${bad('✗')} uv not found — install from ${accent('https://docs.astral.sh/uv/')} to enable codegraph`);
+    } else {
+      console.log(`  ${ok('✓')} uv found: ${faint(uvCheck2.stdout.trim())}`);
+      // On Windows, an existing .venv contains a lib64 junction that uv can't remove — wipe it first
+      if (process.platform === 'win32') {
+        const venvPath = join(pkgRootInit, '.venv');
+        spawnSync('cmd', ['/c', 'rmdir', '/s', '/q', venvPath], { encoding: 'utf8' });
+      }
+      const sync2 = spawnSync('uv', ['sync', '--no-dev'], { cwd: pkgRootInit, encoding: 'utf8', shell: true });
+      if (sync2.status !== 0) {
+        console.log(`  ${bad('✗')} uv sync failed:\n${faint((sync2.stderr || sync2.stdout || '').trim())}`);
+      } else {
+        console.log(`  ${ok('✓')} Python environment ready — codegraph enabled`);
+      }
+    }
+    console.log('');
+    return;
+  }
+
   if (!keys.length) {
     printSection('Install');
-    console.log(`  ${muted('Usage:')}  ctx install ${faint('[--claude] [--cursor] [--vscode] [--gemini] [--codex] [--windsurf] [--all]')}`);
+    console.log(`  ${muted('Usage:')}  ctx install ${faint('[--initial] [--claude] [--cursor] [--vscode] [--gemini] [--codex] [--windsurf] [--all]')}`);
+    console.log('');
+    console.log(`  ${accent('--initial      ')}  ${faint('Install / update Node.js + Python (codegraph) deps')}`);
     console.log('');
     console.log(`  Writes MCP config file + AI instruction file for each selected platform.`);
     console.log(`  Files are written into the ${accent('current directory')} (your project root).`);
@@ -700,6 +745,7 @@ function cmdOnline(args) {
   const host    = hostIdx !== -1 && args[hostIdx + 1] ? args[hostIdx + 1] : null;
   const git     = args.includes('--access-git');
   const restart = args.includes('--restart');
+  const close   = args.includes('--close');
 
   let cfg;
   try { cfg = getConfig(); } catch { cfg = { client_id: 'context-mcp', client_secret: '(unavailable)', port: 3100, host: 'localhost' }; }
@@ -710,6 +756,21 @@ function cmdOnline(args) {
   printSection('Online', `HTTP MCP server → Claude.ai / ChatGPT`);
   console.log('');
 
+  if (close) {
+    const existing2 = _checkExistingHttpServer(resolvedPort);
+    if (existing2.status === 'running') {
+      if (existing2.pid) {
+        try { process.kill(existing2.pid); } catch {}
+      }
+      try { unlinkSync(_httpPidFile(resolvedPort)); } catch {}
+      const pidStr = existing2.pid ? `pid ${existing2.pid}  ·  ` : '';
+      console.log(`  ${ok('✓')} ${bold('server stopped')}  ${faint(pidStr + 'port ' + resolvedPort)}\n`);
+    } else {
+      console.log(`  ${warn('–')} no server running on port ${resolvedPort}\n`);
+    }
+    return;
+  }
+
   // Check if a server is already running on this port
   const existing = _checkExistingHttpServer(resolvedPort);
   if (existing.status === 'running') {

package/src/tools/context.js

@@ -1,9 +1,19 @@
+import { execFileSync } from 'node:child_process';
+import { guardPath } from '../guard.js';
 import {
   saveContext, updateContext, getContext, deleteContext,
   listProjects, findDuplicate, archiveExpired, linkContextToDiscussion,
   listDiscussions, listGraphs, countContext, shouldCompact, compactProject,
   ensureProject, getProjectRoot,
 } from '../db.js';
+
+function detectGitRoot() {
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: process.cwd(), encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch { return null; }
+}
 import { summarizeEntries } from '../summarizer.js';
 import { fireAutoLink } from '../hooks/autoLink.js';
 
@@ -71,10 +81,12 @@ export async function handle(args, state) {
       // 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
-      if (proj) ensureProject(proj, args.rootPath || undefined);
+      // 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;
-      state.projectRootPath = args.rootPath || storedRoot || 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 })
         .filter(e => e.status !== 'archived');
@@ -105,6 +117,9 @@ export async function handle(args, state) {
         stats:              { totalEntries, projects: listProjects().length },
         message: `Loaded ${totalEntries} entries for project "${proj || 'global'}".${discussions.length === 1 ? ` Auto-linked to discussion "${discussions[0].name}".` : ''}`,
         rootPath: state.projectRootPath || undefined,
+        sandbox: state.projectRootPath
+          ? `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.`
           : 'No graph built yet. Call codegraph_build on the project root to enable graph queries.',
@@ -114,6 +129,27 @@ 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) {
+          const detected = state.projectRootPath || detectGitRoot();
+          if (detected) {
+            ensureProject(args.project, detected);
+            if (!state.projectRootPath) state.projectRootPath = detected;
+          }
+        }
+      }
+      // 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); });
+        }
+        if (Array.isArray(args.codeRefs)) {
+          args.codeRefs.forEach(r => { if (r.file) guardPath(r.file, state.projectRootPath); });
+        }
+      }
+
       const dupe = findDuplicate(args.content, args.project);
       if (dupe) {
         const updated = updateContext({

package/src/tools/fileTools.js

@@ -20,28 +20,30 @@ function atomicWrite(filePath, data) {
   }
 }
 
+const ROOT_NOTE = ' Sandboxed to project root — paths outside root are denied.';
+
 export const definitions = [
   {
     name: 'create_dir',
-    description: 'Create a directory (and any missing parent directories). Safe to call if already exists.',
+    description: 'Create a directory (and any missing parent directories). Safe to call if already exists.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
     outputSchema: { type: 'object', properties: { path: { type: 'string' }, existed: { type: 'boolean' }, message: { type: 'string' } } },
   },
   {
     name: 'list_dir',
-    description: 'List the contents of a local directory.',
+    description: 'List the contents of a local directory.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
     outputSchema: { type: 'object', properties: { directory: { type: 'string' }, items: { type: 'array' } } },
   },
   {
     name: 'read_file',
-    description: 'Read the text contents of a local file.',
+    description: 'Read the text contents of a local file.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
     outputSchema: { type: 'object', properties: { file: { type: 'string' }, content: { type: 'string' } } },
   },
   {
     name: 'write_file',
-    description: 'Create a new file or overwrite an existing file.',
+    description: 'Create a new file or overwrite an existing file.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { path: { type: 'string' }, content: { type: 'string' } }, required: ['path', 'content'] },
     outputSchema: { type: 'object', properties: { file: { type: 'string' }, message: { type: 'string' } } },
   },
@@ -51,7 +53,7 @@ export const definitions = [
       `Apply targeted string replacement(s) to a file.\n` +
       `Single edit: pass old_str + new_str.\n` +
       `Multi edit:  pass edits:[{old_str, new_str, description?}] — atomic.\n` +
-      `Use dry_run:true to validate without writing.`,
+      `Use dry_run:true to validate without writing.` + ROOT_NOTE,
     inputSchema: {
       type: 'object',
       properties: {
@@ -68,7 +70,7 @@ export const definitions = [
   },
   {
     name: 'delete_file',
-    description: 'Delete a local file. Pass recursive:true to delete a directory and its contents.',
+    description: 'Delete a local file. Pass recursive:true to delete a directory and its contents.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { path: { type: 'string' }, recursive: { type: 'boolean', description: 'Required to delete a directory. Defaults to false.' } }, required: ['path'] },
     outputSchema: { type: 'object', properties: { path: { type: 'string' }, message: { type: 'string' } } },
   },

package/src/tools/gitTools.js

@@ -15,69 +15,85 @@ function runGit(argArr, cwd) {
   }
 }
 
+function autoDetectRoot(fromDir) {
+  try {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: fromDir, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
 function resolveCwd(args, state) {
-  const raw = args.cwd ? pathResolve(args.cwd) : process.cwd();
-  // If a project root is configured, validate cwd is within it
+  // Auto-detect project root on first use if not already configured.
+  if (!state.projectRootPath) {
+    const detected = autoDetectRoot(args.cwd ? pathResolve(args.cwd) : process.cwd());
+    if (detected) state.projectRootPath = detected;
+  }
+  const raw = args.cwd ? pathResolve(args.cwd) : (state.projectRootPath || process.cwd());
   if (state.projectRootPath) return guardPath(raw, state.projectRootPath);
   return raw;
 }
 
+const ROOT_NOTE = ' All paths must be within the project root (sandboxed — access outside root is denied).';
+
 export const definitions = [
   {
     name: 'git_status',
-    description: 'Show working tree status — current branch, staged, unstaged, and untracked files.',
+    description: 'Show working tree status — current branch, staged, unstaged, and untracked files.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { cwd: { type: 'string' } } },
     outputSchema: { type: 'object', properties: { branch: { type: 'string' }, clean: { type: 'boolean' }, staged: { type: 'array' }, unstaged: { type: 'array' }, untracked: { type: 'array' } } },
   },
   {
     name: 'git_diff',
-    description: 'Show file changes. Use staged:true for cached diff. Optionally scope to a path.',
+    description: 'Show file changes. Use staged:true for cached diff. Optionally scope to a path.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { staged: { type: 'boolean' }, path: { type: 'string' }, cwd: { type: 'string' } } },
     outputSchema: { type: 'object', properties: { diff: { type: 'string' }, staged: { type: 'boolean' } } },
   },
   {
     name: 'git_log',
-    description: 'Show recent commit history — hash, author, date, message.',
+    description: 'Show recent commit history — hash, author, date, message.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { limit: { type: 'number' }, path: { type: 'string' }, cwd: { type: 'string' } } },
     outputSchema: { type: 'object', properties: { commits: { type: 'array' }, count: { type: 'number' } } },
   },
   {
     name: 'git_add',
-    description: 'Stage files for commit. Pass paths:["."] to stage everything.',
+    description: 'Stage files for commit. Pass paths:["."] to stage everything.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { paths: { type: 'array', items: { type: 'string' } }, cwd: { type: 'string' } }, required: ['paths'] },
     outputSchema: { type: 'object', properties: { success: { type: 'boolean' }, staged: { type: 'array' }, message: { type: 'string' } } },
   },
   {
     name: 'git_commit',
-    description: 'Commit staged changes. Set all:true to auto-stage tracked modified files first. Auto-saves context entry.',
+    description: 'Commit staged changes. Set all:true to auto-stage tracked modified files first. Auto-saves context entry.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { message: { type: 'string' }, all: { type: 'boolean' }, cwd: { type: 'string' } }, required: ['message'] },
     outputSchema: { type: 'object', properties: { success: { type: 'boolean' }, hash: { type: 'string' }, branch: { type: 'string' }, message: { type: 'string' }, files: { type: 'array' } } },
   },
   {
     name: 'git_push',
-    description: 'Push current branch to remote.',
+    description: 'Push current branch to remote.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { remote: { type: 'string' }, branch: { type: 'string' }, cwd: { type: 'string' } } },
     outputSchema: { type: 'object', properties: { success: { type: 'boolean' }, remote: { type: 'string' }, branch: { type: 'string' }, output: { type: 'string' } } },
   },
   {
     name: 'git_pull',
-    description: 'Pull from remote and merge into current branch.',
+    description: 'Pull from remote and merge into current branch.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { remote: { type: 'string' }, branch: { type: 'string' }, cwd: { type: 'string' } } },
     outputSchema: { type: 'object', properties: { success: { type: 'boolean' }, remote: { type: 'string' }, output: { type: 'string' } } },
   },
   {
     name: 'git_branch',
-    description: 'List, create, or checkout branches.',
+    description: 'List, create, or checkout branches.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'create', 'checkout'] }, name: { type: 'string' }, cwd: { type: 'string' } } },
   },
   {
     name: 'git_stash',
-    description: 'Stash or restore work-in-progress changes.',
+    description: 'Stash or restore work-in-progress changes.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { action: { type: 'string', enum: ['save', 'pop', 'list', 'drop'] }, message: { type: 'string' }, ref: { type: 'string' }, cwd: { type: 'string' } } },
   },
   {
     name: 'git_reset',
-    description: 'Unstage files or reset HEAD. Use mode:file + path to restore a single file.',
+    description: 'Unstage files or reset HEAD. Use mode:file + path to restore a single file.' + ROOT_NOTE,
     inputSchema: { type: 'object', properties: { mode: { type: 'string', enum: ['soft', 'mixed', 'hard', 'file'] }, path: { type: 'string' }, ref: { type: 'string' }, cwd: { type: 'string' } } },
   },
   {