@context-engine-bridge/context-engine-mcp-bridge 0.0.29 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@context-engine-bridge/context-engine-mcp-bridge",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "description": "Context Engine MCP bridge (http/stdio proxy combining indexer + memory servers)",
   "bin": {
     "ctxce": "bin/ctxce.js",

package/src/mcpServer.js

@@ -3,7 +3,8 @@ import fs from "node:fs";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
-import { createServer } from "node:http";
+import os from "node:os";
+import http, { createServer } from "node:http";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
@@ -14,6 +15,116 @@ import { loadAnyAuthEntry, loadAuthEntry, readConfig, saveAuthEntry } from "./au
 import { maybeRemapToolArgs, maybeRemapToolResult } from "./resultPathMapping.js";
 import * as oauthHandler from "./oauthHandler.js";
 
+let _lspConnCache;
+let _lspConnCacheTs = 0;
+const LSP_CONN_CACHE_TTL = 5000;
+const LSP_CONN_MAX_AGE = 60 * 60 * 1000;
+
+function _isValidPort(v) {
+  const p = Number.parseInt(String(v), 10);
+  return Number.isFinite(p) && p >= 1024 && p <= 65535;
+}
+
+function _readLspConnection() {
+  const envPort = process.env.CTXCE_LSP_PORT;
+  if (envPort && _isValidPort(envPort)) return { port: envPort, secret: process.env.CTXCE_LSP_SECRET || "" };
+  const now = Date.now();
+  if (_lspConnCache !== undefined && (now - _lspConnCacheTs) < LSP_CONN_CACHE_TTL) return _lspConnCache;
+
+  function _cacheNull() {
+    _lspConnCache = null;
+    _lspConnCacheTs = now;
+    return null;
+  }
+
+  try {
+    const connPath = path.join(os.homedir(), ".ctxce", "lsp-connection.json");
+    const conn = JSON.parse(fs.readFileSync(connPath, "utf8"));
+    if (conn.port && _isValidPort(conn.port) && conn.pid) {
+      try { process.kill(conn.pid, 0); } catch (_) { return _cacheNull(); }
+      if (conn.created_at && (now - conn.created_at) > LSP_CONN_MAX_AGE) return _cacheNull();
+      _lspConnCache = { port: String(conn.port), secret: conn.secret || "" };
+      _lspConnCacheTs = now;
+      return _lspConnCache;
+    }
+  } catch (_) {}
+  return _cacheNull();
+}
+
+const _LSP_ENRICHABLE_TOOLS = new Set([
+  "batch_search", "batch_symbol_graph", "batch_graph_query",
+  "repo_search", "repo_search_compat", "symbol_graph", "search",
+  "code_search", "context_search", "search_tests_for",
+  "search_config_for", "search_callers_for", "search_importers_for",
+]);
+
+function _extractPaths(obj, paths, depth = 0) {
+  if (!obj || typeof obj !== "object" || depth > 20) return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) _extractPaths(item, paths, depth + 1);
+    return;
+  }
+  if (typeof obj.path === "string" && (obj.path.startsWith("/") || /^[a-zA-Z]:[/\\]/.test(obj.path))) paths.add(obj.path);
+  for (const [key, val] of Object.entries(obj)) {
+    if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+    if (val && typeof val === "object") _extractPaths(val, paths, depth + 1);
+  }
+}
+
+function _callLspHandler(port, secret, operation, params) {
+  const postData = JSON.stringify(params);
+  return new Promise((resolve) => {
+    const req = http.request({
+      hostname: "127.0.0.1",
+      port: parseInt(port, 10),
+      path: `/lsp/${operation}`,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(postData),
+        ...(secret ? { "x-lsp-handler-token": secret } : {}),
+      },
+      timeout: 3000,
+    }, (res) => {
+      let data = "";
+      let exceeded = false;
+      const MAX_RESP = 5 * 1024 * 1024;
+      res.on("data", chunk => {
+        if (exceeded) return;
+        data += chunk;
+        if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve(null); }
+      });
+      res.on("end", () => { if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve(null); } } });
+    });
+    req.on("error", () => resolve(null));
+    req.on("timeout", () => { req.destroy(); resolve(null); });
+    req.write(postData);
+    req.end();
+  });
+}
+
+async function _enrichWithLsp(result, lspConn) {
+  try {
+    if (!Array.isArray(result?.content)) return result;
+    const textBlock = result.content.find(c => c.type === "text");
+    if (!textBlock?.text) return result;
+    let parsed;
+    try { parsed = JSON.parse(textBlock.text); } catch { return result; }
+    if (!parsed.ok) return result;
+    const paths = new Set();
+    _extractPaths(parsed, paths);
+    if (paths.size === 0) return result;
+    const diag = await _callLspHandler(lspConn.port, lspConn.secret, "diagnostics_recent", { paths: [...paths] });
+    if (!diag?.ok || !diag.files || diag.total === 0) return result;
+    parsed._lsp = { diagnostics: diag.files, total: diag.total };
+    textBlock.text = JSON.stringify(parsed);
+    return result;
+  } catch (err) {
+    debugLog("[ctxce] LSP enrichment failed: " + String(err));
+    return result;
+  }
+}
+
 function debugLog(message) {
   try {
     const text = typeof message === "string" ? message : String(message);
@@ -97,6 +208,9 @@ function selectClientForTool(name, indexerClient, memoryClient) {
   if (memoryClient && lowered.startsWith("memory")) {
     return memoryClient;
   }
+  if (lowered.startsWith("lsp_")) {
+    return null;
+  }
   return indexerClient;
 }
 
@@ -796,6 +910,90 @@ async function createBridgeServer(options) {
     const indexerTools = Array.isArray(remote?.tools) ? remote.tools.slice() : [];
     const memoryTools = await listMemoryTools(memoryClient);
     const tools = dedupeTools([...indexerTools, ...memoryTools]);
+
+    const lspAvailable = !!_readLspConnection();
+    if (lspAvailable) {
+      const lspProp = {
+        type: "boolean",
+        description: "When true, auto-enrich results with live LSP diagnostics (errors/warnings) for files in the response. Zero extra tool calls needed.",
+      };
+      for (const tool of tools) {
+        if (_LSP_ENRICHABLE_TOOLS.has(tool.name) && tool.inputSchema?.properties) {
+          tool.inputSchema = { ...tool.inputSchema, properties: { ...tool.inputSchema.properties, include_lsp: lspProp } };
+        }
+      }
+
+      const pathProp = { type: "string", description: "Absolute file path" };
+      const lineProp = { type: "integer", description: "0-based line" };
+      const charProp = { type: "integer", description: "0-based column" };
+      const positionProps = { path: pathProp, line: lineProp, character: charProp };
+      const positionRequired = ["path", "line", "character"];
+
+      tools.push(
+        {
+          name: "lsp_diagnostics",
+          description: "Get compiler diagnostics (errors, warnings) for a file from the active language server.",
+          inputSchema: { type: "object", properties: { path: pathProp }, required: ["path"] },
+        },
+        {
+          name: "lsp_definition",
+          description: "Go to definition of symbol at position.",
+          inputSchema: { type: "object", properties: { ...positionProps }, required: positionRequired },
+        },
+        {
+          name: "lsp_references",
+          description: "Find all references to symbol at position.",
+          inputSchema: {
+            type: "object",
+            properties: { ...positionProps, includeDeclaration: { type: "boolean", description: "Include the declaration itself" } },
+            required: positionRequired,
+          },
+        },
+        {
+          name: "lsp_hover",
+          description: "Get hover information (type, docs) for symbol at position.",
+          inputSchema: { type: "object", properties: { ...positionProps }, required: positionRequired },
+        },
+        {
+          name: "lsp_document_symbols",
+          description: "Get all symbols in a document.",
+          inputSchema: { type: "object", properties: { path: pathProp }, required: ["path"] },
+        },
+        {
+          name: "lsp_workspace_symbols",
+          description: "Search for symbols across the workspace.",
+          inputSchema: { type: "object", properties: { query: { type: "string", description: "Symbol search query" } }, required: ["query"] },
+        },
+        {
+          name: "lsp_code_actions",
+          description: "Get available code actions (quick fixes, refactors) for a range.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              path: pathProp,
+              startLine: { type: "integer" },
+              startChar: { type: "integer" },
+              endLine: { type: "integer" },
+              endChar: { type: "integer" },
+            },
+            required: ["path", "startLine", "startChar", "endLine", "endChar"],
+          },
+        },
+        {
+          name: "lsp_diagnostics_recent",
+          description: "Get recently collected diagnostics from file edits (errors and warnings auto-collected via language server).",
+          inputSchema: {
+            type: "object",
+            properties: {
+              paths: { type: "array", items: { type: "string" }, description: "Filter to specific file paths" },
+              severity_filter: { type: "string", enum: ["error", "warning", "info", "hint"], description: "Filter by severity" },
+              since_ms: { type: "integer", description: "Only return diagnostics newer than this Unix timestamp in ms" },
+            },
+          },
+        },
+      );
+    }
+
     debugLog(`[ctxce] tools/list: returning ${tools.length} tools`);
     return { tools };
   });
