@minhpnq1807/contextos 0.5.42 → 0.5.44

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

@@ -1,7 +1,9 @@
 import { scheduleContext } from "./scheduler.js";
 import { appendJsonLine, writeJsonFile } from "./fs-utils.js";
+import { maybeAutoWarmWorkspace } from "./auto-warm.js";
 import { callCtxScoreContext } from "./ctx-mcp-client.js";
 import { resolveHookCwd } from "./hook-io.js";
+import { loadOutputConfig } from "./output-config.js";
 import { scoreContext as scoreContextDirect } from "./score-context.js";
 import path from "node:path";
 
@@ -14,7 +16,11 @@ export async function handlePromptPayload(
     started = Date.now(),
     injectContext = process.env.CONTEXTOS_INJECT !== "0",
     scoreContextClient = callCtxScoreContext,
-    mcpDataDir
+    scoreContextDirectClient = scoreContextDirect,
+    autoWarmWorkspace = maybeAutoWarmWorkspace,
+    mcpDataDir,
+    outputConfig,
+    directFallbackTimeoutMs = Number(process.env.CONTEXTOS_DIRECT_FALLBACK_TIMEOUT_MS || 6000)
   } = {}
 ) {
   const prompt = payload.prompt || payload.message || payload.user_prompt || "";
@@ -31,21 +37,31 @@ export async function handlePromptPayload(
       maxFiles: 3
     }, {
       dataDir: mcpDataDir || dataDir,
-      timeoutMs: Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || 1000)
+      timeoutMs: Number(process.env.CONTEXTOS_MCP_BRIDGE_TIMEOUT_MS || 2000)
     });
   } catch (error) {
-    scored = await scoreContextDirect({
-      cwd,
-      prompt,
-      openFiles,
-      maxFiles: 3,
-      dataDir: mcpDataDir || dataDir
-    });
-    scored.telemetry = {
-      ...(scored.telemetry || {}),
-      bridgeStatus: "fallback",
-      bridgeError: error?.message || String(error)
-    };
+    try {
+      scored = await withTimeout(scoreContextDirectClient({
+        cwd,
+        prompt,
+        openFiles,
+        maxFiles: 3,
+        dataDir: mcpDataDir || dataDir,
+        embeddingTimeoutMs: Number(process.env.CONTEXTOS_HOOK_EMBEDDING_TIMEOUT_MS || 500),
+        fileEmbeddingTimeoutMs: Number(process.env.CONTEXTOS_HOOK_FILE_EMBEDDING_TIMEOUT_MS || 500)
+      }), directFallbackTimeoutMs, "direct fallback scoring");
+      scored.telemetry = {
+        ...(scored.telemetry || {}),
+        bridgeStatus: "fallback",
+        bridgeError: error?.message || String(error)
+      };
+    } catch (directError) {
+      scored = emptyScore({
+        bridgeStatus: "fallback-failed",
+        bridgeError: error?.message || String(error),
+        directFallbackError: directError?.message || String(directError)
+      });
+    }
   }
 
   if (scored.error) throw new Error(scored.error);
