@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-IN7DGBVS.js

@@ -0,0 +1,582 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  readStateInfoResult
+} from "./chunk-NOCSM22Y.js";
+import {
+  fingerprintNativeRuntime
+} from "./chunk-KW5HXKLJ.js";
+import {
+  initializeClioHome
+} from "./chunk-URCXX7WJ.js";
+import {
+  detectInteropAgents,
+  resolveOnPath
+} from "./chunk-4A6YRGV4.js";
+import {
+  foldPromptCacheTelemetry,
+  hasPromptCacheTelemetry,
+  topExpectedColdReason
+} from "./chunk-TKDRT2DF.js";
+import {
+  loadSkills
+} from "./chunk-LAR7DX5E.js";
+import {
+  credentialsPresent
+} from "./chunk-DVTBERFY.js";
+import {
+  openAuthStorage,
+  resolveAuthTarget,
+  targetRequiresAuth
+} from "./chunk-Z4GLJ6J4.js";
+import {
+  isSessionEntry
+} from "./chunk-I4Y4WKZR.js";
+import {
+  readSessionFileEntries
+} from "./chunk-EKV4UBCM.js";
+import {
+  interopAgentKind
+} from "./chunk-5EQO5NWP.js";
+import {
+  formatSettingsIssues,
+  readSettings,
+  validateSettingsFile
+} from "./chunk-56XP4FJU.js";
+import {
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
+import {
+  getVersionInfo
+} from "./chunk-2VLYHHFT.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/lifecycle/doctor.ts
+init_esm_shims();
+import { accessSync, chmodSync, constants, existsSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+var FOREIGN_SKILL_SOURCES = /* @__PURE__ */ new Set(["agents", "claude", "codex", "copilot", "opencode"]);
+function describeNodeType(stats) {
+  if (stats.isFile()) return "a regular file";
+  if (stats.isSymbolicLink()) return "a symlink";
+  if (stats.isFIFO()) return "a FIFO";
+  if (stats.isSocket()) return "a socket";
+  if (stats.isBlockDevice() || stats.isCharacterDevice()) return "a device node";
+  return "not a directory";
+}
+function directoryFinding(name, path) {
+  let stats;
+  try {
+    stats = statSync(path);
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") return { ok: false, name, detail: `${path} missing (run \`clio-coder doctor --fix\`)` };
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, name, detail: `${path} cannot be inspected: ${message}` };
+  }
+  if (!stats.isDirectory()) {
+    return {
+      ok: false,
+      name,
+      detail: `${path} is ${describeNodeType(stats)}, not a directory (move it aside, then run \`clio-coder doctor --fix\`)`
+    };
+  }
+  const missing = [
+    ["readable", constants.R_OK],
+    ["writable", constants.W_OK],
+    ["traversable", constants.X_OK]
+  ].filter(([, bit]) => {
+    try {
+      accessSync(path, bit);
+      return false;
+    } catch {
+      return true;
+    }
+  }).map(([label]) => label);
+  if (missing.length > 0) {
+    return { ok: false, name, detail: `${path} is not ${missing.join(" or ")} (run \`chmod u+rwx\` on it)` };
+  }
+  return { ok: true, name, detail: path };
+}
+var SESSION_STORE_DAMAGE_DETAIL_LIMIT = 3;
+var SESSION_STORE_DAMAGE_LOCATION_LIMIT = 2;
+function summarizeSessionDamage(warnings) {
+  const byMessage = /* @__PURE__ */ new Map();
+  for (const warning of warnings) {
+    const locations = byMessage.get(warning.message) ?? [];
+    locations.push(`${warning.path}:${warning.line}`);
+    byMessage.set(warning.message, locations);
+  }
+  return Array.from(byMessage, ([message, locations]) => {
+    const shown = locations.slice(0, SESSION_STORE_DAMAGE_LOCATION_LIMIT);
+    const rest = locations.length - shown.length;
+    return `${shown.join(", ")}${rest > 0 ? `, +${rest} more` : ""}: ${message}`;
+  });
+}
+function collectSessionLedgers(dir, ledgers, unlistable) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    unlistable.push(`${dir} could not be listed: ${message}`);
+    return;
+  }
+  for (const entry of entries) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectSessionLedgers(full, ledgers, unlistable);
+      continue;
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) ledgers.push(full);
+  }
+}
+function sessionStoreFinding(stateDir, stateMetadataPresent) {
+  const store = join(stateDir, "sessions");
+  const usable = directoryFinding("session store", store);
+  if (!usable.ok) {
+    if (!stateMetadataPresent && !existsSync(store)) return null;
+    return usable;
+  }
+  const ledgers = [];
+  const unlistable = [];
+  collectSessionLedgers(store, ledgers, unlistable);
+  const damaged = [];
+  for (const ledger of ledgers) {
+    const first = [];
+    readSessionFileEntries(ledger, {
+      onWarning: (warning2) => {
+        if (first.length === 0) first.push(warning2);
+      }
+    });
+    const warning = first[0];
+    if (warning) damaged.push(warning);
+  }
+  if (damaged.length === 0 && unlistable.length === 0) {
+    return {
+      ok: true,
+      name: "session store",
+      detail: ledgers.length === 0 ? `${store} (no sessions recorded)` : `${store} (${ledgers.length} readable)`
+    };
+  }
+  const clauses = summarizeSessionDamage(damaged);
+  const shown = clauses.slice(0, SESSION_STORE_DAMAGE_DETAIL_LIMIT);
+  const remainder = clauses.length - shown.length;
+  const parts = [];
+  if (damaged.length > 0) {
+    parts.push(
+      `${damaged.length} of ${ledgers.length} ledgers hold lines that cannot be read: ${shown.join("; ")}${remainder > 0 ? `; +${remainder} more` : ""}`
+    );
+  }
+  parts.push(...unlistable);
+  return { ok: false, name: "session store", detail: parts.join("; ") };
+}
+function latestSessionCacheFinding(stateDir) {
+  const store = join(stateDir, "sessions");
+  const ledgers = [];
+  const unlistable = [];
+  collectSessionLedgers(store, ledgers, unlistable);
+  const candidates = [];
+  for (const ledger of ledgers) {
+    if (basename(ledger) !== "current.jsonl") continue;
+    let parsed;
+    let modifiedAt;
+    try {
+      parsed = readSessionFileEntries(ledger, { onWarning: () => {
+      } });
+      modifiedAt = statSync(ledger).mtimeMs;
+    } catch {
+      continue;
+    }
+    const entries = parsed.filter(isSessionEntry);
+    const entryTimes = entries.map((entry) => Date.parse(entry.timestamp)).filter((timestamp) => Number.isFinite(timestamp));
+    candidates.push({
+      entries,
+      ledger,
+      sessionId: basename(dirname(ledger)),
+      updatedAt: entryTimes.length > 0 ? Math.max(...entryTimes) : modifiedAt
+    });
+  }
+  const latest = candidates.sort(
+    (left, right) => right.updatedAt - left.updatedAt || left.ledger.localeCompare(right.ledger)
+  )[0];
+  if (latest === void 0) return null;
+  const telemetry = foldPromptCacheTelemetry(latest.entries);
+  if (!hasPromptCacheTelemetry(telemetry)) {
+    return {
+      ok: true,
+      level: "warn",
+      name: "cache telemetry",
+      detail: `last session ${latest.sessionId}: no prompt-cache telemetry recorded`
+    };
+  }
+  const counts = telemetry.verdictCounts;
+  const topReason = topExpectedColdReason(telemetry);
+  return {
+    ok: true,
+    name: "cache telemetry",
+    detail: `last session ${latest.sessionId}: hot ${counts.hot} \xB7 partial ${counts.partial} \xB7 cold ${counts.cold} \xB7 small ${counts.small} \xB7 unknown ${counts.unknown}; top expected reason ${topReason === null ? "none" : `${topReason.reason} (${topReason.count})`}`
+  };
+}
+function credentialsDamage() {
+  try {
+    return openAuthStorage().damageReason();
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function isUninitializedHome(dirs = resolveClioDirs()) {
+  return !existsSync(dirs.config) && !existsSync(dirs.data) && !existsSync(dirs.state) && !existsSync(dirs.cache) && !existsSync(join(dirs.state, "install.json"));
+}
+function runDoctor(options = {}) {
+  let repairFailure = null;
+  if (options.fix) {
+    try {
+      initializeClioHome();
+      const credentialsPath = join(resolveClioDirs().config, "credentials.yaml");
+      if (existsSync(credentialsPath)) {
+        chmodSync(credentialsPath, 384);
+      }
+    } catch (error) {
+      repairFailure = error instanceof Error ? error.message : String(error);
+    }
+  }
+  const findings = [];
+  if (repairFailure !== null) {
+    findings.push({ ok: false, name: "repair", detail: `--fix could not finish: ${repairFailure}` });
+  }
+  const version = getVersionInfo();
+  findings.push({ ok: true, name: "Clio Coder version", detail: version.clio });
+  findings.push({ ok: true, name: "node version", detail: version.node });
+  findings.push({ ok: true, name: "platform", detail: version.platform });
+  const engineReady = Boolean(version.piAgentCore && version.piAi && version.piTui);
+  findings.push({
+    ok: engineReady,
+    name: "engine runtime",
+    detail: engineReady ? "ready" : "missing required packages"
+  });
+  const dirs = resolveClioDirs();
+  const config = dirs.config;
+  if (!options.fix && isUninitializedHome(dirs)) {
+    findings.push({
+      ok: true,
+      level: "warn",
+      name: "installation",
+      detail: "not set up yet: run `clio-coder` to start the first-run wizard, or `clio-coder configure`; `clio-coder doctor --fix` creates the directories without choosing a model"
+    });
+    return findings;
+  }
+  findings.push(directoryFinding("config dir", config));
+  findings.push(directoryFinding("data dir", dirs.data));
+  findings.push(directoryFinding("state dir", dirs.state));
+  findings.push(directoryFinding("cache dir", dirs.cache));
+  const settings = join(config, "settings.yaml");
+  if (!existsSync(settings)) {
+    findings.push({
+      ok: false,
+      name: "settings.yaml",
+      detail: "missing (run `clio-coder doctor --fix` or `clio-coder configure`)"
+    });
+  } else {
+    const validation = validateSettingsFile();
+    if (validation.issues.length === 0) {
+      findings.push({ ok: true, name: "settings.yaml", detail: settings });
+    } else {
+      findings.push({ ok: false, name: "settings.yaml", detail: formatSettingsIssues(validation.issues) });
+    }
+  }
+  const creds = join(config, "credentials.yaml");
+  if (!existsSync(creds)) {
+    findings.push({ ok: false, name: "credentials", detail: "missing (run `clio-coder doctor --fix`)" });
+  } else {
+    try {
+      accessSync(creds, constants.R_OK);
+      const st = statSync(creds);
+      const mode = st.mode & 511;
+      const damage = credentialsDamage();
+      findings.push({
+        ok: mode === 384 && damage === null,
+        name: "credentials",
+        detail: damage === null ? mode.toString(8) : `${mode.toString(8)}; ${damage}`
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      findings.push({
+        ok: false,
+        name: "credentials",
+        detail: foldDetail(`${creds} cannot be read: ${message} (run \`clio-coder doctor --fix\`)`)
+      });
+    }
+  }
+  const stateRead = readStateInfoResult();
+  const state = stateRead.info;
+  const stateCurrent = Boolean(state && state.version === version.clio);
+  const stateStamps = state ? [
+    state.installedAt ? `installed ${state.installedAt}` : null,
+    state.repairedAt ? `repaired ${state.repairedAt}` : null,
+    state.upgradedAt ? `upgraded ${state.upgradedAt}${state.upgradedFrom ? ` from ${state.upgradedFrom}` : ""}` : null
+  ].filter((stamp) => stamp !== null) : [];
+  const stateStamp = stateStamps.join(", ");
+  findings.push({
+    ok: stateCurrent,
+    name: "state metadata",
+    detail: state ? stateCurrent ? `${state.version} (${stateStamp})` : `stale ${state.version} (${stateStamp}); current ${version.clio} (run \`clio-coder doctor --fix\`)` : stateRead.problem !== null ? (
+      // Present but unreadable. `--fix` cannot repair this one: it fails on
+      // the same permissions, so pointing there would send the user in a
+      // circle.
+      stateRead.problem
+    ) : (
+      // Every other failing row names the command that repairs it. This one
+      // said only "missing", and `clio-coder doctor --fix` does write it.
+      "missing (run `clio-coder doctor --fix`)"
+    )
+  });
+  const sessionStore = sessionStoreFinding(dirs.state, state !== null);
+  if (sessionStore !== null) findings.push(sessionStore);
+  if (sessionStore?.ok) {
+    const cacheTelemetry = latestSessionCacheFinding(dirs.state);
+    if (cacheTelemetry !== null) findings.push(cacheTelemetry);
+  }
+  return findings;
+}
+function foldDetail(detail) {
+  return detail.replace(/\s*\n\s*/g, " ").trim();
+}
+function formatDoctorReport(findings) {
+  const lines = findings.map((f) => {
+    const level = f.level ?? (f.ok ? "ok" : "error");
+    const badge = level === "ok" ? "OK" : level === "info" ? "INFO" : level === "warn" ? "WARN" : "!! ";
+    return `${badge.padEnd(4)} ${f.name.padEnd(22)} ${foldDetail(f.detail)}`;
+  });
+  return lines.join("\n");
+}
+async function runDoctorFleetChecks(projectRoot = process.cwd(), options = {}) {
+  let settings;
+  try {
+    settings = readSettings();
+  } catch {
+    return [];
+  }
+  const nodes = settings.fleet?.nodes ?? [];
+  if (nodes.length === 0) return [];
+  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-NZQHABWO.js");
+  const targets = (settings.targets ?? []).map((target) => ({
+    id: target.id,
+    runtimeId: target.runtime,
+    ...target.url !== void 0 ? { url: target.url } : {},
+    ...target.defaultModel !== void 0 ? { wireModelId: target.defaultModel } : {}
+  }));
+  const records = await Promise.all(nodes.map((node) => runFleetNodePreflight(node, projectRoot, { targets })));
+  let recorded = options.fix === true;
+  if (recorded) {
+    try {
+      recordFleetPreflight(records);
+    } catch {
+      recorded = false;
+    }
+  }
+  const admission = recorded ? "recorded for dispatch" : "not recorded, run doctor --fix to admit this node";
+  return records.map((record) => ({
+    ok: true,
+    level: record.ok ? "ok" : "warn",
+    name: `fleet node ${record.nodeId}`,
+    detail: record.ok ? `eligible (${admission}): ${record.host} clio ${record.remoteVersion ?? "(custom entry)"}, path parity for ${record.projectRoot}, ${record.targets.filter((fact) => fact.reachable === "true").length}/${record.targets.length} targets reachable from the node` : `ineligible: ${record.detail ?? "preflight failed"}`
+  }));
+}
+async function runDoctorInteropChecks(projectRoot = process.cwd()) {
+  let settings;
+  try {
+    settings = readSettings();
+  } catch {
+    return [];
+  }
+  const configDir = resolveClioDirs().config;
+  const skills = existsSync(configDir) ? loadSkills({ cwd: projectRoot, configDir }) : { items: [], diagnostics: [] };
+  const foreign = skills.items.filter((skill) => FOREIGN_SKILL_SOURCES.has(skill.source));
+  const report = await detectInteropAgents(
+    {
+      cwd: projectRoot,
+      // Version probes use the shared command runner, which prepares managed Git
+      // hooks before spawning. Doctor promises observation only, so PATH presence
+      // is the strongest safe fact here.
+      probeVersion: false,
+      skillSources: skills.items.map((skill) => skill.source)
+    },
+    // Reading the prior report resolves through the ensuring state accessor.
+    // Existing decisions are irrelevant to doctor's presence-only projection.
+    []
+  );
+  const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
+  const findings = report.agents.map((agent) => {
+    const kind = interopAgentKind(agent.kind);
+    const status = configured.has(agent.kind) ? "configured" : kind?.acp === void 0 ? "no ACP recipe" : "detected, not configured";
+    const head = agent.binary === void 0 ? "not on PATH" : agent.version ?? "version unknown";
+    const where = agent.binary !== void 0 ? ` at ${agent.binary}` : agent.installDir !== void 0 ? `, files under ${agent.installDir}` : "";
+    return { ok: true, level: "ok", name: `interop ${agent.kind}`, detail: `${head} (${status})${where}` };
+  });
+  for (const agent of settings.integrations.externalAgents.entries) {
+    if (resolveOnPath([agent.command]).presence === "present") continue;
+    findings.push({
+      ok: true,
+      level: "warn",
+      name: `interop ${agent.id}`,
+      detail: `configured peer command \`${agent.command}\` does not resolve on PATH; /delegate ${agent.id} will fail to spawn`
+    });
+  }
+  if (foreign.length > 0) {
+    const roots = new Set(foreign.map((skill) => skill.sourceInfo.source ?? skill.baseDir));
+    findings.push({
+      ok: true,
+      level: "ok",
+      name: "interop skills",
+      detail: `${foreign.length} skills from ${roots.size} foreign roots`
+    });
+  }
+  return findings;
+}
+async function runDoctorRuntimeChecks() {
+  let settings;
+  try {
+    settings = readSettings();
+  } catch {
+    return [];
+  }
+  const candidates = settings.targets.filter(
+    (entry) => (entry.runtime === "openai-compat" || entry.runtime === "anthropic-compat") && Boolean(entry.url)
+  );
+  if (candidates.length === 0) return [];
+  const results = await Promise.all(
+    candidates.map(async (target) => {
+      const url = target.url;
+      if (!url) return null;
+      const fingerprint = await fingerprintNativeRuntime(url);
+      if (!fingerprint) return null;
+      return {
+        ok: true,
+        level: "warn",
+        name: `target ${target.id}`,
+        detail: `${fingerprint.displayName} detected at ${url}; run \`clio-coder targets convert ${target.id} --runtime ${fingerprint.runtimeId}\` for proper resident-model lifecycle`
+      };
+    })
+  );
+  return results.filter((finding) => finding !== null);
+}
+function configuredModelRoles(settings, target) {
+  const roles = [];
+  if (target.defaultModel) roles.push({ role: "defaultModel", model: target.defaultModel });
+  if (settings.chat.target === target.id && settings.chat.model) {
+    roles.push({ role: "orchestrator.model", model: settings.chat.model });
+  }
+  if (settings.context.memory.target === target.id && settings.context.memory.model) {
+    roles.push({ role: "background.model", model: settings.context.memory.model });
+  }
+  if (settings.fleet.default.target === target.id && settings.fleet.default.model) {
+    roles.push({ role: "workers.default.model", model: settings.fleet.default.model });
+  }
+  return roles;
+}
+var DOCTOR_MODEL_PROBE_TIMEOUT_MS = 2500;
+async function doctorProbeContext(target, runtime) {
+  const ctx = { credentialsPresent: credentialsPresent(), httpTimeoutMs: DOCTOR_MODEL_PROBE_TIMEOUT_MS };
+  if (!targetRequiresAuth(target, runtime)) return ctx;
+  try {
+    const resolution = await openAuthStorage().resolveForTarget(resolveAuthTarget(target, runtime), {
+      includeFallback: false
+    });
+    if (resolution.apiKey) ctx.authToken = resolution.apiKey;
+  } catch {
+  }
+  return ctx;
+}
+async function probeAdvertisedModels(target, runtime) {
+  if (runtime.kind !== "http" || typeof runtime.probe !== "function" || !target.url) return null;
+  let probe;
+  try {
+    probe = await runtime.probe(target, await doctorProbeContext(target, runtime));
+  } catch {
+    return null;
+  }
+  if (!probe.ok || !probe.models || probe.models.length === 0) return null;
+  const advertised = [...probe.models];
+  const resident = [];
+  for (const [id, status] of Object.entries(probe.modelStates ?? {})) {
+    if (!advertised.includes(id)) advertised.push(id);
+    if (status.state === "loaded" || status.state === "loading") resident.push(id);
+  }
+  return { advertised, resident, cacheAdvisories: probe.cacheAdvisories ?? [] };
+}
+async function runDoctorModelChecks() {
+  let settings;
+  try {
+    settings = readSettings();
+  } catch {
+    return [];
+  }
+  if (settings.targets.length === 0) return [];
+  const [{ getRuntimeRegistry }, { registerBuiltinRuntimes }, { listKnownModelsForRuntime }] = await Promise.all([
+    import("./registry-37T4U6X2.js"),
+    import("./builtins-GDYO4RTR.js"),
+    import("./support-M3RCUUEL.js")
+  ]);
+  const registry = getRuntimeRegistry();
+  if (registry.list().length === 0) registerBuiltinRuntimes(registry);
+  const results = await Promise.all(
+    settings.targets.map(async (target) => {
+      const runtime = registry.get(target.runtime);
+      if (!runtime) return [];
+      if (listKnownModelsForRuntime(runtime.id).length > 0) return [];
+      const roles = configuredModelRoles(settings, target);
+      if (roles.length === 0) return [];
+      const live = await probeAdvertisedModels(target, runtime);
+      const cache = (live?.cacheAdvisories ?? []).map(
+        (detail) => ({ ok: true, level: "warn", name: `cache ${target.id}`, detail })
+      );
+      const recorded = target.wireModels ?? [];
+      if (live === null && recorded.length === 0) {
+        return [
+          {
+            ok: true,
+            level: "warn",
+            name: `model ${target.id}`,
+            detail: `${roles.map((entry) => `${entry.role} '${entry.model}'`).join(", ")} could not be verified: the target did not answer and configure recorded no model list; run \`clio-coder targets --probe\` once it is up`
+          }
+        ];
+      }
+      const advertised = live ? live.advertised : recorded;
+      const source = live ? `advertised by ${target.url ?? target.id} now` : "recorded by configure at last save";
+      const missing = roles.filter((entry) => !advertised.includes(entry.model));
+      if (missing.length === 0) {
+        return [
+          {
+            ok: true,
+            name: `model ${target.id}`,
+            detail: `${roles.map((entry) => `${entry.role} '${entry.model}'`).join(", ")} ${source}`
+          },
+          ...cache
+        ];
+      }
+      const resident = live && live.resident.length > 0 ? live.resident.join(", ") : live ? "none" : "unknown";
+      return [
+        {
+          ok: false,
+          name: `model ${target.id}`,
+          detail: `${missing.map((entry) => `${entry.role} '${entry.model}'`).join(", ")} not ${source} (${advertised.length} ids). Resident instances: ${resident}. Re-run \`clio-coder configure --id ${target.id} --model <advertised id>\`; \`clio-coder targets --probe\` lists them`
+        },
+        ...cache
+      ];
+    })
+  );
+  return results.flat();
+}
+
+export {
+  isUninitializedHome,
+  runDoctor,
+  formatDoctorReport,
+  runDoctorFleetChecks,
+  runDoctorInteropChecks,
+  runDoctorRuntimeChecks,
+  runDoctorModelChecks
+};
+//# sourceMappingURL=chunk-IN7DGBVS.js.map