vexp-cli 1.3.11 → 2.0.3

package/README.md

@@ -1,18 +1,24 @@
 # vexp — Context Engine for AI Coding Agents
 
-**Save 70% of tokens. Get 2x better answers. Your code never leaves your machine.**
+**58% Less Cost. 90% Fewer Tool Calls. 100% On Your Machine.**
 
 vexp is a local-first context engine that gives AI coding agents the right code context — automatically. One install, and every agent gets smarter answers with fewer tokens.
 
-Works with **12+ AI coding agents** and **30 programming languages** out of the box.
+Works with **14+ AI coding agents** and **30 programming languages** out of the box.
+
+→ [SWE-bench Verified: 73% pass@1 at $0.67/task](https://vexp.dev/benchmark)
 
 ## Why vexp?
 
-AI coding agents dump entire files into their context window, burning tokens and getting confused. vexp solves this with a local code graph that delivers only the relevant symbols, call chains, and dependencies — compressed to 70% fewer tokens.
+AI coding agents waste more than half their budget exploring codebases before writing a single line of code — 23 tool calls on average just to orient themselves. vexp pre-indexes your project into a dependency graph and delivers only the code that matters, ranked by relevance.
 
+- **23 tool calls → 2** — the agent stops guessing and starts coding
+- **$0.78 → $0.33 per task** — measured on SWE-bench Verified
+- **117s → 74s per task** — less context to process = faster answers
 - **Local-first** — your code never leaves your machine
 - **Zero config** — auto-detects your agents and configures MCP
 - **Universal** — works with any agent that supports MCP or custom rules
+- **Optional local AI** — unlock +30% extra savings with `vexp-devmind`, a ~3.5 GB model that runs 100% on your machine. GPU-accelerated on NVIDIA (CUDA) and Apple Silicon (Metal). Opt in with one command.
 
 ## Supported AI Coding Agents
 
@@ -26,11 +32,15 @@ AI coding agents dump entire files into their context window, burning tokens and
 | Augment | ✓ |
 | Zed | ✓ |
 | Codex (OpenAI) | ✓ |
+| Cline | ✓ |
+| Aider | ✓ |
 | Kilo Code | ✓ |
 | Kiro | ✓ |
 | Antigravity | ✓ |
 | Opencode | ✓ |
 
+Your agents don't compete with each other — they all share the same context layer.
+
 ## Supported Languages (30)
 
 TypeScript, JavaScript, Python, Go, Rust, Java, C#, C, C++, Ruby, Kotlin, Scala, Swift, Dart, Elixir, Haskell, OCaml, Lua, R, PHP, Zig, HCL/Terraform, Objective-C, Bash/Shell, Dockerfile, Clojure, F#, SQL, HTML/CSS, YAML/JSON
@@ -44,18 +54,50 @@ vexp
 
 That's it. The interactive CLI guides you through setup, indexing, and agent configuration.
 
+## What You Get
+
+- **Semantic + graph-ranked context** — finds the right symbols even when keywords don't match
+- **Intent detection in 15 languages** — English, Italian, French, German, Spanish, Portuguese, Russian, Chinese, Japanese, Korean, Arabic, Hindi, Turkish, Dutch, Polish
+- **Cross-session memory** — your agent picks up exactly where it left off, even days later
+- **Stale-knowledge alerts** — when code changes, outdated memory is automatically flagged
+- **Pattern & anti-pattern detection** — recurring changes surface as guidelines; dead-end explorations get flagged early
+- **Change awareness** — files frequently modified together are automatically linked
+- **Security filter** — `.env`, credentials, and SSH keys are excluded automatically
+
 ## Platforms
 
-| Platform | Architecture |
-|----------|:-:|
-| Linux | x64, ARM64 |
-| macOS | x64, ARM64 (Apple Silicon) |
-| Windows | x64 |
+Native binaries — no runtime dependencies:
+
+| Platform | Architecture | GPU Acceleration |
+|----------|:-:|:-:|
+| Linux | x64, ARM64 | CUDA (NVIDIA) |
+| macOS | x64, ARM64 (Apple Silicon) | Metal (built-in) |
+| Windows | x64 | CUDA (NVIDIA) |
+
+GPU acceleration applies to the optional local AI layer. Vexp's core context engine runs on any modern CPU.
 
 ## VS Code Extension
 
 For the best experience, install the [vexp VS Code extension](https://marketplace.visualstudio.com/items?itemName=Vexp.vexp-vscode) — it manages the daemon automatically and adds a sidebar dashboard with token savings tracking.
 
+## Local AI — Optional +30% Savings
+
+Turn on `vexp-devmind` — a code-specialised AI model that runs entirely on your machine — for an extra +30% token savings on top of the baseline.
+
+- **100% local** — the model never calls out. Your code stays on your hardware.
+- **GPU-accelerated** — Metal on Apple Silicon, CUDA on NVIDIA. Auto-detected.
+- **One-command install** — ~3.5 GB one-time download. Minimum 6 GB RAM.
+- **Always up to date** — `--check-updates` compares your local version to the published release without downloading anything.
+
+Sharper context ranking, higher-quality session memory, smarter prompt preprocessing. All without sending a single byte to any server.
+
+```bash
+vexp setup-llm --install        # ~3.5 GB one-time download
+vexp setup-llm --check-updates  # no-op if already up to date
+vexp setup-llm --status         # show current config + hardware
+vexp setup-llm --disable        # turn it off any time
+```
+
 ## Links
 
 - [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=Vexp.vexp-vscode)

package/dist/agent-config.js

@@ -9,6 +9,7 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import * as crypto from "crypto";
 import { VEXP_GUARD_HOOK } from "./hook-template.js";
 // ---------------------------------------------------------------------------
 // Constants
@@ -206,9 +207,9 @@ export function configureAgents(workspaceRoot, binaryPath, version, agentFilter,
                 });
             }
         }