@@ -53,7 +69,16 @@ export async function handlePromptPayload(
   const relevantFiles = (scored.suggestedFiles || []).slice(0, 3);
   const suggestedSkills = (scored.suggestedSkills || []).slice(0, 3);
   const suggestedWorkflows = (scored.suggestedWorkflows || []).slice(0, 2);
-  const scheduled = scheduleContext({ rules: scoredRules, relevantFiles, suggestedSkills, suggestedWorkflows });
+  const effectiveOutputConfig = outputConfig || loadOutputConfig();
+  const scheduled = scheduleContext({ rules: scoredRules, relevantFiles, suggestedSkills, suggestedWorkflows, outputConfig: effectiveOutputConfig });
+  const contextEmptyReason = emptyContextReason({ scheduled, outputConfig: effectiveOutputConfig, injectContext });
+  const autoWarm = autoWarmWorkspace({
+    cwd,
+    prompt,
+    dataDir,
+    reason: contextEmptyReason,
+    now: now.getTime()
+  });
 
   const runtime = {
     at: now.toISOString(),
@@ -72,7 +97,9 @@ export async function handlePromptPayload(
       rulesInjected: (scheduled.highRules?.length || 0) + (scheduled.midRules?.length || 0),
       filesSuggested: relevantFiles.length,
       skillsSuggested: suggestedSkills.length,
-      workflowsSuggested: suggestedWorkflows.length
+      workflowsSuggested: suggestedWorkflows.length,
+      emptyContextReason: contextEmptyReason,
+      autoWarm
     },
     scheduled,
     injected: injectContext,
@@ -86,12 +113,60 @@ export async function handlePromptPayload(
     // Context injection is the critical path; diagnostics are best-effort.
   }
 
-  return {
+  const additionalContext = injectContext ? scheduled.additionalContext : "";
+  const output = {
     continue: true,
-    suppressOutput: true,
-    hookSpecificOutput: {
+    suppressOutput: true
+  };
+  if (additionalContext) {
+    output.hookSpecificOutput = {
       hookEventName: "UserPromptSubmit",
-      additionalContext: injectContext ? scheduled.additionalContext : ""
+      additionalContext
+    };
+  }
+  return output;
+}
+
+function emptyContextReason({ scheduled, outputConfig, injectContext }) {
+  if (!injectContext) return "injection-disabled";
+  if (scheduled.additionalContext) return null;
+  const sections = outputConfig?.sections || {};
+  const available = [];
+  if ((scheduled.highRules?.length || 0) || (scheduled.midRules?.length || 0)) available.push("rules");
+  if (scheduled.relevantFiles?.length) available.push("files");
+  if (scheduled.suggestedSkills?.length) available.push("skills");
+  if (scheduled.suggestedWorkflows?.length) available.push("workflows");
+  if (!available.length) return "no-context-candidates";
+  const enabled = available.filter((section) => sections[section] !== false);
+  return enabled.length ? "enabled-sections-empty-after-formatting" : `available-sections-disabled:${available.join(",")}`;
+}
+
+function emptyScore(telemetry = {}) {
+  return {
+    scoredRules: [],
+    suggestedFiles: [],
+    suggestedSkills: [],
+    suggestedWorkflows: [],
+    telemetry: {
+      elapsedMs: 0,
+      modelStatus: "skipped",
+      rulesParsed: 0,
+      rulesInjected: 0,
+      filesSuggested: 0,
+      skillsSuggested: 0,
+      workflowsSuggested: 0,
+      ...telemetry
     }
   };
 }
+
+function withTimeout(promise, timeoutMs, label) {
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return promise;
+  let timer;
+  return Promise.race([
+    promise,
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+    })
+  ]).finally(() => clearTimeout(timer));
+}

package/plugins/ctx/lib/ruler-sync.js

@@ -6,6 +6,7 @@ import { stdin as input, stdout as output } from "node:process";
 import { execFileSync, spawn } from "node:child_process";
 
 import { defaultDataRoot } from "./workspace-data.js";
+import { formatTomlValue, readMcpServersFromToml } from "./toml-config.js";
 
 const DEFAULT_AGENTS = ["codex", "claude", "antigravity", "copilot"];
 const CTX_MCP_NAME = "ctx-mcp";
@@ -171,60 +172,12 @@ function hasTomlSection(content, sectionName) {
   return new RegExp(`^\\[${sectionName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]\\s*$`, "m").test(content);
 }
 
-function findMcpServerSections(content) {
-  const lines = String(content || "").split(/\r?\n/);
-  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]),
-      body: lines.slice(index + 1, end)
-    });
-  }
-  return sections;
-}
-
-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 [];
-  const arrayMatch = line.match(/=\s*\[(.*)\]\s*$/);
-  if (!arrayMatch) return [];
-  const values = [];
-  const pattern = /"((?:\\.|[^"\\])*)"/g;
-  let match;
-  while ((match = pattern.exec(arrayMatch[1]))) values.push(unescapeTomlString(match[1]));
-  return values;
-}
-
 function tomlString(value) {
-  return `"${String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  return formatTomlValue(value);
 }
 
 function tomlArray(values = []) {
-  return `[${values.map(tomlString).join(", ")}]`;
-}
-
-function unescapeTomlString(value) {
-  return String(value).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
-}
-
-function unquoteTomlKey(value) {
-  return value.replace(/^"|"$/g, "");
+  return formatTomlValue(values);
 }
 
 function escapeRegExp(value) {
@@ -246,19 +199,14 @@ function unwrapContextOSProxy(command, args = []) {
 export function readCodexMcpServers({ configPath = codexConfigPath() } = {}) {
   if (!fs.existsSync(configPath)) return [];
   const content = fs.readFileSync(configPath, "utf8");
-  const servers = [];
-  for (const section of findMcpServerSections(content)) {
-    const command = findStringValue(section.body, "command");
-    if (!command) continue;
-    const args = findArrayValue(section.body, "args");
+  return readMcpServersFromToml(content).map(({ name, command, args }) => {
     const unwrapped = unwrapContextOSProxy(command, args);
-    servers.push({
-      name: section.name,
+    return {
+      name,
       command: unwrapped.command,
       args: unwrapped.args
-    });
-  }
-  return servers;
+    };
+  });
 }
 
 export function readProjectMcpJsonServers({ cwd = process.cwd(), configPath = path.join(cwd, ".mcp.json") } = {}) {
@@ -302,17 +250,7 @@ function mergeMcpServers(...groups) {
 function readRulerMcpServers({ tomlPath } = {}) {
   if (!tomlPath || !fs.existsSync(tomlPath)) return [];
   const content = fs.readFileSync(tomlPath, "utf8");
-  const servers = [];
-  for (const section of findMcpServerSections(content)) {
-    const command = findStringValue(section.body, "command");
-    if (!command) continue;
-    servers.push({
-      name: section.name,
-      command,
-      args: findArrayValue(section.body, "args")
-    });
-  }
-  return servers;
+  return readMcpServersFromToml(content);
 }
 
 function readRulerMcpServer({ tomlPath, name } = {}) {

package/plugins/ctx/lib/scheduler.js

@@ -1,26 +1,36 @@
+import path from "node:path";
+
+import { loadOutputConfig } from "./output-config.js";
 
 const MAX_CONTEXT_CHARS = 4000;
 
-export function scheduleContext({ rules = [], relevantFiles = [], suggestedSkills = [], suggestedWorkflows = [], maxChars = MAX_CONTEXT_CHARS } = {}) {
+export function scheduleContext({
+  rules = [],
+  relevantFiles = [],
+  suggestedSkills = [],
+  suggestedWorkflows = [],
+  maxChars = MAX_CONTEXT_CHARS,
+  outputConfig = loadOutputConfig()
+} = {}) {
   const orderedRules = [...rules].sort(compareRulesForContext);
   const high = orderedRules.filter((rule) => rule.score >= 0.5);
   const mid = orderedRules.filter((rule) => rule.score >= 0.1 && rule.score < 0.5);
   const dropped = orderedRules.filter((rule) => rule.score < 0.1);
 
   const sections = [];
-  if (high.length) {
+  if (outputConfig.sections.rules && high.length) {
     sections.push(section("Critical ContextOS rules", high.slice(0, 5).map(formatRule)));
   }
-  if (relevantFiles.length) {
-    sections.push(section("Suggested files to check", relevantFiles.map((file) => `- ${file.path}`)));
+  if (outputConfig.sections.files && relevantFiles.length) {
+    sections.push(section("Suggested files to check", relevantFiles.map(formatFile)));
   }
-  if (suggestedSkills.length) {
-    sections.push(section("Skills to activate for this task", suggestedSkills.map(formatSkill)));
+  if (outputConfig.sections.skills && suggestedSkills.length) {
+    sections.push(inlineSection("Skills to activate for this task", suggestedSkills.map(formatSkill)));
   }
-  if (suggestedWorkflows.length) {
+  if (outputConfig.sections.workflows && suggestedWorkflows.length) {
     sections.push(section("Suggested workflow for this task", suggestedWorkflows.map(formatWorkflow)));
   }
-  if (mid.length) {
+  if (outputConfig.sections.rules && mid.length) {
     sections.push(section("Additional relevant rules", mid.slice(0, 5).map(formatRule)));
   }
 
@@ -51,8 +61,15 @@ function rulePriority(rule) {
 }
 
 function section(title, lines) {
-  if (!lines.length) return "";
-  return `## ${title}\n${lines.join("\n")}`;
+  const uniqueLines = [...new Set(lines)];
+  if (!uniqueLines.length) return "";
+  return `## ${title}\n${uniqueLines.join("\n")}`;
+}
+
+function inlineSection(title, values) {
+  const uniqueValues = [...new Set(values)];
+  if (!uniqueValues.length) return "";
+  return `## ${title}: ${uniqueValues.join(", ")}`;
 }
 
 