@@ -806,6 +1004,13 @@ async function createBridgeServer(options) {
     const name = params.name;
     let args = params.arguments;
 
+    let includeLsp = false;
+    if (args && typeof args === "object" && args.include_lsp === true && _LSP_ENRICHABLE_TOOLS.has(name)) {
+      includeLsp = true;
+      const { include_lsp: _stripped, ...rest } = args;
+      args = rest;
+    }
+
     debugLog(`[ctxce] tools/call: ${name || "<no-name>"}`);
 
     // Refresh session before each call; re-init clients if session changes.
@@ -846,6 +1051,55 @@ async function createBridgeServer(options) {
       return indexerResult;
     }
 
+    if (name && name.toLowerCase().startsWith("lsp_")) {
+      const lspConn = _readLspConnection();
+      const lspPort = lspConn ? lspConn.port : null;
+      const lspSecret = lspConn ? lspConn.secret : "";
+      if (!lspPort) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "LSP proxy not available. Ensure VS Code extension has lsp.enabled=true." }) }] };
+      }
+      const ALLOWED_LSP_OPS = new Set(['diagnostics','definition','references','hover','document_symbols','workspace_symbols','code_actions','diagnostics_recent']);
+      const operation = name.toLowerCase().replace(/^lsp_/, "");
+      if (!ALLOWED_LSP_OPS.has(operation)) {
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: "Unknown LSP operation" }) }] };
+      }
+      try {
+        const lspArgs = params.arguments || {};
+        const postData = JSON.stringify(lspArgs);
+        const result = await new Promise((resolve, reject) => {
+          const req = http.request({
+            hostname: "127.0.0.1",
+            port: parseInt(lspPort, 10),
+            path: `/lsp/${operation}`,
+            method: "POST",
+            headers: Object.assign({ "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }, lspSecret ? { "x-lsp-handler-token": lspSecret } : {}),
+            timeout: 15000,
+          }, (res) => {
+            let data = "";
+            let exceeded = false;
+            const MAX_RESP = 5 * 1024 * 1024;
+            res.on("data", chunk => {
+              if (exceeded) return;
+              data += chunk;
+              if (data.length > MAX_RESP) { exceeded = true; req.destroy(); resolve({ ok: false, error: "Response too large" }); }
+            });
+            res.on("end", () => {
+              if (!exceeded) { try { resolve(JSON.parse(data)); } catch { resolve({ ok: false, error: "Invalid response from LSP handler" }); } }
+            });
+          });
+          req.on("error", reject);
+          req.on("timeout", () => { req.destroy(); reject(new Error("LSP request timeout")); });
+          req.write(postData);
+          req.end();
+        });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (err) {
+        debugLog("[ctxce] LSP proxy error: " + String(err));
+        const safeMsg = (err && err.code) ? `LSP proxy error: ${err.code}` : "LSP proxy error: request failed";
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: safeMsg }) }] };
+      }
+    }
+
     await initializeRemoteClients(false);
 
     const timeoutMs = getBridgeToolTimeoutMs();
