@iowarp/clio-coder 0.3.0

package/dist/chunk-7RBKDI66.js

@@ -0,0 +1,348 @@
+import {
+  getVersionInfo
+} from "./chunk-HMYNFFY4.js";
+import {
+  fingerprintNativeRuntime
+} from "./chunk-262G75JS.js";
+import {
+  initializeClioHome
+} from "./chunk-TFSSEXL6.js";
+import {
+  formatSettingsIssues,
+  readSettings,
+  validateSettingsFile
+} from "./chunk-JWHCJDCI.js";
+import {
+  openAuthStorage
+} from "./chunk-5LDRNKX2.js";
+import {
+  readSessionFileEntries
+} from "./chunk-UGYAX5YI.js";
+import {
+  clioStatePath,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+
+// src/domains/lifecycle/state.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+function readStateInfoResult() {
+  const path = join(clioStatePath(), "install.json");
+  try {
+    return { info: JSON.parse(readFileSync(path, "utf8")), problem: null };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") return { info: null, problem: null };
+    const message = error instanceof Error ? error.message : String(error);
+    return { info: null, problem: `${path} could not be read: ${message}` };
+  }
+}
+function readStateInfo() {
+  return readStateInfoResult().info;
+}
+function ensureClioState() {
+  initializeClioHome();
+  const info = readStateInfo();
+  if (!info) throw new Error("state metadata was not written by initializeClioHome()");
+  return info;
+}
+
+// src/domains/lifecycle/doctor.ts
+import { accessSync, chmodSync, constants, existsSync, readdirSync, statSync } from "node:fs";
+import { join as join2 } from "node:path";
+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 = join2(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 = join2(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 credentialsDamage() {
+  try {
+    return openAuthStorage().damageReason();
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function runDoctor(options = {}) {
+  let repairFailure = null;
+  if (options.fix) {
+    try {
+      initializeClioHome();
+      const credentialsPath = join2(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;
+  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 = join2(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 = join2(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}` : 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);
+  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 === "warn" ? "WARN" : "!! ";
+    return `${badge.padEnd(4)} ${f.name.padEnd(22)} ${foldDetail(f.detail)}`;
+  });
+  return lines.join("\n");
+}
+async function runDoctorFleetChecks(projectRoot = process.cwd()) {
+  let settings;
+  try {
+    settings = readSettings();
+  } catch {
+    return [];
+  }
+  const nodes = settings.fleet?.nodes ?? [];
+  if (nodes.length === 0) return [];
+  const { recordFleetPreflight, runFleetNodePreflight } = await import("./fleet-preflight-CLIAX7YR.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 })));
+  try {
+    recordFleetPreflight(records);
+  } catch {
+  }
+  return records.map((record) => ({
+    ok: true,
+    level: record.ok ? "ok" : "warn",
+    name: `fleet node ${record.nodeId}`,
+    detail: record.ok ? `eligible: ${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 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);
+}
+
+export {
+  readStateInfo,
+  ensureClioState,
+  runDoctor,
+  formatDoctorReport,
+  runDoctorFleetChecks,
+  runDoctorRuntimeChecks
+};
+//# sourceMappingURL=chunk-7RBKDI66.js.map