-        // Codex: configure MCP in ~/.codex/config.toml (global, TOML format)
+        // Codex: configure MCP in ~/.codex/config.toml (global, HTTP + bearer token)
         if (detector.agent === "Codex") {
-            const wrote = configureCodexGlobal(binaryPath, mcpServerPath);
+            const wrote = configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot);
             if (wrote)
                 mcpConfigs.push("~/.codex/config.toml");
         }
@@ -315,7 +316,7 @@ export function configureSelectedAgents(workspaceRoot, binaryPath, version, sele
             installClaudeCodeHook(workspaceRoot);
         }
         if (detector.agent === "Codex") {
-            const wrote = configureCodexGlobal(binaryPath, mcpServerPath);
+            const wrote = configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot);
             if (wrote)
                 mcpConfigs.push("~/.codex/config.toml");
         }
@@ -449,33 +450,74 @@ function writeMcpConfig(mcpConfigPath, binaryPath, alwaysAllow, mcpServerPath) {
     fs.writeFileSync(mcpConfigPath, JSON.stringify(existing, null, 2), "utf-8");
     return true;
 }
+/**
+ * Read or generate a bearer token for MCP HTTP auth.
+ * Persists to ~/.vexp/mcp.token so the MCP server and Codex config share it.
+ */
+function resolveCodexToken() {
+    const home = os.homedir();
+    const tokenPath = home ? path.join(home, ".vexp", "mcp.token") : "";
+    if (tokenPath) {
+        try {
+            const existing = fs.readFileSync(tokenPath, "utf-8").trim();
+            if (existing)
+                return existing;
+        }
+        catch { /* not yet created */ }
+    }
+    const token = crypto.randomUUID();
+    if (tokenPath) {
+        try {
+            fs.mkdirSync(path.dirname(tokenPath), { recursive: true });
+            fs.writeFileSync(tokenPath, token, { mode: 0o600 });
+        }
+        catch { /* non-fatal */ }
+    }
+    return token;
+}
+/**
+ * Read the MCP HTTP port from .vexp/mcp.port, or return the default.
+ */
+function readMcpPort(workspaceRoot) {
+    const DEFAULT_PORT = 7821;
+    if (workspaceRoot) {
+        try {
+            const portStr = fs.readFileSync(path.join(workspaceRoot, ".vexp", "mcp.port"), "utf-8").trim();
+            const port = parseInt(portStr, 10);
+            if (port > 0)
+                return port;
+        }
+        catch { /* file doesn't exist */ }
+    }
+    return DEFAULT_PORT;
+}
 /**
  * Configure MCP in ~/.codex/config.toml (global).
  * Codex only reads the global config, not project-level .codex/config.toml.
+ * Uses HTTP transport with bearer token so Codex shows "Auth: BearerToken"
+ * instead of "Auth: Unsupported" (which is hardcoded for stdio servers).
  * Uses TOML format with [mcp_servers.<name>] sections.
  */