@@ -862,7 +1116,7 @@ async function createBridgeServer(options) {
 
       const targetClient = selectClientForTool(name, indexerClient, memoryClient);
       if (!targetClient) {
-        throw new Error(`Tool ${name} not available on any configured MCP server`);
+        return { content: [{ type: "text", text: JSON.stringify({ ok: false, error: `Tool ${name} not available on any configured MCP server` }) }] };
       }
 
       try {
@@ -874,7 +1128,10 @@ async function createBridgeServer(options) {
           undefined,
           { timeout: timeoutMs },
         );
-        return maybeRemapToolResult(name, result, workspace);
+        let finalResult = maybeRemapToolResult(name, result, workspace);
+        const lspConn = includeLsp && _readLspConnection();
+        if (lspConn) finalResult = await _enrichWithLsp(finalResult, lspConn);
+        return finalResult;
       } catch (err) {
         lastError = err;
 

package/.omc/state/hud-state.json

@@ -1,6 +0,0 @@
-{
-  "timestamp": "2026-02-20T02:56:43.457Z",
-  "backgroundTasks": [],
-  "sessionStartTimestamp": "2026-02-20T02:54:38.180Z",
-  "sessionId": "391fa45d902019af"
-}

package/.sisyphus/ultrawork-state.json

@@ -1,7 +0,0 @@
-{
-  "active": true,
-  "started_at": "2026-01-25T14:25:53.146Z",
-  "original_prompt": "/oh-my-claude-sisyphus:ultrawork we need to figure out, research context engine a bit.... how to make our agent tools better via mcp... (the claude.example.md is\n  clear) but maybe we need an agents.md, we have claude skills... can we make the descriptors better? research alot fo other\n  tools and see",
-  "reinforcement_count": 5,
-  "last_checked_at": "2026-01-25T14:43:28.449Z"
-}

package/AGENTS.md

@@ -1,69 +0,0 @@
-<!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
-
-# ctx-mcp-bridge
-
-## Purpose
-
-The MCP bridge (`ctxce` CLI) is a Model Context Protocol server that aggregates the Context Engine indexer and memory servers into a single unified MCP server. It supports both stdio and HTTP transport modes, making it compatible with MCP clients like Claude Code, Windsurf, Augment, and others. The bridge is primarily launched by the VS Code extension but can run standalone.
-
-## Key Files
-
-| File | Description |
-|------|-------------|
-| `bin/ctxce.js` | CLI entry point and executable (chmod +x 755) |
-| `src/cli.js` | Command routing and argument parsing for `mcp-serve`, `mcp-http-serve`, `auth`, `connect` |
-| `src/mcpServer.js` | MCP server implementation with stdio/HTTP transport, tool deduping, and auth handling |
-| `src/authCli.js` | Auth command handlers: `login`, `logout`, `status` with token and password flows |
-| `src/authConfig.js` | Session storage and management in `~/.ctxce/auth.json` |
-| `src/oauthHandler.js` | OAuth protocol support for remote deployments |
-| `src/uploader.js` | Standalone code uploader integration |
-| `src/connectCli.js` | Connection validation and setup helpers |
-| `src/resultPathMapping.js` | Path remapping for tool results (container/host paths) |
-| `package.json` | Node.js package manifest (requires Node >= 18) |
-
-## Subdirectories
-
-| Directory | Purpose |
-|-----------|---------|
-| `bin/` | Executable CLI entry point |
-| `docs/` | Debugging guides and documentation |
-| `src/` | Core MCP server and auth logic (see `src/AGENTS.md`) |
-
-## For AI Agents
-
-### Working In This Directory
-
-This is a Node.js MCP bridge package. Changes to MCP routing, tool forwarding, or auth handling require updates to `src/cli.js` and `src/mcpServer.js`. The bridge proxies requests between MCP clients and remote indexer/memory HTTP servers, so test both stdio and HTTP modes.
-
-### Testing Requirements
-
-- Run with `npm start` or `node bin/ctxce.js --help`
-- Test MCP stdio mode: `ctxce mcp-serve --workspace /tmp/test`
-- Test MCP HTTP mode: `ctxce mcp-http-serve --workspace /tmp/test --port 30810`
-- Test auth commands: `ctxce auth login --backend-url http://localhost:8004 --token TEST_TOKEN`
-- Verify auth state: `ctxce auth status --backend-url http://localhost:8004 --json`
-- E2E tests: `npm run test:e2e`
-
-### Common Patterns
-
-- Environment variables: `CTXCE_INDEXER_URL`, `CTXCE_MEMORY_URL`, `CTXCE_HTTP_PORT`, `CTXCE_AUTH_*`
-- Auth sessions stored in `~/.ctxce/auth.json` keyed by backend URL
-- MCP tools are deduplicated and forwarded from indexer and memory servers
-- Path remapping (host paths <-> container paths) handled transparently
-- All MCP requests are logged to stderr or `CTXCE_DEBUG_LOG` if set
-
-## Dependencies
-
-### Internal
-- Context Engine indexer (HTTP endpoint at `CTXCE_INDEXER_URL` or `http://localhost:8003/mcp`)
-- Context Engine memory server (HTTP endpoint at `CTXCE_MEMORY_URL` or `http://localhost:8002/mcp`)
-- Auth backend (optional, at `CTXCE_AUTH_BACKEND_URL` or `http://localhost:8004`)
-
-### External
-- `@modelcontextprotocol/sdk` (^1.24.3) – MCP protocol implementation
-- `zod` (^3.25.0) – Runtime type validation
-- `tar` (^7.5.9) – Archive support for uploads
-- `ignore` (^7.0.5) – .gitignore-style file filtering
-
-<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/bin/AGENTS.md

@@ -1,34 +0,0 @@
-<!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
-
-# bin
-
-## Purpose
-
-Executable CLI entry point for the `ctxce` command (also aliased as `ctxce-bridge`). This directory contains the shebang-wrapped Node.js script that is installed globally or via npm when the package is installed.
-
-## Key Files
-
-| File | Description |
-|------|-------------|
-| `ctxce.js` | CLI executable entry point (Node.js script, chmod +x 755) |
-
-## For AI Agents
-
-### Working In This Directory
-
-Do not modify `ctxce.js` directly unless changing the CLI bootstrap. The actual CLI logic is in `src/cli.js`. The executable must have a shebang (`#!/usr/bin/env node`) and be marked executable on Unix systems.
-
-### Testing Requirements
-
-- Verify executable permission: `ls -l bin/ctxce.js` should show `-rwxr-xr-x`
-- Test global install: `npm install -g` and run `ctxce --help`
-- Test npx mode: `npx @context-engine-bridge/context-engine-mcp-bridge ctxce --help`
-- Postinstall script auto-fixes permissions on non-Windows systems
-
-## Dependencies
-
-### Internal
-- `src/cli.js` – Main CLI router and handler
-
-<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/docs/AGENTS.md

@@ -1,22 +0,0 @@
-<!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
-
-# docs
-
-## Purpose
-
-Debugging guides and developer documentation for the MCP bridge. Currently contains minimal documentation; most usage is covered in the main `README.md`.
-
-## Key Files
-
-| File | Description |
-|------|-------------|
-| `debugging.md` | Debug logging and troubleshooting tips |
-
-## For AI Agents
-
-### Working In This Directory
-
-This directory is for developer guides, not API documentation (which belongs in the main README). When adding debugging tips or advanced usage patterns, place them here.
-
-<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->

package/docs/debugging.md

@@ -1,20 +0,0 @@
-{
-  "mcpServers": {
-    "context-engine": {
-      "command": "node",
-      "args": [
-        "C:/Users/Admin/Documents/GitHub/Context-Engine/ctx-mcp-bridge/bin/ctxce.js",
-        "mcp-serve",
-        "--indexer-url",
-        "http://192.168.100.249:30806/mcp",
-        "--memory-url",
-        "http://192.168.100.249:30804/mcp",
-        "--workspace",
-        "C:/Users/Admin/Documents/GitHub/Pirate Survivors"
-      ],
-      "env": {
-        "CTXCE_DEBUG_LOG": "C:/Users/Admin/ctxce-mcp.log"
-      }
-    }
-  }
-}

package/publish.sh

@@ -1,34 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-# Simple helper to login (if needed) and publish the package.
-# Usage:
-#   ./publish.sh            # publishes current version
-#   ./publish.sh 0.0.2      # bumps version to 0.0.2 then publishes
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$SCRIPT_DIR"
-
-PACKAGE_NAME="@context-engine-bridge/context-engine-mcp-bridge"
-
-echo "[publish] Verifying npm authentication..."
-if ! npm whoami >/dev/null 2>&1; then
-  echo "[publish] Not logged in; running npm login"
-  npm login
-else
-  echo "[publish] Already authenticated as $(npm whoami)"
-fi
-
-if [[ $# -gt 0 ]]; then
-  VERSION="$1"
-  echo "[publish] Bumping version to $VERSION"
-  npm version "$VERSION" --no-git-tag-version
-fi
-
-echo "[publish] Packing $PACKAGE_NAME for verification..."
-npm pack >/dev/null
-
-echo "[publish] Publishing $PACKAGE_NAME..."
-npm publish --access public
-
-echo "[publish] Done!"

package/src/AGENTS.md

@@ -1,59 +0,0 @@
-<!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-02-19 | Updated: 2026-02-19 -->
-
-# src
-
-## Purpose
-
-Core MCP server implementation, auth handling, and CLI routing for the `ctxce` bridge. This module aggregates the Context Engine indexer and memory servers, manages authentication sessions, and handles both stdio and HTTP transport modes.
-
-## Key Files
-
-| File | Description |
-|------|-------------|
-| `cli.js` | Main command router for `mcp-serve`, `mcp-http-serve`, `auth`, `connect` subcommands; parses CLI flags and environment variables |
-| `mcpServer.js` | MCP server implementation; proxies requests to indexer/memory servers, dedupes tools, handles auth, supports stdio and HTTP transports |
-| `authCli.js` | Auth command handlers for `login`, `logout`, `status` with token and password flows; manages session lifecycle |
-| `authConfig.js` | Persistent auth state in `~/.ctxce/auth.json`; session loading, saving, TTL handling, OAuth support |
-| `oauthHandler.js` | OAuth protocol implementation for token refresh and remote auth flows |
-| `uploader.js` | Integration with the standalone code uploader (tar archive support, progress tracking) |
-| `connectCli.js` | Connection validation, workspace discovery, and setup helpers |
-| `resultPathMapping.js` | Path remapping for tool results (host paths <-> container paths); handles path translation for Docker environments |
-
-## For AI Agents
-
-### Working In This Directory
-
-This is the core business logic. Changes to MCP command handling, tool routing, or auth flows affect both the CLI and the VS Code extension. The server proxies all tool requests to remote indexer/memory servers and dedupes tool lists to prevent duplicates. Auth is optional but handles session TTL, token refresh, and fallback to dev tokens.
-
-### Testing Requirements
-
-- Test MCP stdio transport: `node src/cli.js mcp-serve --workspace /tmp/test`
-- Test MCP HTTP transport: `node src/cli.js mcp-http-serve --workspace /tmp/test --port 30810`
-- Test auth login: `node src/cli.js auth login --backend-url http://localhost:8004 --token TOKEN`
-- Test auth status: `node src/cli.js auth status --backend-url http://localhost:8004 --json`
-- Verify tool deduping: Check that tools from indexer and memory are merged without duplicates
-- Test path remapping: Verify that container paths are correctly mapped for Docker environments
-- Run E2E tests: `npm run test:e2e`, `npm run test:e2e:auth`, `npm run test:e2e:happy`, `npm run test:e2e:edge`
-
-### Common Patterns
-
-- Environment variables guide server initialization: `CTXCE_INDEXER_URL`, `CTXCE_MEMORY_URL`, `CTXCE_HTTP_PORT`, `CTXCE_AUTH_BACKEND_URL`, `CTXCE_AUTH_ENABLED`, `CTXCE_DEBUG_LOG`
-- Sessions are stored per backend URL in `~/.ctxce/auth.json` with TTL tracking
-- All MCP tools from indexer and memory are merged and deduplicated before listing
-- Path remapping is applied to tool arguments and results for Docker host/container path translation
-- Debug logging goes to stderr and optionally to a file (set `CTXCE_DEBUG_LOG` env var)
-- HTTP transport uses Node.js `createServer` with MCP's `StreamableHTTPServerTransport`
-
-## Dependencies
-
-### Internal
-- `bin/ctxce.js` – CLI entry point that imports and runs these modules
-
-### External
-- `@modelcontextprotocol/sdk` – MCP protocol (Server, StdioServerTransport, StreamableHTTPServerTransport, Client, StreamableHTTPClientTransport)
-- `zod` – Runtime type validation (used in config parsing)
-- `tar` – Archive handling for uploader
-- `ignore` – File filtering for .gitignore patterns
-
-<!-- MANUAL: Any manually added notes below this line are preserved on regeneration -->