@minhpnq1807/contextos 0.5.42 → 0.5.44

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, "\\$&");
-}

package/plugins/ctx/lib/output-config.js

@@ -0,0 +1,85 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { writeJsonFile } from "./fs-utils.js";
+import { defaultDataRoot } from "./workspace-data.js";
+
+const CONFIG_FILE = "output-config.json";
+
+export const OUTPUT_SECTION_OPTIONS = [
+  { value: "rules", label: "Critical ContextOS rules", hint: "Include critical and additional relevant AGENTS.md rules." },
+  { value: "files", label: "Suggested files to check", hint: "Include semantic, import-graph, and code-review-graph file suggestions." },
+  { value: "skills", label: "Suggested skills for this task", hint: "Include matching local skill recommendations." },
+  { value: "workflows", label: "Suggested workflow for this task", hint: "Include matching workflow recommendations." }
+];
+
+export function defaultOutputConfig() {
+  return {
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [option.value, true]))
+  };
+}
+
+export function outputConfigPath(dataRoot = defaultDataRoot()) {
+  return path.join(dataRoot, CONFIG_FILE);
+}
+
+export function loadOutputConfig({ dataRoot = defaultDataRoot() } = {}) {
+  try {
+    return normalizeOutputConfig(JSON.parse(fs.readFileSync(outputConfigPath(dataRoot), "utf8")));
+  } catch {
+    return defaultOutputConfig();
+  }
+}
+
+export function saveOutputConfig(config, { dataRoot = defaultDataRoot() } = {}) {
+  const normalized = normalizeOutputConfig(config);
+  writeJsonFile(outputConfigPath(dataRoot), normalized);
+  return normalized;
+}
+
+export function enabledOutputSections(config = loadOutputConfig()) {
+  const normalized = normalizeOutputConfig(config);
+  return OUTPUT_SECTION_OPTIONS
+    .filter((option) => normalized.sections[option.value])
+    .map((option) => option.value);
+}
+
+export function enabledOutputSectionsLabel(config = loadOutputConfig()) {
+  const enabled = enabledOutputSections(config);
+  return enabled.length ? enabled.join(", ") : "(none)";
+}
+
+export async function configureOutputSections({
+  dataRoot = defaultDataRoot(),
+  select,
+  logger = console.log
+} = {}) {
+  if (typeof select !== "function") throw new Error("configureOutputSections requires a multi-select function");
+  const current = loadOutputConfig({ dataRoot });
+  const selected = await select({
+    message: "Select ContextOS prompt sections to show:",
+    options: OUTPUT_SECTION_OPTIONS.map((option) => ({
+      ...option,
+      selected: current.sections[option.value]
+    }))
+  });
+  const selectedSet = new Set(selected);
+  const saved = saveOutputConfig({
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [option.value, selectedSet.has(option.value)]))
+  }, { dataRoot });
+  logger(`│  Saved ContextOS prompt section config: ${outputConfigPath(dataRoot)}`);
+  logger(`│  Enabled sections: ${enabledOutputSectionsLabel(saved)}`);
+  return saved;
+}
+
+function normalizeOutputConfig(config = {}) {
+  const defaults = defaultOutputConfig();
+  return {
+    sections: Object.fromEntries(OUTPUT_SECTION_OPTIONS.map((option) => [
+      option.value,
+      typeof config.sections?.[option.value] === "boolean"
+        ? config.sections[option.value]
+        : defaults.sections[option.value]
+    ]))
+  };
+}

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

@@ -34,3 +34,11 @@ export function copyPackageRoot({ rootDir, targetRoot }) {
   }
   return targetRoot;
 }
+
+export function syncPackageRoot({ rootDir, targetRoot }) {
+  if (path.resolve(rootDir) === path.resolve(targetRoot)) {
+    return { targetRoot, synced: false };
+  }
+  copyPackageRoot({ rootDir, targetRoot });
+  return { targetRoot, synced: true };
+}