-function configureCodexGlobal(binaryPath, mcpServerPath) {
+function configureCodexGlobal(binaryPath, mcpServerPath, workspaceRoot) {
     const home = os.homedir();
     if (!home)
         return false;
     const configPath = path.join(home, ".codex", "config.toml");
+    const mcpPort = readMcpPort(workspaceRoot);
+    const token = resolveCodexToken();
+    const newSection = `\n[mcp_servers.vexp]\nurl = "http://127.0.0.1:${mcpPort}/mcp"\ntool_timeout_sec = 120\n\n[mcp_servers.vexp.http_headers]\nAuthorization = "Bearer ${token}"\n`;
     let content = "";
     if (fs.existsSync(configPath)) {
         content = fs.readFileSync(configPath, "utf-8");
     }
     fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    const useNode = mcpServerPath && fs.existsSync(mcpServerPath);
-    const cmd = useNode ? "node" : binaryPath;
-    const arg = useNode ? mcpServerPath : "mcp";
-    const escapedCmd = cmd.replace(/\\/g, "\\\\");
-    const escapedArg = arg.replace(/\\/g, "\\\\");
-    const newSection = `\n[mcp_servers.vexp]\ncommand = "${escapedCmd}"\nargs = ["${escapedArg}"]\nstartup_timeout_sec = 30\ntool_timeout_sec = 120\n`;
     if (content.includes("[mcp_servers.vexp]")) {
-        // Already configured — check if args match (path includes version, may change on update)
-        if (content.includes(`args = ["${escapedArg}"]`))
-            return false; // Already up to date
-        // Remove old section and replace
-        content = content.replace(/\n?\[mcp_servers\.vexp\][^\[]*/, "");
+        // Check if already up to date (same URL and token)
+        if (content.includes(`url = "http://127.0.0.1:${mcpPort}/mcp"`) &&
+            content.includes(`Authorization = "Bearer ${token}"`))
+            return false;
+        // Remove old section(s) — handles both stdio (command=) and http (url=) formats
+        content = content.replace(/\n?\[mcp_servers\.vexp(?:\.http_headers)?\][^\[]*/g, "");
     }
     content += newSection;
     fs.writeFileSync(configPath, content, "utf-8");
@@ -716,14 +758,9 @@ Only use Read when you need exact raw content to edit a specific line.
   - \`run_pipeline({ "task": "add auth", "observation": "using JWT" })\` — save insight in same call
 
 ### Other MCP tools (use only when run_pipeline is insufficient)
-- \`get_context_capsule\` — lightweight alternative for simple questions only
-- \`get_impact_graph\` — standalone deep impact analysis of a specific symbol
-- \`search_logic_flow\` — trace execution paths between two specific symbols
 - \`get_skeleton\` — **preferred over Read** for inspecting files (minimal/standard/detailed detail levels, 70-90% token savings)
 - \`index_status\` — indexing status and health check
-- \`get_session_context\` — recall observations from current/previous sessions
-- \`search_memory\` — cross-session search for past decisions
-- \`save_observation\` — persist insights (prefer using run_pipeline's observation param instead)
+- \`expand_vexp_ref\` — expand V-REF hash placeholders in v2 compact output
 
 ### Workflow
 1. \`run_pipeline("your task")\` — ALWAYS FIRST. Returns pivots + impact + memories in 1 call
@@ -776,14 +813,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -820,14 +852,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -874,14 +901,9 @@ When working on this codebase:
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — standalone impact analysis
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — token-efficient file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -909,14 +931,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -944,14 +961,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -979,14 +991,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Auto-detects intent. Includes file content. Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -1014,14 +1021,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ## Available vexp tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — trace execution paths
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ## Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -1049,14 +1051,9 @@ vexp returns pre-indexed, graph-ranked context in a single call.
 ### Available MCP tools
 - \`run_pipeline\` — **PRIMARY TOOL**. Runs capsule + impact + memory in 1 call.
   Example: \`run_pipeline({ "task": "fix auth bug" })\`
-- \`get_context_capsule\` — lightweight, for simple questions only
-- \`get_impact_graph\` — impact analysis of a specific symbol
-- \`search_logic_flow\` — execution paths between functions
 - \`get_skeleton\` — compact file structure
 - \`index_status\` — indexing status
-- \`get_session_context\` — recall observations from sessions
-- \`search_memory\` — cross-session search
-- \`save_observation\` — persist insights (prefer run_pipeline's observation param)
+- \`expand_vexp_ref\` — expand V-REF placeholders in v2 output
 
 ### Agentic search
 - Do NOT use built-in file search, grep, or codebase indexing — always call \`run_pipeline\` first
@@ -1070,4 +1067,3 @@ Intent auto-detection, hybrid ranking, session memory, auto-expanding budget.
 \`run_pipeline\` auto-queries all indexed repos. Use \`repos: ["alias"]\` to scope. Run \`index_status\` to see aliases.
 <!-- /vexp -->`;
 }
-//# sourceMappingURL=agent-config.js.map

package/dist/binary.js

@@ -10,6 +10,24 @@ const PLATFORM_PACKAGES = {
     "win32-x64": "@vexp/core-win32-x64",
     "win32-arm64": "@vexp/core-win32-x64", // ARM64 Windows uses x64 binary via emulation
 };
+// A single core binary per OS/arch decides at RUNTIME which backend to
+// use (CPU, Metal, CUDA) via ggml's dynamic plugin loader. The CUDA
+// plugin is downloaded on-demand by `vexp setup-llm` when an NVIDIA
+// driver is detected — no separate GPU binary package.
+//
+// The `--gpu` / `--cuda` flags and VEXP_GPU / VEXP_CUDA env vars are
+// forwarded to the Rust core as VEXP_PREFER_GPU=1, which flips
+// prefer_gpu=true on the llama.cpp load. If no GPU plugin is present,
+// llama.cpp silently falls back to CPU.
+function gpuRequested() {
+    return (process.env.VEXP_GPU === "1" ||
+        process.env.VEXP_CUDA === "1" ||
+        process.argv.includes("--gpu") ||
+        process.argv.includes("--cuda"));
+}
+export function preferGpuEnv() {
+    return gpuRequested() ? { VEXP_PREFER_GPU: "1" } : {};
+}
 export function getBinaryPath() {
     // Dev override: use VEXP_CORE_PATH env var to point to a local binary
     const envPath = process.env.VEXP_CORE_PATH;
@@ -93,4 +111,3 @@ export async function getInstalledVersion() {
         return null;
     }
 }
-//# sourceMappingURL=binary.js.map

package/dist/cli.js

@@ -2,14 +2,14 @@
 import { Command } from "commander";
 import chalk from "chalk";
 import ora from "ora";
-import { spawn, spawnSync } from "child_process";
+import { spawn, spawnSync, execFileSync } from "child_process";
 import * as path from "path";
 import * as fs from "fs";
 import { checkbox } from "@inquirer/prompts";
 import { getBinaryPath, getInstalledVersion, getMcpServerPath } from "./binary.js";
 import { detectAgents, getAgentList, configureSelectedAgents } from "./agent-config.js";
 import { CLI_VERSION } from "./version.js";
-import { activateLicense, deactivateLicense, readLicenseLimits, } from "./license.js";
+import { activateLicense, deactivateLicense, readLicenseLimits, readDeviceBlocked, } from "./license.js";
 import { checkForUpdate } from "./update-check.js";
 const program = new Command();
 program
@@ -163,14 +163,57 @@ program
     .command("savings")
     .description("Show token savings statistics")
     .option("--days <n>", "Number of days to analyze", "30")
+    .option("--today", "Show savings for today only (since local midnight)")
     .option("--export", "Export report to .vexp/token-savings-report.md")
     .action(async (opts) => {
     const binaryPath = ensureBinary();
-    const args = ["savings", "--days", opts.days];
+    const args = ["savings"];
+    if (opts.today) {
+        // Compute local midnight in unix seconds so the Rust core aggregates
+        // only events from today in the caller's timezone.
+        const midnight = new Date();
+        midnight.setHours(0, 0, 0, 0);
+        const sinceTs = Math.floor(midnight.getTime() / 1000);
+        args.push("--since-ts", String(sinceTs), "--label", "today");
+    }
+    else {
+        args.push("--days", opts.days);
+    }
     if (opts.export)
         args.push("--export");
     runBinary(binaryPath, args);
 });
+program
+    .command("compress <file>")
+    .description("Compress a markdown/text file using caveman-style prose compression (backup to <name>.original.md)")
+    .option("--level <lvl>", "Compression level: off | lite | full | ultra", "full")
+    .action(async (file, opts) => {
+    const binaryPath = ensureBinary();
+    runBinary(binaryPath, ["compress", file, "--level", opts.level]);
+});
+program
+    .command("setup-llm")
+    .description("Configure optional local LLM compression (vexp-devmind). Runs interactive wizard by default.")
+    .option("--status", "Print current LLM config and readiness")
+    .option("--disable", "Disable LLM compression without removing model files")
+    .option("--install", "Non-interactive install (for CI / first-run)")
+    .option("--check-updates", "Check for model updates without downloading")
+    .option("--enable", "Enable a previously-installed LLM without re-downloading anything")
+    .action(async (opts) => {
+    const binaryPath = ensureBinary();
+    const args = ["setup-llm"];
+    if (opts.status)
+        args.push("--status");
+    if (opts.disable)
+        args.push("--disable");
+    if (opts.install)
+        args.push("--install");
+    if (opts.checkUpdates)
+        args.push("--check-updates");
+    if (opts.enable)
+        args.push("--enable");
+    runBinary(binaryPath, args);
+});
 program
     .command("hooks <action>")
     .description("Manage git hooks (install, check, remove)")
@@ -273,6 +316,46 @@ program
     catch {
         spinnerDaemon.warn("Daemon already running or failed to start (non-fatal)");
     }
+    // Step 2.6: Start MCP HTTP server (needed for Codex and HTTP-based agents)
+    const mcpPath = getMcpServerPath();
+    if (mcpPath) {
+        const spinnerMcp = ora("Starting MCP HTTP server...").start();
+        try {
+            const { randomUUID } = await import("crypto");
+            const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+            let mcpToken = "";
+            const tokenPath = home ? path.join(home, ".vexp", "mcp.token") : "";
+            if (tokenPath) {
+                try {
+                    mcpToken = fs.readFileSync(tokenPath, "utf-8").trim();
+                }
+                catch { }
+            }
+            if (!mcpToken) {
+                mcpToken = randomUUID();
+                if (tokenPath) {
+                    fs.mkdirSync(path.dirname(tokenPath), { recursive: true });
+                    fs.writeFileSync(tokenPath, mcpToken, { mode: 0o600 });
+                }
+            }
+            const mcpChild = spawn("node", [mcpPath, "--http", "--port=7821"], {
+                detached: true,
+                stdio: "ignore",
+                env: {
+                    ...process.env,
+                    VEXP_WORKSPACE: workspaceRoot,
+                    VEXP_HTTP: "1",
+                    VEXP_PORT: "7821",
+                    VEXP_MCP_TOKEN: mcpToken,
+                },
+            });
+            mcpChild.unref();
+            spinnerMcp.succeed("MCP HTTP server started (port 7821)");
+        }
+        catch {
+            spinnerMcp.warn("MCP HTTP server failed to start (non-fatal)");
+        }
+    }
     // In personal mode, make .vexp/ fully gitignored
     if (isPersonal) {
         const vexpGitignore = path.join(workspaceRoot, ".vexp", ".gitignore");
@@ -541,6 +624,12 @@ program
     console.log(`  All tools: ${limits.allTools ? "yes" : "no (7/10)"}`);
     if (limits.renewsAt)
         console.log(`  Renews:    ${limits.renewsAt.toLocaleDateString()}`);
+    const blocked = readDeviceBlocked();
+    if (blocked) {
+        console.log("");
+        console.log(chalk.yellow(`  ⚠ This machine is not registered (${blocked.maxDevices}/${blocked.maxDevices} slots used).`));
+        console.log(chalk.dim(`    Free a slot at ${blocked.manageUrl} and run a vexp command\n    to re-register this device.`));
+    }
     console.log("");
 });
 // ────────────────────────────────────────────────────
@@ -562,6 +651,7 @@ const MENU_CONFIG = [
     { key: "3", label: "setup", hint: "Full setup (index + agents + hooks)", description: "One-command bootstrap: indexes the codebase, detects AI agents,\n    writes MCP configs, installs git hooks." },
     { key: "4", label: "setup-agents", hint: "Choose which AI agents to configure", description: "Select agents (Claude, Cursor, Windsurf, Copilot, …) to configure.\n    Creates config directories and writes MCP settings for each." },
     { key: "5", label: "daemon-cmd", hint: "Manage daemon (start/stop/status/logs)", description: "Controls the background daemon:\n    start  → launches the daemon (indexes + watches for changes)\n    stop   → stops the running daemon\n    status → shows node/edge/file counts\n    logs   → prints .vexp/vexp.log" },
+    { key: "6", label: "setup-llm", hint: "Configure local LLM compression (vexp-devmind)", description: "Install, update, or disable the optional local LLM (vexp-devmind).\n    Runs entirely on your machine (~3.5 GB download).\n    Enables smart prompt preprocessing and higher-quality memory compression." },
 ];
 // ── Sub-menu: Explore & Analyze ──
 const MENU_EXPLORE = [
@@ -592,10 +682,30 @@ function printBanner() {
     console.log(chalk.dim("    ╚═══╝  ╚══════╝╚═╝  ╚═╝╚═╝") + chalk.dim(`  v${version}`));
     console.log("");
     console.log(chalk.dim("  Context Engine for AI Coding Agents"));
+    // One-liner LLM status
+    try {
+        const llmBin = ensureBinary();
+        const stdout = execFileSync(llmBin, ["setup-llm", "--status"], {
+            timeout: 5000,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const operational = /Operational:\s*true/.test(stdout);
+        const model = stdout.match(/Model:\s*(.+)/)?.[1]?.trim() ?? "";
+        if (operational) {
+            console.log(chalk.green(`  ● LLM: ${model} (active)`));
+        }
+        else {
+            console.log(chalk.dim("  ○ LLM: not configured — type 'setup-llm' or press 1 > 6"));
+        }
+    }
+    catch {
+        // Binary not available or no local_llm feature — skip silently
+    }
 }
 function printMainMenu() {
     console.log("");
-    console.log(`   ${chalk.cyan.bold("1")}  ${chalk.green("Setup & Config".padEnd(20))} ${chalk.dim("Initialize, index, and configure agents")}`);
+    console.log(`   ${chalk.cyan.bold("1")}  ${chalk.green("Setup & Config".padEnd(20))} ${chalk.dim("Initialize, index, configure agents & LLM")}`);
     console.log(`   ${chalk.cyan.bold("2")}  ${chalk.green("Explore & Analyze".padEnd(20))} ${chalk.dim("Query context, skeletons, impact, flow")}`);
     console.log(`   ${chalk.cyan.bold("3")}  ${chalk.green("Token Savings".padEnd(20))} ${chalk.dim("View savings stats, export report")}`);
     console.log(`   ${chalk.cyan.bold("4")}  ${chalk.green("License".padEnd(20))} ${chalk.dim("View or activate your license")}`);
@@ -732,6 +842,41 @@ async function executeCommand(label, rl) {
                 }
                 break;
             }
+            case "setup-llm": {
+                console.log("");
+                console.log(chalk.cyan("    Local LLM compression (vexp-devmind)"));
+                console.log(chalk.dim("    All processing runs locally — no data leaves your machine.\n"));
+                console.log(`    ${chalk.bold("1")}  Install / Reinstall (~3.5 GB download)`);
+                console.log(`    ${chalk.bold("2")}  Start               (enable without re-downloading)`);
+                console.log(`    ${chalk.bold("3")}  Check for updates   (no download if up to date)`);
+                console.log(`    ${chalk.bold("4")}  Status              (show current config + hardware)`);
+                console.log(`    ${chalk.bold("5")}  Disable             (keep files, stop using LLM)`);
+                console.log(`    ${chalk.dim("b")}  ${chalk.dim("Cancel")}`);
+                console.log("");
+                const llmChoice = await ask(rl, chalk.cyan("    Choose: "));
+                const llmBinary = ensureBinary();
+                switch (llmChoice.trim()) {
+                    case "1":
+                        console.log(chalk.dim("    Starting LLM setup (this may take several minutes)…\n"));
+                        runBinary(llmBinary, ["setup-llm", "--install"]);
+                        break;
+                    case "2":
+                        runBinary(llmBinary, ["setup-llm", "--enable"]);
+                        break;
+                    case "3":
+                        runBinary(llmBinary, ["setup-llm", "--check-updates"]);
+                        break;
+                    case "4":
+                        runBinary(llmBinary, ["setup-llm", "--status"]);
+                        break;
+                    case "5":
+                        runBinary(llmBinary, ["setup-llm", "--disable"]);
+                        break;
+                    default:
+                        console.log(chalk.dim("    Cancelled."));
+                }
+                break;
+            }
             // ── Explore commands ──
             case "capsule": {
                 const query = await ask(rl, chalk.cyan("    Describe your task: "));
@@ -772,17 +917,33 @@ async function executeCommand(label, rl) {
             }
             case "savings": // fallthrough from direct command
             case "summary": {
-                const daysInput = await ask(rl, chalk.cyan("    Period in days (7/14/30/60/90): "));
-                const days = parseInt(daysInput.trim(), 10) || 30;
+                const input = await ask(rl, chalk.cyan("    Period (today / 7 / 14 / 30 / 60 / 90): "));
                 const binaryPath = ensureBinary();
-                runBinary(binaryPath, ["savings", "--days", String(days)]);
+                const trimmed = input.trim().toLowerCase();
+                if (trimmed === "today") {
+                    const midnight = new Date();
+                    midnight.setHours(0, 0, 0, 0);
+                    runBinary(binaryPath, ["savings", "--since-ts", String(Math.floor(midnight.getTime() / 1000)), "--label", "today"]);
+                }
+                else {
+                    const days = parseInt(trimmed, 10) || 30;
+                    runBinary(binaryPath, ["savings", "--days", String(days)]);
+                }
                 break;
             }
             case "export": {
-                const daysInput = await ask(rl, chalk.cyan("    Period in days (7/14/30/60/90): "));
-                const days = parseInt(daysInput.trim(), 10) || 30;
+                const input = await ask(rl, chalk.cyan("    Period (today / 7 / 14 / 30 / 60 / 90): "));
                 const binaryPath = ensureBinary();
-                runBinary(binaryPath, ["savings", "--days", String(days), "--export"]);
+                const trimmed = input.trim().toLowerCase();
+                if (trimmed === "today") {
+                    const midnight = new Date();
+                    midnight.setHours(0, 0, 0, 0);
+                    runBinary(binaryPath, ["savings", "--since-ts", String(Math.floor(midnight.getTime() / 1000)), "--label", "today", "--export"]);
+                }
+                else {
+                    const days = parseInt(trimmed, 10) || 30;
+                    runBinary(binaryPath, ["savings", "--days", String(days), "--export"]);
+                }
                 break;
             }
             // ── License commands ──
@@ -838,4 +999,3 @@ if (process.argv.length <= 2) {
 else {
     program.parse();
 }
-//# sourceMappingURL=cli.js.map

package/dist/hook-template.js

@@ -18,4 +18,3 @@ else
 fi
 exit 0
 `;
-//# sourceMappingURL=hook-template.js.map