chainlesschain 0.162.166 → 0.162.167

package/src/lib/doctor-checkup.js

@@ -26,6 +26,11 @@ import {
 import { execSync, spawnSync } from "node:child_process";
 import { join, basename } from "node:path";
 import { getHomeDir, getConfigPath } from "./paths.js";
+import {
+  languageIdForFile,
+  resolveServer,
+  describeServer,
+} from "./lsp/lsp-server-registry.js";
 import {
   checkAgenda,
   checkInstructionFiles,
@@ -33,6 +38,8 @@ import {
   checkHooks,
   checkSandbox,
   checkDuplicateSkills,
+  checkLspReadiness,
+  checkOrphanProcesses,
   DEFAULT_CHECKUP_THRESHOLDS,
 } from "./runtime-checkup.js";
 
@@ -604,16 +611,84 @@ async function worktreeSection(opts, deps) {
 
 // ── runtime checkup: agenda expiry + verbose instruction files ──────────────
 // Only the gaps the OTHER sections don't already cover. Stale sessions,
-// worktrees, orphan processes and lost background agents are handled by
-// transcriptSection / worktreeSection / backgroundSection — surfacing them here
-// too would double-report, so this section deliberately covers just the agenda
-// schedule store and the instruction files (cc.md / AGENTS.md / CLAUDE.md).
+// worktrees and lost background agents (worker STATUS) are handled by
+// transcriptSection / worktreeSection / backgroundSection — surfacing those
+// here too would double-report. This section covers the agenda schedule store,
+// instruction files (cc.md / AGENTS.md / CLAUDE.md), and — distinct from
+// backgroundSection's worker-status check — leaked agent CHILD subprocesses
+// (a per-turn agentPid still alive after its worker died), probed via a static
+// one-shot PID-liveness check and the shared checkOrphanProcesses evaluator.
 const SEVERITY_TO_LEVEL = {
   error: CHECK_LEVELS.ERR,
   warn: CHECK_LEVELS.WARN,
   info: CHECK_LEVELS.INFO,
 };
 
+// Heavy / generated directories a project-language scan must never descend into
+// (they'd dominate the budget and aren't the user's source).
+const LSP_SCAN_SKIP_DIRS = new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  "target",
+  "coverage",
+  "vendor",
+  "venv",
+  "__pycache__",
+]);
+
+/**
+ * Bounded shallow walk of a project root, counting source files per LSP
+ * languageId (via `languageIdForFile`). Deliberately capped by total entries
+ * visited AND depth so `cc doctor` stays fast on a huge monorepo; heavy build /
+ * vendor dirs and dot-dirs are skipped. fs access goes through injected `deps`
+ * (readdirSync/statSync) so it's unit-testable. Returns a Map languageId→count.
+ */
+function scanProjectLanguages(
+  root,
+  deps,
+  { maxEntries = 20000, maxDepth = 8 } = {},
+) {
+  const counts = new Map();
+  let visited = 0;
+  const stack = [{ dir: root, depth: 0 }];
+  while (stack.length && visited < maxEntries) {
+    const { dir, depth } = stack.pop();
+    let names;
+    try {
+      names = deps.readdirSync(dir);
+    } catch {
+      continue; // unreadable dir — skip, never crash the doctor
+    }
+    for (const name of names) {
+      if (visited >= maxEntries) break;
+      visited += 1;
+      const lang = languageIdForFile(name);
+      if (lang) {
+        counts.set(lang, (counts.get(lang) || 0) + 1);
+        continue;
+      }
+      // Not a source file — maybe a directory to descend (bounded). Skip heavy
+      // build/vendor trees and dot-dirs (rarely hold the user's own source).
+      if (
+        depth < maxDepth &&
+        !LSP_SCAN_SKIP_DIRS.has(name) &&
+        !String(name).startsWith(".")
+      ) {
+        let isDir = false;
+        try {
+          isDir = deps.statSync(join(dir, name)).isDirectory();
+        } catch {
+          isDir = false;
+        }
+        if (isDir) stack.push({ dir: join(dir, name), depth: depth + 1 });
+      }
+    }
+  }
+  return counts;
+}
+
 async function runtimeSection(opts, deps) {
   const checks = [];
   const now = deps.now();
@@ -789,6 +864,111 @@ async function runtimeSection(opts, deps) {
     checks.push(failedCheck("sandbox", "sandbox availability", err));
   }
 
+  // LSP readiness — languages the project actually contains but for which no
+  // language server is installed: the silent reason `code_intelligence` /
+  // `cc code-intel` degrades to plain text search. A STATIC install-gap check
+  // (no server is started); the project scan is bounded so it stays fast.
+  try {
+    const root = opts.cwd || process.cwd();
+    const langCounts = scanProjectLanguages(root, deps);
+    if (langCounts.size > 0) {
+      const languages = [];
+      for (const [languageId, fileCount] of langCounts) {
+        const resolved = resolveServer(languageId, root);
+        const desc = describeServer(languageId);
+        languages.push({
+          languageId,
+          fileCount,
+          available: !!resolved,
+          serverId: (resolved && resolved.id) || (desc && desc.id) || null,
+          exampleBin: desc && desc.bins ? desc.bins[0] : null,
+        });
+      }
+      for (const f of checkLspReadiness(languages)) {
+        checks.push(
+          check(
+            f.id,
+            `lsp ${f.ref}`,
+            SEVERITY_TO_LEVEL[f.severity] || CHECK_LEVELS.INFO,
+            `${f.message} — ${f.remediation}`,
+          ),
+        );
+      }
+    }
+  } catch (err) {
+    checks.push(failedCheck("lsp-readiness", "lsp server readiness", err));
+  }
+
+  // Orphaned agent subprocesses — a background worker died but its per-turn
+  // agent CHILD (the LLM/tool subprocess recorded as `agentPid`) is still
+  // alive: a leaked process nothing reaped. backgroundSection reports the
+  // worker's STATUS; this probes the actual child PID's liveness (static,
+  // one-shot, anchored on the process start time to defeat PID reuse) and
+  // feeds the shared checkOrphanProcesses evaluator. Only PIDs we recorded are
+  // probed → no false positives, no OS-wide process-table scan. Tests inject
+  // opts.backgroundProcesses / opts.activeSessionIds (mirrors
+  // opts.skillLayerEntries below).
+  try {
+    let processes = opts.backgroundProcesses;
+    let activeSessionIds = opts.activeSessionIds;
+    if (!processes) {
+      const bgMod = await import("./background-agent-supervisor.js");
+      const agents = bgMod.listBackgroundAgents({ all: true }) || [];
+      activeSessionIds = agents
+        .filter((a) => a.status === "running")
+        .map((a) => a.sessionId)
+        .filter(Boolean);
+      processes = [];
+      for (const a of agents) {
+        let state;
+        try {
+          state = bgMod.readBackgroundAgentState(a.id);
+        } catch {
+          continue; // unreadable/raced state file — skip
+        }
+        const agentPid = Number(state?.agentPid);
+        if (!Number.isInteger(agentPid) || agentPid <= 0) continue;
+        if (agentPid === Number(state?.pid)) continue; // that's the worker itself
+        // Alive AND still the same process we launched (not a reused PID).
+        const anchor = state.agentStartedAt || state.startedAt;
+        if (!bgMod.isSameProcess(agentPid, anchor)) continue; // dead → nothing to reap
+        const parentAlive = bgMod.isSameProcess(
+          Number(state.pid),
+          state.startedAt,
+        );
+        processes.push({
+          pid: agentPid,
+          alive: true,
+          parentAlive,
+          sessionId: state.sessionId || null,
+          kind: "agent-child",
+        });
+      }
+    }
+    for (const f of checkOrphanProcesses(processes, activeSessionIds || [])) {
+      const killCmd =
+        process.platform === "win32"
+          ? `taskkill /PID ${f.ref} /T /F`
+          : `kill ${f.ref}`;
+      checks.push(
+        check(
+          f.id,
+          `process pid=${f.ref}`,
+          SEVERITY_TO_LEVEL[f.severity] || CHECK_LEVELS.WARN,
+          `${f.message} — ${f.remediation}`,
+          {
+            id: `reap-orphan-${f.ref}`,
+            safe: false,
+            description: `terminate leaked agent subprocess pid=${f.ref}`,
+            command: killCmd,
+          },
+        ),
+      );
+    }
+  } catch (err) {
+    checks.push(failedCheck("orphan-process", "orphan agent processes", err));
+  }
+
   // Duplicate skills — an id defined in more than one layer silently shadows
   // (loadAll keeps only the winner), so a user's custom skill can override, or
   // be overridden by, another without any signal. opts.skillLayerEntries lets a

package/src/lib/install-command-policy.js

@@ -0,0 +1,333 @@
+/**
+ * install-command-policy — a UNIFIED classifier + audit for package-install
+ * shell commands across managers (npm / pnpm / yarn / bun / pip / pipx / poetry /
+ * conda / brew / winget / choco / apt / dnf / yum / apk / snap / gem / cargo /
+ * go / composer / dotnet).
+ *
+ * The gap (docs/…INCREMENTAL_GAP_ANALYSIS P0 "跨平台沙箱"): "npm、pip、winget、brew
+ * 等安装入口需要统一权限类型与审计事件". Today a `run_shell` install command is just
+ * another shell command — there is no single place that recognizes "this fetches
+ * and runs third-party code" regardless of which tool does it, and no unified
+ * audit trail. This module supplies both, as PURE detection (no I/O) plus a
+ * best-effort injected-IO audit sink, so it can be reused by the shell approval
+ * path today and other entry points (run_code, hooks) later.
+ *
+ * Design: a per-manager table maps a binary to its install subcommand(s), a
+ * global-scope signal, and package extraction. `classifyInstallCommand` splits a
+ * compound command into segments (reusing the shell-policy splitter) so
+ * `npm i foo && pip install bar` reports BOTH installs. Nothing here changes a
+ * permission decision — callers decide whether to raise a risk floor; the
+ * classification is advisory + auditable.
+ */
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import shellPolicy from "../runtime/coding-agent-shell-policy.cjs";
+
+const { splitCommandSegments, tokenizeShellCommand } = shellPolicy;
+
+// Leading tokens that wrap the real command and must be stripped before the
+// binary is read: privilege elevation, env-var assignments, and `env`/`command`.
+const WRAPPER_TOKENS = new Set([
+  "sudo",
+  "doas",
+  "env",
+  "command",
+  "exec",
+  "nice",
+]);
+
+/**
+ * Per-manager install detection. `sub` = subcommand keywords that mean "install".
+ * `system` = the install always affects the whole machine/user (no project
+ * scope), so it is treated as global regardless of flags. `globalFlags`/
+ * `globalWords` mark a per-tool global install. `packageWord` (dotnet) requires a
+ * keyword before the package name.
+ */
+const MANAGERS = [
+  {
+    name: "npm",
+    bin: /^npm$/,
+    sub: ["install", "i", "add", "ci"],
+    globalFlags: ["-g", "--global"],
+  },
+  {
+    name: "pnpm",
+    bin: /^pnpm$/,
+    sub: ["install", "i", "add"],
+    globalFlags: ["-g", "--global"],
+  },
+  {
+    name: "yarn",
+    bin: /^yarn$/,
+    sub: ["add", "install"],
+    globalWords: ["global"],
+  },
+  {
+    name: "bun",
+    bin: /^bun$/,
+    sub: ["install", "i", "add"],
+    globalFlags: ["-g", "--global"],
+  },
+  { name: "pip", bin: /^pip[0-9.]*$/, sub: ["install"], globalFlags: [] },
+  { name: "pipx", bin: /^pipx$/, sub: ["install"], system: true },
+  { name: "poetry", bin: /^poetry$/, sub: ["add"], globalFlags: [] },
+  { name: "conda", bin: /^conda$/, sub: ["install"], globalFlags: [] },
+  { name: "brew", bin: /^brew$/, sub: ["install"], system: true },
+  { name: "winget", bin: /^winget$/, sub: ["install"], system: true },
+  { name: "choco", bin: /^choco(latey)?$/, sub: ["install"], system: true },
+  { name: "apt", bin: /^apt(-get)?$/, sub: ["install"], system: true },
+  { name: "dnf", bin: /^(dnf|yum)$/, sub: ["install"], system: true },
+  { name: "apk", bin: /^apk$/, sub: ["add"], system: true },
+  { name: "snap", bin: /^snap$/, sub: ["install"], system: true },
+  { name: "gem", bin: /^gem$/, sub: ["install"], system: true },
+  { name: "cargo", bin: /^cargo$/, sub: ["install"], system: true },
+  { name: "go", bin: /^go$/, sub: ["install", "get"], system: true },
+  {
+    name: "composer",
+    bin: /^composer$/,
+    sub: ["require", "install"],
+    globalWords: ["global"],
+  },
+  {
+    name: "dotnet",
+    bin: /^dotnet$/,
+    sub: ["add"],
+    packageWord: "package",
+    system: false,
+  },
+];
+
+/** Basename of a binary path, minus a Windows .exe/.cmd/.bat/.ps1 suffix. */
+function normalizeBin(token) {
+  const base = String(token || "")
+    .replace(/\\/g, "/")
+    .split("/")
+    .pop();
+  return base.replace(/\.(exe|cmd|bat|ps1)$/i, "").toLowerCase();
+}
+
+/** Strip leading wrapper tokens (sudo/env/VAR=val) → the real argv, or null. */
+function unwrapArgv(tokens) {
+  let i = 0;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (WRAPPER_TOKENS.has(t) || /^[A-Za-z_][A-Za-z0-9_]*=/.test(t)) {
+      i += 1;
+      continue;
+    }
+    break;
+  }
+  return tokens.slice(i);
+}
+
+/**
+ * Classify ONE already-split command segment. Returns an install descriptor or
+ * null. Pure.
+ * @returns {{manager:string, subcommand:string, packages:string[], global:boolean}|null}
+ */
+export function classifyInstallSegment(segment) {
+  const argv = unwrapArgv(tokenizeShellCommand(segment));
+  if (argv.length === 0) return null;
+  const bin = normalizeBin(argv[0]);
+  const mgr = MANAGERS.find((m) => m.bin.test(bin));
+  if (!mgr) return null;
+
+  const rest = argv.slice(1);
+  // Find the install subcommand token (first non-flag token that matches). For
+  // dotnet, the trigger is `add … package`, so also require the package word.
+  let subIdx = -1;
+  let subcommand = null;
+  for (let i = 0; i < rest.length; i++) {
+    const tok = rest[i];
+    if (mgr.sub.includes(tok)) {
+      subIdx = i;
+      subcommand = tok;
+      break;
+    }
+  }
+  if (subIdx === -1) return null;
+  if (mgr.packageWord && !rest.slice(subIdx + 1).includes(mgr.packageWord)) {
+    return null; // e.g. `dotnet add reference` is not a package install
+  }
+
+  // Everything after the subcommand (and, for dotnet, after `package`) that is
+  // not a flag = the requested packages (best-effort; enough for audit).
+  let argsAfter = rest.slice(subIdx + 1);
+  if (mgr.packageWord) {
+    const pw = argsAfter.indexOf(mgr.packageWord);
+    argsAfter = pw >= 0 ? argsAfter.slice(pw + 1) : argsAfter;
+  }
+  const packages = argsAfter.filter((t) => !t.startsWith("-"));
+
+  const global =
+    mgr.system === true ||
+    (mgr.globalFlags || []).some((f) => rest.includes(f)) ||
+    (mgr.globalWords || []).some((w) => rest.includes(w));
+
+  return { manager: mgr.name, subcommand, packages, global };
+}
+
+/**
+ * Classify a full (possibly compound) shell command. Splits on `&&`/`||`/`;`/`|`
+ * so `npm i a && pip install b` reports BOTH. Returns `{ isInstall, installs }`.
+ * Pure.
+ */
+export function classifyInstallCommand(command) {
+  const segments = splitCommandSegments(String(command || ""));
+  const installs = [];
+  for (const seg of segments) {
+    const hit = classifyInstallSegment(seg);
+    if (hit) installs.push(hit);
+  }
+  return { isInstall: installs.length > 0, installs };
+}
+
+/** True if any classified install is global/system-scoped (higher blast radius). */
+export function hasGlobalInstall(classification) {
+  return !!(
+    classification &&
+    Array.isArray(classification.installs) &&
+    classification.installs.some((i) => i.global)
+  );
+}
+
+// ── remote-script execution ("curl … | sh") ────────────────────────────────
+// The most dangerous "fetch and run third-party code" vector isn't a package
+// manager at all — it's piping a download straight into a shell, or running a
+// shell over a command/process substitution that downloads. It runs UNPINNED,
+// UNVERIFIED, attacker-mutable code with the agent's privileges. These patterns
+// must be recognized on the RAW command (the pipe/substitution structure is lost
+// once split into segments), so they use anchored regexes rather than the
+// per-segment classifier.
+const REMOTE_FETCHERS = "curl|wget|fetch|iwr|invoke-webrequest|http|httpie";
+const SHELL_INTERPRETERS =
+  "sh|bash|zsh|ksh|dash|fish|python[0-9.]*|ruby|perl|node|deno|pwsh|powershell|eval|source";
+
+// `curl URL | sh`, `wget -O- URL | sudo bash`, `curl URL | tee f | sh`. After
+// the pipe, skip inline wrappers (`sudo `/`env `, space-separated) AND piped
+// pass-throughs (`tee f |`, `cat |`) before the interpreter.
+const PIPE_TO_SHELL_RE = new RegExp(
+  `\\b(${REMOTE_FETCHERS})\\b[^|]*\\|\\s*(?:(?:sudo|env|command|nice)\\s+|(?:tee|cat)\\b[^|]*\\|\\s*)*(${SHELL_INTERPRETERS})\\b`,
+  "i",
+);
+// `bash -c "$(curl URL)"`, `sh <(curl URL)`, `eval "$(wget -O- URL)"`
+const SUBST_TO_SHELL_RE = new RegExp(
+  `\\b(${SHELL_INTERPRETERS})\\b[^\\n]*[$<]\\(\\s*(?:sudo\\s+)?(${REMOTE_FETCHERS})\\b`,
+  "i",
+);
+
+function firstUrl(s) {
+  const m = String(s).match(/\bhttps?:\/\/[^\s'"|)>]+/i);
+  return m ? m[0] : null;
+}
+
+/**
+ * Detect remote-script execution in a raw shell command: a network fetcher piped
+ * into (or command/process-substituted into) a shell interpreter. Returns
+ * `{ isRemoteExec, matches:[{pattern, fetcher, interpreter, url}] }`. Pure.
+ */
+export function classifyRemoteExecCommand(command) {
+  const s = String(command || "");
+  const matches = [];
+  const pipe = PIPE_TO_SHELL_RE.exec(s);
+  if (pipe) {
+    matches.push({
+      pattern: "pipe-to-shell",
+      fetcher: pipe[1].toLowerCase(),
+      interpreter: pipe[2].toLowerCase(),
+      url: firstUrl(s),
+    });
+  }
+  const subst = SUBST_TO_SHELL_RE.exec(s);
+  if (subst) {
+    matches.push({
+      pattern: "cmdsubst-to-shell",
+      interpreter: subst[1].toLowerCase(),
+      fetcher: subst[2].toLowerCase(),
+      url: firstUrl(s),
+    });
+  }
+  return { isRemoteExec: matches.length > 0, matches };
+}
+
+/**
+ * Combined "untrusted code acquisition" classification: package installs AND
+ * remote-script execution. `flagged` is true if EITHER fires — the single signal
+ * a caller gates/audits on. Pure.
+ */
+export function classifyCodeAcquisition(command) {
+  const install = classifyInstallCommand(command);
+  const remote = classifyRemoteExecCommand(command);
+  return {
+    flagged: install.isInstall || remote.isRemoteExec,
+    isInstall: install.isInstall,
+    installs: install.installs,
+    isRemoteExec: remote.isRemoteExec,
+    remoteExec: remote.matches,
+  };
+}
+
+/**
+ * Resolve the install-command policy from env/settings (opt-in, so the default
+ * shell path is byte-unchanged). `audit` enables the audit trail; `riskFloor`
+ * ("low"|"medium"|"high") is the MINIMUM risk an install command is treated as
+ * (never lowers an already-higher risk).
+ */
+export function resolveInstallPolicy({
+  env = process.env,
+  settings = null,
+} = {}) {
+  const s = (settings && settings.installPolicy) || {};
+  const envAudit = env.CC_INSTALL_AUDIT;
+  const audit =
+    envAudit === "1" ? true : envAudit === "0" ? false : s.audit === true;
+  const riskFloor =
+    env.CC_INSTALL_RISK_FLOOR ||
+    (typeof s.riskFloor === "string" ? s.riskFloor : null) ||
+    null;
+  return {
+    audit,
+    riskFloor: riskFloor ? String(riskFloor).toLowerCase() : null,
+    enabled: audit || !!riskFloor,
+  };
+}
+
+const RISK_RANK = { low: 0, medium: 1, high: 2 };
+
+/**
+ * Apply a risk floor: return whichever of `currentRisk` / `floor` is HIGHER
+ * (never downgrades). Unknown values pass `currentRisk` through unchanged.
+ */
+export function applyRiskFloor(currentRisk, floor) {
+  if (!floor || !(floor in RISK_RANK)) return currentRisk;
+  const cur = RISK_RANK[currentRisk];
+  if (cur == null) return currentRisk;
+  return RISK_RANK[floor] > cur ? floor : currentRisk;
+}
+
+/** Best-effort append of one install-command audit record. Never throws. */
+export function recordInstallCommandAudit(entry, opts = {}) {
+  try {
+    const baseDir =
+      opts.baseDir ||
+      (opts.env || process.env).CC_AUDIT_DIR ||
+      path.join(os.homedir(), ".chainlesschain", "audit");
+    const _fs = opts.fs || fs;
+    _fs.mkdirSync(baseDir, { recursive: true });
+    const line = JSON.stringify({
+      ts: new Date(opts.now ? opts.now() : Date.now()).toISOString(),
+      kind: "install-command",
+      ...entry,
+    });
+    _fs.appendFileSync(
+      path.join(baseDir, "install-commands.jsonl"),
+      line + "\n",
+      "utf-8",
+    );
+    return true;
+  } catch {
+    return false; // audit is best-effort — never affect the run
+  }
+}

package/src/lib/jsonl-session-store.js

@@ -21,6 +21,7 @@ export {
   readEvents,
   rebuildMessages,
   listJsonlSessions,
+  listSessionIds,
   renameSession,
   pruneJsonlSessions,
   forkSession,

package/src/lib/lsp/__tests__/lsp-server-registry.test.js

@@ -11,6 +11,7 @@ import {
   resolveServer,
   resolveBin,
   probeServers,
+  describeServer,
   registerLanguageServer,
   _resetPluginServers,
   _deps,
@@ -126,3 +127,29 @@ describe("probeServers", () => {
     expect(ids).toContain("typescript-language-server");
   });
 });
+
+describe("describeServer", () => {
+  it("names the builtin server for a language even when not installed", () => {
+    existsFor([]); // nothing on PATH
+    const ts = describeServer("typescript");
+    expect(ts.id).toBe("typescript-language-server");
+    expect(ts.bins).toContain("typescript-language-server");
+    // Independent of install state — it describes the EXPECTED server.
+    expect(describeServer("python").id).toBe("pyright");
+    expect(describeServer("go").id).toBe("gopls");
+  });
+
+  it("returns null for an unsupported language", () => {
+    expect(describeServer("cobol")).toBe(null);
+    expect(describeServer(undefined)).toBe(null);
+  });
+
+  it("prefers a registered plugin server over the builtin", () => {
+    registerLanguageServer({
+      languageId: "typescript",
+      command: "my-ts-lsp",
+      id: "plugin-ts",
+    });
+    expect(describeServer("typescript").id).toBe("plugin-ts");
+  });
+});

package/src/lib/lsp/lsp-server-registry.js

@@ -232,3 +232,17 @@ export function probeServers(projectRoot) {
 export function supportedExtensions() {
   return Object.keys(EXTENSION_LANGUAGE).sort();
 }
+
+/**
+ * Describe the server that WOULD serve a languageId, whether or not its binary
+ * is installed — the first plugin candidate, else the builtin. Unlike
+ * `resolveServer` (which returns null when nothing is on PATH), this names the
+ * expected server so a doctor / status view can say *what to install*. Returns
+ * `{ id, bins }` or null for an unsupported language.
+ */
+export function describeServer(languageId) {
+  const candidates = [...(pluginServers.get(languageId) || [])];
+  if (BUILTIN_SERVERS[languageId]) candidates.push(BUILTIN_SERVERS[languageId]);
+  const def = candidates[0];
+  return def ? { id: def.id, bins: [...def.bins] } : null;
+}

package/src/lib/runtime-checkup.js

@@ -437,6 +437,39 @@ export function checkDuplicateSkills(entries = []) {
   return out;
 }
 
+/**
+ * LSP READINESS: languages the project actually contains but for which no
+ * language server is installed — the silent reason `code_intelligence` /
+ * `cc code-intel` quietly degrades to plain text search. Unlike
+ * `checkPluginsAndLsp` (live server health) this is a STATIC install-gap check a
+ * separate `cc doctor` process can compute without any server running: it
+ * correlates source files present with `resolveServer` availability. Only
+ * present-but-missing languages warn; installed languages produce nothing (no
+ * noise). Each `languages` entry: `{ languageId, fileCount, available, serverId,
+ * exampleBin }`.
+ */
+export function checkLspReadiness(languages = []) {
+  const out = [];
+  for (const l of languages) {
+    if (!l || !l.languageId) continue;
+    const fileCount = Number(l.fileCount) || 0;
+    if (fileCount <= 0 || l.available) continue;
+    const server = l.serverId || `a ${l.languageId} language server`;
+    const install = l.exampleBin ? ` (e.g. install ${l.exampleBin})` : "";
+    out.push(
+      finding(
+        "lsp-server-missing",
+        "lsp",
+        "warn",
+        `${fileCount} ${l.languageId} file(s) present but no language server installed${install}`,
+        `install ${server} for real code-intelligence, or ignore to keep text-search fallback`,
+        { ref: l.languageId, fileCount, serverId: l.serverId || null },
+      ),
+    );
+  }
+  return out;
+}
+
 /** Plugins / LSP servers reported unhealthy or dead. */
 export function checkPluginsAndLsp(plugins = []) {
   const out = [];