@minhpnq1807/contextos 0.5.42 → 0.5.45

package/plugins/ctx/lib/file-embedding-retriever.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { enhanceRuleScoresWithEmbeddings, isModelCacheReady, warmRuleEmbeddings } from "./embedding-scorer.js";
+import { isModelCacheReady, searchIndexedEmbeddings, warmIndexedEmbeddings } from "./embedding-scorer.js";
+import { rebuildImportGraphIndex } from "./import-graph.js";
 
 const SOURCE_EXTENSIONS = new Set([
   ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".sql", ".md", ".json"
@@ -8,7 +9,7 @@ const SOURCE_EXTENSIONS = new Set([
 const IGNORE_DIRS = new Set([
   ".git", ".next", ".turbo", "coverage", "dist", "build", "node_modules", "vendor"
 ]);
-const DEFAULT_TIMEOUT_MS = 80;
+const DEFAULT_TIMEOUT_MS = 1000;
 const DEFAULT_MAX_FILES = 1200;
 
 export async function findEmbeddingRelevantFiles({
@@ -18,27 +19,17 @@ export async function findEmbeddingRelevantFiles({
   limit = 10,
   timeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
   maxFiles = Number(process.env.CONTEXTOS_FILE_EMBEDDING_MAX_FILES || DEFAULT_MAX_FILES),
-  embeddingOptions = {}
+  embeddingOptions = {},
+  indexedSearcher = searchIndexedEmbeddings
 } = {}) {
   if (process.env.CONTEXTOS_FILE_EMBEDDINGS === "0") return [];
   if (!dataDir) return [];
   if (!String(task || "").trim()) return [];
 
-  const files = listSourceFiles(cwd, { maxFiles });
-  if (!files.length) return [];
-
-  const fileRules = files.map((filePath, index) => ({
-    id: `f${index + 1}`,
-    content: fileSearchText(filePath),
-    path: filePath,
-    score: 0,
-    reasons: [],
-    originalOrder: index
-  }));
-
-  const result = await enhanceRuleScoresWithEmbeddings(fileRules, task, {
+  const result = await indexedSearcher({
+    kind: fileIndexKind(cwd),
+    task,
     dataDir,
-    sources: [path.join(cwd, "AGENTS.md")],
     timeoutMs,
     allowRemote: false,
     ...embeddingOptions
@@ -46,12 +37,12 @@ export async function findEmbeddingRelevantFiles({
 
   if (result.status !== "enabled") return [];
 
-  return result.rules
+  return result.items
     .filter((rule) => Number(rule.embeddingScore || 0) >= 0.45)
-    .sort((a, b) => Number(b.embeddingScore || 0) - Number(a.embeddingScore || 0) || a.path.localeCompare(b.path))
+    .sort((a, b) => Number(b.embeddingScore || 0) - Number(a.embeddingScore || 0) || a.id.localeCompare(b.id))
     .slice(0, limit)
     .map((rule) => ({
-      path: rule.path,
+      path: rule.id,
       score: Math.round(Number(rule.embeddingScore || 0) * 10),
       source: "embedding",
       reasons: [`file-embedding:${Number(rule.embeddingScore || 0).toFixed(2)}`]
@@ -67,9 +58,11 @@ export async function warmFileEmbeddings({
   if (!dataDir) return { count: 0, cachePath: null };
   if (!allowRemote && !isModelCacheReady(dataDir)) return { count: 0, cachePath: null, status: "missing-model" };
   const files = listSourceFiles(cwd, { maxFiles });
-  const rules = files.map((filePath) => ({ content: fileSearchText(filePath) }));
-  return warmRuleEmbeddings({
-    rules,
+  rebuildImportGraphIndex({ cwd, files, dataDir });
+  const items = files.map((filePath) => ({ id: filePath, text: fileSearchText(filePath) }));
+  return warmIndexedEmbeddings({
+    kind: fileIndexKind(cwd),
+    items,
     task: "project file semantic retrieval",
     dataDir,
     sources: [path.join(cwd, "AGENTS.md")],
@@ -77,6 +70,10 @@ export async function warmFileEmbeddings({
   });
 }
 
+function fileIndexKind(cwd) {
+  return `file:${path.resolve(cwd)}`;
+}
+
 function listSourceFiles(cwd, { maxFiles }) {
   const files = [];
   walkFiles(cwd, (filePath) => {

package/plugins/ctx/lib/global-hooks.js

@@ -4,6 +4,8 @@ import path from "node:path";
 const CONTEXTOS_COMMAND_MARKER = "/contextos/plugins/ctx/bin/on-";
 const QUIET_CODE_REVIEW_GRAPH_STATUS_COMMAND =
   "git rev-parse --git-dir >/dev/null 2>&1 && code-review-graph status >/dev/null 2>&1 || true";
+const DRAINED_CODE_REVIEW_GRAPH_UPDATE_COMMAND =
+  "cat >/dev/null; git rev-parse --git-dir >/dev/null 2>&1 && code-review-graph update --skip-flows || true";
 
 function shellQuote(value) {
   const s = String(value);
@@ -52,6 +54,23 @@ function quietCodeReviewGraphSessionStart(entries = []) {
   }));
 }
 
+function drainCodeReviewGraphPostToolUse(entries = []) {
+  return entries.map((entry) => ({
+    ...entry,
+    hooks: (entry.hooks || []).map((hook) => {
+      if (typeof hook.command === "string" && hook.command.includes("code-review-graph update --skip-flows")) {
+        return {
+          ...hook,
+          command: hook.command.includes("cat >/dev/null")
+            ? hook.command
+            : DRAINED_CODE_REVIEW_GRAPH_UPDATE_COMMAND
+        };
+      }
+      return hook;
+    })
+  }));
+}
+
 function commandFor(marketplaceRoot, scriptName, { injectPromptContext = true } = {}) {
   const envPrefix = scriptName === "on-prompt.js" && !injectPromptContext ? "CONTEXTOS_INJECT=0 " : "";
   return `${envPrefix}node ${shellQuote(path.join(marketplaceRoot, "plugins", "ctx", "bin", scriptName))}`;
@@ -105,6 +124,7 @@ export function buildGlobalHooksConfig(existingConfig, { marketplaceRoot, inject
   }
 
   config.hooks.SessionStart = quietCodeReviewGraphSessionStart(config.hooks.SessionStart);
+  config.hooks.PostToolUse = drainCodeReviewGraphPostToolUse(config.hooks.PostToolUse);
 
   return config;
 }

package/plugins/ctx/lib/graph-retriever.js

@@ -3,6 +3,9 @@ import os from "node:os";
 import path from "node:path";
 import { execFileSync } from "node:child_process";
 
+import { appendTelemetry } from "./telemetry.js";
+import { workspaceDataDir } from "./workspace-data.js";
+
 const DEFAULT_TIMEOUT_MS = 80;
 const MAX_GRAPH_QUERIES = 10;
 const DEFAULT_CRG_PYTHON = path.join(
@@ -25,17 +28,47 @@ export function findGraphRelevantFiles({
   rules = [],
   seedFiles = [],
   limit = 6,
-  timeoutMs = Number(process.env.CONTEXTOS_GRAPH_TIMEOUT_MS || DEFAULT_TIMEOUT_MS)
+  timeoutMs = Number(process.env.CONTEXTOS_GRAPH_TIMEOUT_MS || DEFAULT_TIMEOUT_MS),
+  python = process.env.CONTEXTOS_CRG_PYTHON || DEFAULT_CRG_PYTHON,
+  telemetryPath,
+  graphSearch = runCodeReviewGraphSearch,
+  appendTelemetryEvent = appendTelemetry
 } = {}) {
   if (process.env.CONTEXTOS_GRAPH_RETRIEVAL === "0") return [];
   if (!hasGraphIndex(cwd)) return [];
 
-  const python = process.env.CONTEXTOS_CRG_PYTHON || DEFAULT_CRG_PYTHON;
   if (!fs.existsSync(python)) return [];
 
   const queries = buildGraphQueries({ task, rules, seedFiles });
   if (!queries.length) return [];
 
+  try {
+    const raw = graphSearch({ cwd, python, queries, limit, timeoutMs });
+    const files = mergeGraphResults({ cwd, results: raw, limit });
+    recordGraphRetrievalTelemetry({
+      cwd,
+      telemetryPath,
+      appendTelemetryEvent,
+      queryCount: queries.length,
+      resultCount: files.length,
+      status: "ok"
+    });
+    return files;
+  } catch (error) {
+    recordGraphRetrievalTelemetry({
+      cwd,
+      telemetryPath,
+      appendTelemetryEvent,
+      queryCount: queries.length,
+      resultCount: 0,
+      status: "error",
+      error
+    });
+    return [];
+  }
+}
+
+export function runCodeReviewGraphSearch({ cwd, python, queries, limit, timeoutMs }) {
   const script = `
 import json
 import sys
@@ -79,22 +112,56 @@ for query in queries:
 print(json.dumps(results))
 `;
 
+  const output = execFileSync(python, ["-c", script], {
+    cwd,
+    input: JSON.stringify({ repoRoot: cwd, queries, limit }),
+    encoding: "utf8",
+    timeout: timeoutMs,
+    env: {
+      ...process.env,
+      MPLCONFIGDIR: process.env.MPLCONFIGDIR || path.join(os.tmpdir(), "contextos-mpl")
+    },
+    stdio: ["pipe", "pipe", "ignore"]
+  });
+  return JSON.parse(output || "[]");
+}
+
+export function recordGraphRetrievalTelemetry({
+  cwd,
+  telemetryPath,
+  appendTelemetryEvent = appendTelemetry,
+  queryCount = 0,
+  resultCount = 0,
+  status,
+  error
+}) {
   try {
-    const output = execFileSync(python, ["-c", script], {
-      cwd,
-      input: JSON.stringify({ repoRoot: cwd, queries, limit }),
-      encoding: "utf8",
-      timeout: timeoutMs,
-      env: {
-        ...process.env,
-        MPLCONFIGDIR: process.env.MPLCONFIGDIR || path.join(os.tmpdir(), "contextos-mpl")
+    appendTelemetryEvent({
+      telemetryPath: telemetryPath || path.join(workspaceDataDir({ cwd }), "telemetry.jsonl"),
+      event: "InternalGraphRetrieval",
+      payload: {
+        cwd,
+        source: "graph-retriever",
+        method: "internal",
+        ...(status === "ok"
+          ? {
+            mcp: "code-review-graph",
+            toolName: "code-review-graph.semantic_search_nodes"
+          }
+          : {})
       },
-      stdio: ["pipe", "pipe", "ignore"]
+      extra: {
+        source: "graph-retriever",
+        backend: "code-review-graph",
+        method: "internal",
+        status,
+        queryCount,
+        resultCount,
+        ...(error ? { error: String(error.message || error).slice(0, 200) } : {})
+      }
     });
-    const raw = JSON.parse(output || "[]");
-    return mergeGraphResults({ cwd, results: raw, limit });
   } catch {
-    return [];
+    // Graph retrieval must remain fail-open when telemetry storage is unavailable.
   }
 }
 
@@ -165,7 +232,7 @@ function mergeGraphResults({ cwd, results, limit }) {
       source: "graph",
       reasons: []
     };
-    existing.score += 1;
+    existing.score += 1 + Number(result.score || 0);
     existing.reasons.push(`graph:${result.query}`);
     byPath.set(normalized, existing);
   }

package/plugins/ctx/lib/graph-strategy.js

@@ -0,0 +1,107 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const DEFAULT_CRG_PYTHON = path.join(
+  os.homedir(),
+  ".local/share/pipx/venvs/code-review-graph/bin/python"
+);
+
+export function detectGraphStrategy({
+  cwd = process.cwd(),
+  pathEnv = process.env.PATH || "",
+  mcpServerNames = []
+} = {}) {
+  const serverNames = new Set(mcpServerNames);
+  const codeReviewGraph = fs.existsSync(path.join(cwd, ".code-review-graph", "graph.db"))
+    || hasExecutable("code-review-graph", pathEnv)
+    || serverNames.has("code-review-graph");
+  const codegraph = hasExecutable("codegraph", pathEnv)
+    || serverNames.has("codegraph");
+
+  const strategy = codeReviewGraph && codegraph
+    ? "hybrid-adapter-pending"
+    : codegraph
+      ? "codegraph-detected-adapter-pending"
+      : codeReviewGraph
+        ? "code-review-graph"
+        : "none";
+
+  return { strategy, codeReviewGraph, codegraph };
+}
+
+export function formatGraphStrategy(result) {
+  const detected = [
+    result.codeReviewGraph ? "code-review-graph" : null,
+    result.codegraph ? "codegraph" : null
+  ].filter(Boolean);
+  return `${result.strategy}${detected.length ? ` (${detected.join(", ")})` : ""}`;
+}
+
+export function embedCodeReviewGraph({
+  cwd = process.cwd(),
+  python = process.env.CONTEXTOS_CRG_PYTHON || DEFAULT_CRG_PYTHON,
+  run = execFileSync
+} = {}) {
+  if (!fs.existsSync(path.join(cwd, ".code-review-graph", "graph.db"))) {
+    return { status: "skipped", reason: "missing-graph-index" };
+  }
+  if (!fs.existsSync(python)) {
+    return { status: "skipped", reason: "missing-code-review-graph-python" };
+  }
+
+  const script = `
+import json
+
+from code_review_graph.tools.docs import embed_graph
+
+print(json.dumps(embed_graph(repo_root=${JSON.stringify(cwd)}, provider="local")))
+`;
+
+  try {
+    const output = run(python, ["-c", script], {
+      cwd,
+      encoding: "utf8",
+      timeout: Number(process.env.CONTEXTOS_CRG_EMBED_TIMEOUT_MS || 120_000),
+      env: {
+        ...process.env,
+        MPLCONFIGDIR: process.env.MPLCONFIGDIR || path.join(os.tmpdir(), "contextos-mpl")
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const response = JSON.parse(output || "{}");
+    return {
+      status: "embedded",
+      newlyEmbedded: Number(response.newly_embedded || 0),
+      totalEmbeddings: Number(response.total_embeddings || response.embeddings_count || 0)
+    };
+  } catch (error) {
+    return {
+      status: "skipped",
+      reason: "embed-failed",
+      error: String(error.stderr || error.message || error).trim().slice(0, 200)
+    };
+  }
+}
+
+export function formatCodeReviewGraphEmbedding(result) {
+  if (result.status === "embedded") {
+    return `${result.totalEmbeddings} nodes (${result.newlyEmbedded} new)`;
+  }
+  if (result.reason === "missing-graph-index") return "skipped (no .code-review-graph/graph.db)";
+  if (result.reason === "missing-code-review-graph-python") return "skipped (code-review-graph Python unavailable)";
+  return `skipped (${result.error || result.reason || "unavailable"})`;
+}
+
+function hasExecutable(command, pathEnv) {
+  return String(pathEnv || "").split(path.delimiter).some((directory) => {
+    if (!directory) return false;
+    try {
+      fs.accessSync(path.join(directory, command), fs.constants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  });
+}

package/plugins/ctx/lib/hook-io.js

@@ -12,7 +12,35 @@ export async function readStdinJson() {
 }
 
 export function writeJson(value) {
-  process.stdout.write(`${JSON.stringify(value)}\n`);
+  try {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+  } catch (error) {
+    if (error?.code !== "EPIPE") throw error;
+  }
+}
+
+export function exitAfterStdout(code = 0) {
+  if (process.stdout.writableNeedDrain) {
+    process.stdout.once("drain", () => process.exit(code));
+    return;
+  }
+  setImmediate(() => process.exit(code));
+}
+
+export function armHookDeadline(event, fallback, {
+  timeoutMs = Number(process.env.CONTEXTOS_HOOK_DEADLINE_MS || 8500)
+} = {}) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return { clear() {} };
+  const timer = setTimeout(() => {
+    logError(event, new Error(`${event} hook deadline exceeded after ${timeoutMs}ms`));
+    writeJson(fallback);
+    exitAfterStdout(0);
+  }, timeoutMs);
+  return {
+    clear() {
+      clearTimeout(timer);
+    }
+  };
 }
 
 export function resolveHookCwd(payload = {}) {

package/plugins/ctx/lib/import-graph.js

@@ -4,27 +4,14 @@ import path from "node:path";
 const JS_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"];
 const IMPORT_RE = /\bimport\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]|\brequire\(\s*['"]([^'"]+)['"]\s*\)/g;
 
-export function expandImportGraph({ cwd = process.cwd(), seedFiles = [], limit = 6 } = {}) {
+export function expandImportGraph({ cwd = process.cwd(), seedFiles = [], dataDir, limit = 6 } = {}) {
   const seeds = new Set(seedFiles.map((file) => normalizeRel(file.path)).filter(Boolean));
   if (!seeds.size) return [];
 
-  const files = [];
-  for (const root of importGraphRoots(cwd, [...seeds])) {
-    walkSourceFiles(root, (filePath) => files.push(path.relative(cwd, filePath)));
-  }
-  const fileSet = new Set(files);
-  const outgoing = new Map();
-  const incoming = new Map();
-
-  for (const rel of files) {
-    const imports = resolveImports({ cwd, rel, fileSet });
-    outgoing.set(rel, imports);
-    for (const target of imports) {
-      const importers = incoming.get(target) || new Set();
-      importers.add(rel);
-      incoming.set(target, importers);
-    }
-  }
+  const index = readImportGraphIndex({ cwd, dataDir });
+  if (!index) return [];
+  const outgoing = objectToMap(index.outgoing);
+  const incoming = objectToMap(index.incoming);
 
   const candidates = new Map();
   for (const seed of seeds) {
@@ -42,15 +29,27 @@ export function expandImportGraph({ cwd = process.cwd(), seedFiles = [], limit =
     .slice(0, limit);
 }
 
-function importGraphRoots(cwd, seedFiles) {
-  const roots = new Set();
-  for (const file of seedFiles) {
-    const parts = file.split(path.sep);
-    const rootParts = parts[0] === "services" && parts[1] ? parts.slice(0, 2) : parts.slice(0, 1);
-    const root = path.join(cwd, ...rootParts);
-    if (fs.existsSync(root)) roots.add(root);
+export function rebuildImportGraphIndex({ cwd = process.cwd(), files = [], dataDir } = {}) {
+  if (!dataDir) return { count: 0, path: null };
+  const normalizedFiles = [...new Set(files.map(normalizeRel).filter(Boolean))];
+  const fileSet = new Set(normalizedFiles);
+  const outgoing = {};
+  const incoming = {};
+
+  for (const rel of normalizedFiles) {
+    const imports = resolveImports({ cwd, rel, fileSet });
+    outgoing[rel] = imports;
+    for (const target of imports) {
+      incoming[target] = [...new Set([...(incoming[target] || []), rel])];
+    }
   }
-  return roots.size ? [...roots] : [cwd];
+
+  const indexPath = importGraphIndexPath(dataDir);
+  fs.mkdirSync(path.dirname(indexPath), { recursive: true });
+  const tmpPath = `${indexPath}.tmp-${process.pid}-${Date.now()}`;
+  fs.writeFileSync(tmpPath, `${JSON.stringify({ cwd: path.resolve(cwd), outgoing, incoming })}\n`, "utf8");
+  fs.renameSync(tmpPath, indexPath);
+  return { count: normalizedFiles.length, path: indexPath };
 }
 
 function addImportCandidate(candidates, filePath, reason, score) {
@@ -103,22 +102,20 @@ function normalizeRel(filePath) {
   return normalized;
 }
 
-function walkSourceFiles(directory, onFile, depth = 0) {
-  if (depth > 8) return;
-  let entries = [];
+function readImportGraphIndex({ cwd, dataDir }) {
+  if (!dataDir) return null;
   try {
-    entries = fs.readdirSync(directory, { withFileTypes: true });
+    const index = JSON.parse(fs.readFileSync(importGraphIndexPath(dataDir), "utf8"));
+    return index.cwd === path.resolve(cwd) ? index : null;
   } catch {
-    return;
+    return null;
   }
+}
 
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") || ["node_modules", "dist", "build", "coverage", ".next"].includes(entry.name)) continue;
-    const fullPath = path.join(directory, entry.name);
-    if (entry.isDirectory()) {
-      walkSourceFiles(fullPath, onFile, depth + 1);
-    } else if (entry.isFile() && JS_EXTENSIONS.includes(path.extname(entry.name))) {
-      onFile(fullPath);
-    }
-  }
+function importGraphIndexPath(dataDir) {
+  return path.join(dataDir, "import-graph.json");
+}
+
+function objectToMap(value = {}) {
+  return new Map(Object.entries(value));
 }

package/plugins/ctx/lib/mcp-proxy-install.js

@@ -1,6 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
 
+import { readMcpServersFromToml, updateMcpServerFields } from "./toml-config.js";
+
 const DEFAULT_EXCLUDES = new Set(["ctx-mcp"]);
 
 export function installMcpTelemetryProxies({ codexHome, marketplaceRoot, targets = null, excludes = DEFAULT_EXCLUDES } = {}) {
@@ -17,55 +19,46 @@ export function installMcpTelemetryProxies({ codexHome, marketplaceRoot, targets
 }
 
 export function rewriteMcpTelemetryProxies(toml, { proxyPath, targets = null, excludes = DEFAULT_EXCLUDES } = {}) {
-  const lines = String(toml || "").split(/\r?\n/);
-  const sections = findMcpServerSections(lines);
+  let content = String(toml || "");
+  const servers = readMcpServersFromToml(content);
   const wrapped = [];
   const skipped = [];
 
-  for (const section of sections.reverse()) {
-    const body = lines.slice(section.start + 1, section.end);
-    const command = findStringValue(body, "command");
-    const args = findArrayValue(body, "args") || [];
-    const shouldProxy = shouldProxyServer(section.name, { targets, excludes });
+  for (const server of servers) {
+    const { name, command, args } = server;
+    const shouldProxy = shouldProxyServer(name, { targets, excludes });
 
     if (command === "node" && args[0] === proxyPath && !shouldProxy) {
       const original = unwrapProxyArgs(args);
       if (original) {
-        const nextBody = replaceOrInsertServerField(
-          replaceOrInsertServerField(body, "command", tomlString(original.command)),
-          "args",
-          tomlArray(original.args)
-        );
-        lines.splice(section.start + 1, section.end - section.start - 1, ...nextBody);
-        skipped.push({ name: section.name, reason: "unwrapped-non-target" });
+        content = updateMcpServerFields(content, name, original);
+        skipped.push({ name, reason: "unwrapped-non-target" });
         continue;
       }
     }
 
     if (!shouldProxy) {
-      skipped.push({ name: section.name, reason: "not-targeted" });
+      skipped.push({ name, reason: "not-targeted" });
       continue;
     }
 
     if (!command) {
-      skipped.push({ name: section.name, reason: "missing-command" });
+      skipped.push({ name, reason: "missing-command" });
       continue;
     }
     if (command === "node" && args[0] === proxyPath) {
-      skipped.push({ name: section.name, reason: "already-wrapped" });
+      skipped.push({ name, reason: "already-wrapped" });
       continue;
     }
 
-    const nextBody = replaceOrInsertServerField(
-      replaceOrInsertServerField(body, "command", tomlString("node")),
-      "args",
-      tomlArray([proxyPath, "--name", section.name, "--", command, ...args])
-    );
-    lines.splice(section.start + 1, section.end - section.start - 1, ...nextBody);
-    wrapped.push({ name: section.name, command, args });
+    content = updateMcpServerFields(content, name, {
+      command: "node",
+      args: [proxyPath, "--name", name, "--", command, ...args]
+    });
+    wrapped.push({ name, command, args });
   }
 
-  return { content: lines.join("\n"), wrapped: wrapped.reverse(), skipped: skipped.reverse() };
+  return { content, wrapped, skipped };
 }
 
 function shouldProxyServer(name, { targets, excludes }) {
@@ -82,68 +75,3 @@ function unwrapProxyArgs(args) {
     args: args.slice(separator + 2)
   };
 }
-
-function findMcpServerSections(lines) {
-  const sections = [];
-  for (let index = 0; index < lines.length; index += 1) {
-    const match = lines[index].match(/^\[mcp_servers\.([^\].]+)\]\s*$/);
-    if (!match) continue;
-    let end = lines.length;
-    for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
-      if (/^\[/.test(lines[cursor])) {
-        end = cursor;
-        break;
-      }
-    }
-    sections.push({ name: unquoteTomlKey(match[1]), start: index, end });
-  }
-  return sections;
-}
-
-function replaceOrInsertServerField(body, key, value) {
-  const next = [...body];
-  const index = next.findIndex((line) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(line));
-  const line = `${key} = ${value}`;
-  if (index >= 0) next[index] = line;
-  else next.unshift(line);
-  return next;
-}
-
-function findStringValue(lines, key) {
-  const line = lines.find((item) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(item));
-  if (!line) return null;
-  const match = line.match(/=\s*"((?:\\.|[^"\\])*)"/);
-  return match ? unescapeTomlString(match[1]) : null;
-}
-
-function findArrayValue(lines, key) {
-  const line = lines.find((item) => new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(item));
-  if (!line) return null;
-  const arrayMatch = line.match(/=\s*\[(.*)\]\s*$/);
-  if (!arrayMatch) return null;
-  const values = [];
-  const pattern = /"((?:\\.|[^"\\])*)"/g;
-  let match;
-  while ((match = pattern.exec(arrayMatch[1]))) values.push(unescapeTomlString(match[1]));
-  return values;
-}
-
-function tomlArray(values) {
-  return `[${values.map(tomlString).join(", ")}]`;
-}
-
-function tomlString(value) {
-  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-
-function unescapeTomlString(value) {
-  return String(value).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-}
-
-function unquoteTomlKey(value) {
-  return value.replace(/^"|"$/g, "");
-}
-
-function escapeRegExp(value) {
-  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}