vexp-cli 2.0.18 → 2.0.20

package/dist/agent-config.js

@@ -89,6 +89,7 @@ const VEXP_TOOLS = [
     "get_session_context",
     "search_memory",
     "save_observation",
+    "get_token_savings",
 ];
 // ---------------------------------------------------------------------------
 // Agent detectors — mirrors VS Code extension's AGENT_DETECTORS
@@ -397,6 +398,102 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
 // ---------------------------------------------------------------------------
 // File helpers — ported from agent-auto-config.ts
 // ---------------------------------------------------------------------------
+/**
+ * Parse JSON that may use JSONC syntax — `//` and slash-star comments and
+ * trailing commas. VS Code mcp.json and Zed settings.json are JSONC, so a raw
+ * JSON.parse throws on perfectly valid user files. Strips comments and trailing
+ * commas (preserving string contents) before parsing.
+ */
+export function parseJsonc(text) {
+    let out = "";
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        const next = text[i + 1];
+        if (inLineComment) {
+            if (c === "\n") {
+                inLineComment = false;
+                out += c;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (c === "*" && next === "/") {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            out += c;
+            if (c === "\\") {
+                out += next ?? "";
+                i++;
+            }
+            else if (c === '"')
+                inString = false;
+            continue;
+        }
+        if (c === '"') {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "/" && next === "/") {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (c === "/" && next === "*") {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        out += c;
+    }
+    out = out.replace(/,(\s*[}\]])/g, "$1");
+    return JSON.parse(out);
+}
+/**
+ * Read a JSON/JSONC config file without ever risking user data. When the file
+ * exists but cannot be parsed (even as JSONC), returns ok:false so callers skip
+ * the write instead of silently clobbering the user's config.
+ */
+export function readJsonConfigSafe(filePath) {
+    if (!fs.existsSync(filePath))
+        return { data: {}, ok: true, existed: false };
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return { data: {}, ok: false, existed: true };
+    }
+    if (raw.trim() === "")
+        return { data: {}, ok: true, existed: true };
+    try {
+        const parsed = parseJsonc(raw);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            return { data: parsed, ok: true, existed: true };
+        }
+    }
+    catch { /* fall through to ok:false */ }
+    return { data: {}, ok: false, existed: true };
+}
+/** Copy an existing config to <file>.vexp-bak before overwriting it. */
+function backupConfig(filePath) {
+    try {
+        if (fs.existsSync(filePath))
+            fs.copyFileSync(filePath, `${filePath}.vexp-bak`);
+    }
+    catch { /* non-fatal */ }
+}
+/** Warn that we refused to touch an unparseable config file. */
+function warnUnparseable(filePath) {
+    process.stderr.write(`  ⚠ ${filePath} could not be parsed — leaving it untouched. Fix the file or add vexp manually, then re-run setup.\n`);
+}
 function appendOrCreate(filePath, content, version) {
     if (!fs.existsSync(filePath)) {
         fs.mkdirSync(path.dirname(filePath), { recursive: true });
@@ -432,16 +529,13 @@ function appendOrCreate(filePath, content, version) {
     }
     return "updated";
 }
-function mergeJsonConfig(filePath, mergePayload, version) {
-    let existing = {};
-    if (fs.existsSync(filePath)) {
-        try {
-            existing = JSON.parse(fs.readFileSync(filePath, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+export function mergeJsonConfig(filePath, mergePayload, version) {
+    const read = readJsonConfigSafe(filePath);
+    if (!read.ok) {
+        warnUnparseable(filePath);
+        return "skipped";
     }
+    const existing = read.data;
     // Build the merged result first, then compare to avoid unnecessary writes.
     const merged = { ...existing };
     for (const [key, value] of Object.entries(mergePayload)) {
@@ -466,6 +560,8 @@ function mergeJsonConfig(filePath, mergePayload, version) {
     if (mergedStr === existingStr)
         return "skipped";
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    if (read.existed)
+        backupConfig(filePath);
     fs.writeFileSync(filePath, mergedStr, "utf-8");
     return "merged";
 }
@@ -476,16 +572,13 @@ function mergeJsonConfig(filePath, mergePayload, version) {
  * Write MCP config JSON for agents that use mcpServers format (Cursor, Windsurf).
  * Returns true if a new entry was written.
  */
-function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, workspaceRoot) {
-    let existing = {};
-    if (fs.existsSync(mcpConfigPath)) {
-        try {
-            existing = JSON.parse(fs.readFileSync(mcpConfigPath, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+export function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, workspaceRoot) {
+    const read = readJsonConfigSafe(mcpConfigPath);
+    if (!read.ok) {
+        warnUnparseable(mcpConfigPath);
+        return false;
     }
+    const existing = read.data;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
@@ -516,6 +609,8 @@ function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath, w
     };
     existing.mcpServers = servers;
     fs.mkdirSync(path.dirname(mcpConfigPath), { recursive: true });
+    if (read.existed)
+        backupConfig(mcpConfigPath);
     fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2), "utf-8");
     return true;
 }
@@ -610,16 +705,13 @@ function configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot) {
  * Write .vscode/mcp.json for GitHub Copilot.
  * VS Code uses "servers" (not "mcpServers") + "type": "stdio".
  */
-function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
-    let existing = {};
-    if (fs.existsSync(p)) {
-        try {
-            existing = JSON.parse(fs.readFileSync(p, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+export function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
+    const read = readJsonConfigSafe(p);
+    if (!read.ok) {
+        warnUnparseable(p);
+        return false;
     }
+    const existing = read.data;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
@@ -644,22 +736,21 @@ function writeVsCodeMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
     };
     existing.servers = servers;
     fs.mkdirSync(path.dirname(p), { recursive: true });
+    if (read.existed)
+        backupConfig(p);
     fs.writeFileSync(p, JSON.stringify(existing, null, 2), "utf-8");
     return true;
 }
 /**
  * Write context_servers in .zed/settings.json for Zed.
  */
-function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
-    let settings = {};
-    if (fs.existsSync(p)) {
-        try {
-            settings = JSON.parse(fs.readFileSync(p, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+export function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
+    const read = readJsonConfigSafe(p);
+    if (!read.ok) {
+        warnUnparseable(p);
+        return false;
     }
+    const settings = read.data;
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
     const targetCmd = useNode ? "node" : binaryPath;
     const targetArgs = useNode ? [mcpServerPath] : ["mcp"];
@@ -693,6 +784,8 @@ function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
     }
     settings.agent = { ...agent, tool_permissions: { ...tp, tools } };
     fs.mkdirSync(path.dirname(p), { recursive: true });
+    if (read.existed)
+        backupConfig(p);
     fs.writeFileSync(p, JSON.stringify(settings, null, 2), "utf-8");
     return true;
 }
@@ -700,20 +793,17 @@ function writeZedMcpConfig(p, binaryPath, mcpServerPath, workspaceRoot) {
  * Configure vexp MCP in ~/.claude.json (user-scope) using the Rust binary.
  * Returns true if config was written/updated.
  */
-function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
+export function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
     const home = os.homedir();
     if (!home)
         return false;
     const configPath = path.join(home, ".claude.json");
-    let config = {};
-    if (fs.existsSync(configPath)) {
-        try {
-            config = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+    const read = readJsonConfigSafe(configPath);
+    if (!read.ok) {
+        warnUnparseable(configPath);
+        return false;
     }
+    const config = read.data;
     const beforeServers = config.mcpServers;
     const existing = beforeServers?.["vexp"];
     const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
@@ -735,6 +825,8 @@ function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
         ...(desiredEnv ? { env: desiredEnv } : {}),
     };
     config.mcpServers = servers;
+    if (read.existed)
+        backupConfig(configPath);
     fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
     return true;
 }
@@ -746,7 +838,7 @@ function configureClaudeCodeGlobal(binaryPath, mcpServerPath, workspaceRoot) {
  * Creates .claude/hooks/vexp-guard.sh and merges hook config into .claude/settings.json.
  * Returns the action taken, or null if nothing was written.
  */
-function installClaudeCodeHook(workspaceRoot) {
+export function installClaudeCodeHook(workspaceRoot) {
     const hookDir = path.join(workspaceRoot, ".claude", "hooks");
     const hookPath = path.join(hookDir, "vexp-guard.sh");
     const settingsPath = path.join(workspaceRoot, ".claude", "settings.json");
@@ -760,15 +852,12 @@ function installClaudeCodeHook(workspaceRoot) {
     }
     fs.writeFileSync(hookPath, VEXP_GUARD_HOOK, { mode: 0o755 });
     // 2. Merge hook config into .claude/settings.json
-    let settings = {};
-    if (fs.existsSync(settingsPath)) {
-        try {
-            settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
-        }
-        catch {
-            // Malformed JSON: overwrite
-        }
+    const read = readJsonConfigSafe(settingsPath);
+    if (!read.ok) {
+        warnUnparseable(settingsPath);
+        return existed ? "updated" : "created";
     }
+    const settings = read.data;
     const hooks = (settings.hooks ?? {});
     const existingPreToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
     // Aggressively remove ALL vexp-related hook entries (old format, stale matchers, malformed)
@@ -805,6 +894,8 @@ function installClaudeCodeHook(workspaceRoot) {
         ],
     });
     settings.hooks = { ...hooks, PreToolUse: filtered };
+    if (read.existed)
+        backupConfig(settingsPath);
     fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     return existed ? "updated" : "created";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vexp-cli",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "Vexp — Context Engine for AI Coding Agents. Pre-indexes your codebase into a dependency graph and delivers ranked context to any MCP-compatible agent. 58% lower cost per task, 90% fewer tool calls (SWE-bench Verified). Works with Claude Code, Cursor, Copilot, Windsurf, Codex, Cline, Aider, and 12+ agents. Local-first. Your code never leaves your machine.",
   "type": "module",
   "bin": {
@@ -9,6 +9,7 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsx src/cli.ts",
+    "test": "node --import tsx --test test/*.test.ts",
     "clean": "rm -rf dist",
     "clean:artifacts": "node -e \"const fs=require('fs'),p=require('path');function w(d){if(!fs.existsSync(d))return;for(const e of fs.readdirSync(d,{withFileTypes:true})){const f=p.join(d,e.name);if(e.isDirectory())w(f);else if(/\\.(map|d\\.ts|d\\.ts\\.map)$/.test(e.name))fs.unlinkSync(f);}}w('dist');w('mcp');\"",
     "prepublishOnly": "npm run build && npm run clean:artifacts"
@@ -99,10 +100,10 @@
     "node": ">=20.0.0"
   },
   "optionalDependencies": {
-    "@vexp/core-linux-x64": "2.0.18",
-    "@vexp/core-linux-arm64": "2.0.18",
-    "@vexp/core-darwin-x64": "2.0.18",
-    "@vexp/core-darwin-arm64": "2.0.18",
-    "@vexp/core-win32-x64": "2.0.18"
+    "@vexp/core-linux-x64": "2.0.20",
+    "@vexp/core-linux-arm64": "2.0.20",
+    "@vexp/core-darwin-x64": "2.0.20",
+    "@vexp/core-darwin-arm64": "2.0.20",
+    "@vexp/core-win32-x64": "2.0.20"
   }
 }