@@ -60,23 +77,18 @@ function formatRule(rule) {
   return `- ${rule.content}`;
 }
 
+function formatFile(file) {
+  return `- ${path.basename(file.path)}`;
+}
+
 function formatSkill(skill) {
-  const desc = skill.description
-    ? `: ${truncate(skill.description, 80)}`
-    : "";
-  return `- ${skill.name}${desc}`;
+  return skill.name;
 }
 
 function formatWorkflow(workflow) {
   const name = workflow.title || workflow.name;
-  const hint = workflow.hint ? `: ${workflow.hint}` : "";
   const chain = workflow.chain?.length ? `\n  chain: ${workflow.chain.join(" -> ")}` : "";
-  return `- ${name}${hint}${chain}`;
-}
-
-function truncate(text, maxLen) {
-  if (text.length <= maxLen) return text;
-  return `${text.slice(0, maxLen - 1)}…`;
+  return `- ${name}${chain}`;
 }
 
 function trimToLimit(value, maxChars) {

package/plugins/ctx/lib/score-context.js

@@ -17,46 +17,74 @@ export async function scoreContext({
   skills = null,
   workflows = null,
   embeddingTimeoutMs = 5000,
-  fileEmbeddingTimeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || 80)
+  fileEmbeddingTimeoutMs = Number(process.env.CONTEXTOS_FILE_EMBEDDING_TIMEOUT_MS || 1000)
 } = {}) {
   const started = Date.now();
-  const merged = readAgentsChain({ cwd });
-  const rawRules = parseRules(merged.content);
-  const parsedRules = filterActionableRules(rawRules);
-  const baseScoredRules = scoreRules(parsedRules, prompt, openFiles);
-  const embedding = await enhanceRuleScoresWithEmbeddings(baseScoredRules, prompt, {
-    dataDir,
-    sources: merged.sources,
-    timeoutMs: embeddingTimeoutMs,
-    allowRemote: false
+  const ruleInputsPromise = Promise.resolve().then(() => {
+    const merged = readAgentsChain({ cwd });
+    const rawRules = parseRules(merged.content);
+    const parsedRules = filterActionableRules(rawRules);
+    return {
+      merged,
+      rawRules,
+      parsedRules,
+      baseScoredRules: scoreRules(parsedRules, prompt, openFiles)
+    };
   });
-  const scoredRules = embedding.rules;
-  const suggestedFiles = await findRelevantFiles({
-    cwd,
-    task: prompt,
-    rules: scoredRules,
-    dataDir,
-    limit: maxFiles,
-    fileEmbeddingTimeoutMs,
-    fileEmbeddingOptions: {
+
+  const rulesPromise = ruleInputsPromise.then(({ merged, baseScoredRules }) => {
+    return enhanceRuleScoresWithEmbeddings(baseScoredRules, prompt, {
+      dataDir,
+      sources: merged.sources,
+      timeoutMs: embeddingTimeoutMs,
       allowRemote: false
-    }
+    });
   });
-  const skillCatalog = Array.isArray(skills) ? skills : scanSkills({ cwd });
-  const suggestedSkills = await suggestSkills({
-    prompt,
-    skills: skillCatalog,
-    dataDir,
-    limit: maxSkills
+
+  const filesPromise = ruleInputsPromise.then(({ baseScoredRules }) => {
+    return findRelevantFiles({
+      cwd,
+      task: prompt,
+      rules: baseScoredRules,
+      dataDir,
+      limit: maxFiles,
+      fileEmbeddingTimeoutMs,
+      fileEmbeddingOptions: {
+        allowRemote: false
+      }
+    });
   });
-  const workflowCatalog = Array.isArray(workflows) ? workflows : scanWorkflows({ cwd });
-  const suggestedWorkflows = await suggestWorkflows({
-    prompt,
-    workflows: workflowCatalog,
-    dataDir,
-    limit: maxWorkflows
+
+  const skillsPromise = Promise.resolve().then(async () => {
+    const catalog = Array.isArray(skills) ? skills : scanSkills({ cwd });
+    return {
+      catalog,
+      suggestions: await suggestSkills({ cwd, prompt, skills: catalog, dataDir, limit: maxSkills })
+    };
+  });
+
+  const workflowsPromise = Promise.resolve().then(async () => {
+    const catalog = Array.isArray(workflows) ? workflows : scanWorkflows({ cwd });
+    return {
+      catalog,
+      suggestions: await suggestWorkflows({ prompt, workflows: catalog, dataDir, limit: maxWorkflows })
+    };
   });
 
+  const [ruleInputs, embedding, suggestedFiles, skillResult, workflowResult] = await Promise.all([
+    ruleInputsPromise,
+    rulesPromise,
+    filesPromise,
+    skillsPromise,
+    workflowsPromise
+  ]);
+  const { merged, rawRules, parsedRules } = ruleInputs;
+  const scoredRules = embedding.rules;
+  const skillCatalog = skillResult.catalog;
+  const suggestedSkills = skillResult.suggestions;
+  const workflowCatalog = workflowResult.catalog;
+  const suggestedWorkflows = workflowResult.suggestions;
+
   return {
     cwd,
     prompt,

package/plugins/ctx/lib/setup-wizard.js

@@ -36,13 +36,16 @@ export function setupSummaryLines({
   cwd = process.cwd(),
   agents = DEFAULT_AGENTS,
   syncRules = true,
-  syncSkills = true
+  syncSkills = true,
+  promptSections = null
 } = {}) {
-  return [
+  const lines = [
     `Installation directory: ${cwd}`,
     `Agents: ${agents.join(", ") || "(none)"}`,
     `Prompt context injection: always enabled`,
     `Ruler rule/MCP sync: ${syncRules ? "enabled" : "skipped"}`,
     `skillshare skill sync: ${syncSkills ? "enabled" : "skipped"}`
   ];
+  if (promptSections !== null) lines.push(`Prompt sections shown: ${promptSections}`);
+  return lines;
 }

package/plugins/ctx/lib/shell-runner.js

@@ -0,0 +1,88 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+
+export function shellInvocation(command, { platform = process.platform, env = process.env } = {}) {
+  if (platform === "win32") {
+    return {
+      command: env.ComSpec || env.COMSPEC || "cmd.exe",
+      args: ["/d", "/s", "/c", command]
+    };
+  }
+  return {
+    command: fs.existsSync("/bin/sh") ? "/bin/sh" : "sh",
+    args: ["-c", command]
+  };
+}
+
+export function runPrefixedCommand(commandText, {
+  spawnFn = spawn,
+  stdout = process.stdout,
+  stderr = process.stderr,
+  stdin = "inherit",
+  platform = process.platform,
+  env = process.env,
+  prefix = "\x1B[2m│\x1B[0m  "
+} = {}) {
+  const shell = shellInvocation(commandText, { platform, env });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const fail = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+
+    let child;
+    try {
+      child = spawnFn(shell.command, shell.args, {
+        stdio: [stdin, "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (error) {
+      fail(error);
+      return;
+    }
+
+    pipePrefixed(child.stdout, stdout, prefix);
+    pipePrefixed(child.stderr, stderr, prefix);
+
+    child.on("error", (error) => {
+      if (error?.code === "ENOENT") {
+        fail(new Error([
+          `Unable to start shell '${shell.command}' for installer command.`,
+          `Original command: ${commandText}`,
+          platform === "win32"
+            ? "Fix: ensure cmd.exe is available through ComSpec/COMSPEC, or run ContextOS from a normal Command Prompt, PowerShell, or Windows Terminal session."
+            : "Fix: ensure /bin/sh exists, or install a POSIX shell before running ContextOS installers."
+        ].join("\n")));
+        return;
+      }
+      fail(error);
+    });
+
+    child.on("close", (code) => {
+      if (settled) return;
+      settled = true;
+      if (code === 0) resolve();
+      else reject(new Error(`Installer command exited with code ${code}: ${commandText}`));
+    });
+  });
+}
+
+function pipePrefixed(stream, target, prefix) {
+  if (!stream) return;
+  let needPrefix = true;
+  stream.on("data", (buf) => {
+    const str = buf.toString();
+    let out = "";
+    for (const ch of str) {
+      if (needPrefix) {
+        out += prefix;
+        needPrefix = false;
+      }
+      out += ch;
+      if (ch === "\n") needPrefix = true;
+    }
+    target.write(out);
+  });
+}