@iowarp/clio-coder 0.4.1 → 0.4.3

package/dist/{tools-MKNWVPBH.js → tools-TFGJICCU.js}

@@ -1,29 +1,29 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   runToolsCommand
-} from "./chunk-BJGUKIG4.js";
-import "./chunk-K6BF4U2H.js";
+} from "./chunk-7ZYNNDKC.js";
+import "./chunk-KKOJXO6R.js";
 import "./chunk-HRQMFLJP.js";
-import "./chunk-J5LZHVIT.js";
-import "./chunk-D4CJV46V.js";
+import "./chunk-3M6DQK6S.js";
 import "./chunk-LCGCVYZ4.js";
-import "./chunk-QSNYB6ZV.js";
-import "./chunk-QDC3K2U3.js";
-import "./chunk-ZW55JB7N.js";
+import "./chunk-D4CJV46V.js";
+import "./chunk-PUVDKJ2Y.js";
 import "./chunk-VPKWYKEY.js";
 import "./chunk-5TSRNF4G.js";
+import "./chunk-QSNYB6ZV.js";
+import "./chunk-QDC3K2U3.js";
 import "./chunk-D7E7WCDF.js";
 import "./chunk-IWHMRKLL.js";
-import "./chunk-WNP7O5WZ.js";
+import "./chunk-ID64D7PE.js";
 import "./chunk-336NSSKI.js";
 import "./chunk-IKCO5N3L.js";
 import "./chunk-3I7MS7N2.js";
 import "./chunk-APJ265NV.js";
-import "./chunk-BYP5D4HI.js";
 import "./chunk-WEPFGWHJ.js";
 import "./chunk-YXLYO42X.js";
+import "./chunk-BYP5D4HI.js";
 import "./chunk-3R73A4XB.js";
 export {
   runToolsCommand
 };
-//# sourceMappingURL=tools-MKNWVPBH.js.map
+//# sourceMappingURL=tools-TFGJICCU.js.map

package/dist/{trace-ECQ7TIYZ.js → trace-FXMXUZUF.js}

@@ -2,6 +2,10 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   truncateToWidth
 } from "./chunk-YAKGTXEV.js";
+import {
+  codeStepDir,
+  readCodeStepRecords
+} from "./chunk-XRZT5WY5.js";
 import {
   DEFAULT_TRACE_RETENTION_POLICY,
   TRACE_EVENT_POLL_LIMIT,
@@ -10,13 +14,17 @@ import {
   assertTraceSelectOnly,
   resolveTraceRetentionPolicy,
   traceDatabasePath
-} from "./chunk-ZAZB4JMW.js";
+} from "./chunk-VKPAQYEB.js";
 import {
   sanitizeCallTargetText
-} from "./chunk-TVHHYFHE.js";
+} from "./chunk-NEDJ26B5.js";
 import "./chunk-4BJ5BYCE.js";
+import "./chunk-HAXOFFRH.js";
+import "./chunk-R346GLFC.js";
 import "./chunk-BTK3SSSK.js";
+import "./chunk-IWHMRKLL.js";
 import "./chunk-3I7MS7N2.js";
+import "./chunk-WEPFGWHJ.js";
 import {
   clioStatePath
 } from "./chunk-BYP5D4HI.js";
@@ -165,12 +173,16 @@ var HELP = `Usage:
   clio-coder trace phases <runId> [--db PATH]
   clio-coder trace tail <runId> [--follow] [--db PATH]
   clio-coder trace procs <runId> [--db PATH]
+  clio-coder trace code-steps <rootId> [--json]   deterministic code steps of one fleet root
   clio-coder trace prune [--max-age-days N] [--max-bytes N] [--db PATH] [--json]
   clio-coder trace sql <SELECT query> [--db PATH]
   clio-coder trace ui [--db PATH] [--port N]        source checkout only
 
 The viewer ships with the repository, not the npm package, so from an installed
-Clio the subcommands above are the way in. They read the same database.
+Clio the subcommands above are the way in. They read the same database, except
+code-steps, which reads the per-root record files under the state directory's
+code-steps/ tree (a code step is a subprocess, not a model run, so it never
+enters the SQLite mirror).
 Pruning keeps ${DEFAULT_TRACE_RETENTION_POLICY.maxAgeDays} days and at most ${DEFAULT_TRACE_RETENTION_POLICY.maxBytes} bytes by default. Set
 CLIO_CODER_TRACE_RETENTION_DAYS or CLIO_CODER_TRACE_MAX_BYTES to change the automatic
 policy; prune flags override those values for one command.
@@ -214,7 +226,7 @@ function parseTraceArgs(args) {
   }
   return { positional, db, dbExplicit, follow, limit, port, json, maxAgeDays, maxBytes };
 }
-var TRACE_COMMANDS = /* @__PURE__ */ new Set(["runs", "inspect", "phases", "tail", "procs", "prune", "sql", "ui"]);
+var TRACE_COMMANDS = /* @__PURE__ */ new Set(["runs", "inspect", "phases", "tail", "procs", "code-steps", "prune", "sql", "ui"]);
 var TRACE_COMMANDS_NEEDING_RUN_ID = /* @__PURE__ */ new Set(["phases", "tail", "procs"]);
 function invocationError(command, runId) {
   if (!TRACE_COMMANDS.has(command)) {
@@ -223,6 +235,10 @@ ${HELP}`);
     return 2;
   }
   if (TRACE_COMMANDS_NEEDING_RUN_ID.has(command) && !runId) return missingRunId(command);
+  if (command === "code-steps" && !runId) {
+    process.stderr.write("trace code-steps requires a fleet root id\n");
+    return 2;
+  }
   return null;
 }
 async function runTraceCommand(args) {
@@ -260,6 +276,7 @@ ${HELP}`);
     }
   }
   if (command === "ui") return runTraceUi(parsed.db, parsed.port);
+  if (command === "code-steps") return runTraceCodeSteps(runId ?? "", parsed.json);
   if (command === "inspect") {
     return runTraceInspect(
       parsed.positional.length === 1 && parsed.json && !parsed.dbExplicit && !parsed.follow && parsed.limit === DEFAULT_TRACE_LIMIT && parsed.port === 0 && parsed.maxAgeDays === void 0 && parsed.maxBytes === void 0
@@ -319,6 +336,37 @@ ${HELP}`);
     reader.close();
   }
 }
+function runTraceCodeSteps(rootId, json) {
+  let records;
+  try {
+    records = readCodeStepRecords(rootId);
+  } catch (error) {
+    process.stderr.write(`code-step records: ${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+  if (json) {
+    process.stdout.write(`${JSON.stringify(records, null, 2)}
+`);
+    return 0;
+  }
+  if (records.length === 0) {
+    process.stdout.write(
+      `no code-step records for fleet root ${rootId} under ${codeStepDir(rootId)}. a record is written when a fleet plan runs a deterministic code step.
+`
+    );
+    return 0;
+  }
+  process.stdout.write("EXIT  DURATION STARTED                  STEP                 COMMAND              ARGV\n");
+  for (const record of records) {
+    const exit = record.timedOut ? "timeout" : record.signal !== null ? `sig:${record.signal}` : String(record.exitCode);
+    process.stdout.write(
+      `${exit.padEnd(5)} ${`${record.durationMs}ms`.padStart(8)} ${record.startedAt.padEnd(24)} ${record.stepId.slice(0, 20).padEnd(20)} ${record.commandId.slice(0, 20).padEnd(20)} ${record.argv.join(" ")}
+`
+    );
+  }
+  return 0;
+}
 function runTracePrune(parsed) {
   let policy;
   try {
@@ -381,10 +429,10 @@ function formatEvent(row) {
   return `${row.rowid.toString().padStart(6)} ${row.started_at} ${row.type.padEnd(18)} ${row.name}${duration}`;
 }
 function printRuns(rows) {
-  process.stdout.write("STATUS   STARTED                      TOKENS       COST RUN\n");
+  process.stdout.write("STATUS   SOURCE   STARTED                      TOKENS       COST RUN\n");
   for (const row of rows) {
     process.stdout.write(
-      `${row.status.padEnd(8)} ${row.started_at.padEnd(28)} ${formatNumber(row.total_tokens).padStart(8)} ${formatCost(row.total_cost_usd).padStart(10)} ${row.run_id}
+      `${row.status.padEnd(8)} ${row.source.padEnd(8)} ${row.started_at.padEnd(28)} ${formatNumber(row.total_tokens).padStart(8)} ${formatCost(row.total_cost_usd).padStart(10)} ${row.run_id}
 `
     );
   }
@@ -520,4 +568,4 @@ function jsonBigInt(_key, value) {
 export {
   runTraceCommand
 };
-//# sourceMappingURL=trace-ECQ7TIYZ.js.map
+//# sourceMappingURL=trace-FXMXUZUF.js.map

package/dist/uninstall-5PEVOE5B.js

@@ -0,0 +1,408 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  removePath,
+  reportRemovalFailures
+} from "./chunk-SVNXH4L2.js";
+import {
+  detectInstallMethod
+} from "./chunk-UOIZ7DA4.js";
+import {
+  createLifecyclePresenter,
+  measurePath,
+  shortenPath
+} from "./chunk-SKHCAU7K.js";
+import "./chunk-2IR2NMPA.js";
+import "./chunk-PUVDKJ2Y.js";
+import {
+  printError
+} from "./chunk-VPKWYKEY.js";
+import "./chunk-5TSRNF4G.js";
+import {
+  resolvePackageRoot
+} from "./chunk-IWHMRKLL.js";
+import "./chunk-ID64D7PE.js";
+import "./chunk-336NSSKI.js";
+import "./chunk-IKCO5N3L.js";
+import "./chunk-3I7MS7N2.js";
+import "./chunk-APJ265NV.js";
+import "./chunk-WEPFGWHJ.js";
+import "./chunk-YXLYO42X.js";
+import {
+  resetXdgCache,
+  resolveClioDirs
+} from "./chunk-BYP5D4HI.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/uninstall.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, dirname, isAbsolute, join, resolve, sep } from "node:path";
+var HELP = `clio-coder uninstall [--remove-binary] [--keep-config] [--keep-data] [--dry-run] [--force] [--json]
+
+Remove all Clio Coder state: the config, data, state, and cache roots.
+
+Per-project \`.clio-coder/\` directories sit outside those roots and are never
+removed here. Every project Clio has run in is recorded in the session metadata,
+so the real run and --dry-run both list them and name the command that clears one.
+Shell startup files are reported, never edited.
+
+Flags:
+  --keep-config    preserve the configuration root (settings.yaml, credentials)
+  --keep-data      preserve the data root (memory, evidence, vendored tools)
+  --remove-binary  also remove the launcher symlink when it points at this
+                   installation. A real file, or a link into a different clio-coder
+                   installation, is kept and reported.
+  --dry-run        print what would be removed without changing anything
+  --force, -f      skip confirmation prompt and proceed immediately
+  --json           emit machine-readable JSON output
+  --help, -h       show this message
+`;
+function parseUninstallArgs(argv) {
+  const parsed = {
+    removeBinary: false,
+    keepConfig: false,
+    keepData: false,
+    force: false,
+    dryRun: false,
+    json: false,
+    help: false
+  };
+  for (const arg of argv) {
+    switch (arg) {
+      case "--remove-binary":
+        parsed.removeBinary = true;
+        break;
+      case "--keep-config":
+        parsed.keepConfig = true;
+        break;
+      case "--keep-data":
+        parsed.keepData = true;
+        break;
+      case "--force":
+      case "-f":
+        parsed.force = true;
+        break;
+      case "--dry-run":
+        parsed.dryRun = true;
+        break;
+      case "--json":
+        parsed.json = true;
+        break;
+      case "--help":
+      case "-h":
+        parsed.help = true;
+        break;
+      default:
+        throw new Error(`unknown flag: ${arg}`);
+    }
+  }
+  return parsed;
+}
+function projectContextInventory(stateDir) {
+  const root = join(stateDir, "sessions");
+  let hashes;
+  try {
+    hashes = readdirSync(root);
+  } catch {
+    return { recorded: 0, dirs: [], storeAbsent: true };
+  }
+  const dirs = /* @__PURE__ */ new Set();
+  let recorded = 0;
+  for (const hash of hashes.sort()) {
+    const cwd = firstRecordedCwd(join(root, hash));
+    if (cwd === null) continue;
+    recorded += 1;
+    if (existsSync(join(cwd, ".clio-coder"))) dirs.add(cwd);
+  }
+  return { recorded, dirs: [...dirs].sort(), storeAbsent: false };
+}
+function firstRecordedCwd(hashDir) {
+  let sessions;
+  try {
+    sessions = readdirSync(hashDir);
+  } catch {
+    return null;
+  }
+  for (const session of sessions.sort()) {
+    try {
+      const meta = JSON.parse(readFileSync(join(hashDir, session, "meta.json"), "utf8"));
+      if (typeof meta.cwd === "string" && meta.cwd.length > 0) return meta.cwd;
+    } catch {
+    }
+  }
+  return null;
+}
+function launcherLinkPath() {
+  const binDir = process.env.CLIO_CODER_BIN_DIR?.trim() || join(homedir(), ".local", "bin");
+  return join(binDir, "clio-coder");
+}
+function ownedCliEntry() {
+  const entry = join(resolvePackageRoot(), "dist", "cli", "index.js");
+  try {
+    return realpathSync(entry);
+  } catch {
+    return entry;
+  }
+}
+function classifyLauncher(linkPath) {
+  let isSymlink;
+  try {
+    isSymlink = lstatSync(linkPath).isSymbolicLink();
+  } catch {
+    return { kind: "absent" };
+  }
+  if (!isSymlink) {
+    return { kind: "keep", detail: "not a symlink; remove it via your package manager" };
+  }
+  const owned = ownedCliEntry();
+  let resolved = null;
+  try {
+    resolved = realpathSync(linkPath);
+  } catch {
+    resolved = null;
+  }
+  if (resolved !== null) {
+    if (resolved === owned) return { kind: "remove", detail: `-> ${resolved}` };
+    return {
+      kind: "keep",
+      detail: `points at ${resolved}, not this installation (${owned}); remove it with \`rm ${linkPath}\``
+    };
+  }
+  const raw = readlinkSync(linkPath);
+  const danglingTarget = isAbsolute(raw) ? raw : resolve(dirname(linkPath), raw);
+  if (danglingTarget.endsWith(join(sep, "dist", "cli", "index.js"))) {
+    return { kind: "remove", detail: `-> ${danglingTarget} (dangling; that installation is already gone)` };
+  }
+  return {
+    kind: "keep",
+    detail: `dangling link to ${danglingTarget}, which is not a clio entry; remove it with \`rm ${linkPath}\``
+  };
+}
+function findClioOnPath() {
+  const names = process.platform === "win32" ? ["clio-coder.cmd", "clio-coder.ps1", "clio-coder.exe", "clio-coder"] : ["clio-coder"];
+  for (const dir of (process.env.PATH ?? "").split(delimiter)) {
+    if (!dir) continue;
+    for (const name of names) {
+      const candidate = join(dir, name);
+      if (existsSync(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+function readNpmPrefix() {
+  try {
+    const result = spawnSync("npm", ["config", "get", "prefix"], {
+      encoding: "utf8",
+      timeout: 5e3,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, npm_config_logs_max: "0", npm_config_update_notifier: "false" }
+    });
+    if (result.status !== 0) return null;
+    const prefix = result.stdout.trim();
+    return prefix.length > 0 ? prefix : null;
+  } catch {
+    return null;
+  }
+}
+function otherClioOnPath(pathClio, localLink) {
+  if (pathClio === null) return null;
+  if (pathClio === localLink) return null;
+  const resolve2 = (path) => {
+    try {
+      return realpathSync(path);
+    } catch {
+      return null;
+    }
+  };
+  const resolvedPathClio = resolve2(pathClio);
+  if (resolvedPathClio !== null && resolvedPathClio === resolve2(localLink)) return null;
+  return pathClio;
+}
+function detectShellRcEdits() {
+  const candidates = [join(homedir(), ".bashrc"), join(homedir(), ".zshrc"), join(homedir(), ".profile")];
+  const results = [];
+  for (const file of candidates) {
+    try {
+      const content = readFileSync(file, "utf8");
+      if (content.includes("clio-coder") || content.includes("CLIO_CODER")) results.push(file);
+    } catch {
+    }
+  }
+  return results;
+}
+function survivingClioOnPath(localLink) {
+  return otherClioOnPath(findClioOnPath(), localLink);
+}
+function launcherItemStatus(verdict, removeRequested) {
+  if (verdict.kind === "absent") return "absent";
+  if (verdict.kind === "keep") return "skip";
+  return removeRequested ? "remove" : "skip";
+}
+function launcherItemDetail(verdict, removeRequested) {
+  if (verdict.kind === "absent") return void 0;
+  if (verdict.kind === "keep") return verdict.detail;
+  return removeRequested ? void 0 : "kept; --remove-binary unlinks it";
+}
+function binaryRemovalAdvice(method, linkPath) {
+  if (method === "npm") {
+    const prefix = readNpmPrefix();
+    return {
+      lead: prefix === null ? "To remove the launcher, run:" : `To remove the launcher from ${join(prefix, "bin")}, run:`,
+      command: "npm uninstall -g @iowarp/clio-coder\nhash -r"
+    };
+  }
+  return { lead: "To finish removing the launcher, run:", command: `rm "${linkPath}"
+hash -r` };
+}
+async function runUninstallCommand(argv) {
+  let args;
+  try {
+    args = parseUninstallArgs(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const isInteractive = Boolean(process.stdin.isTTY);
+  if (!args.dryRun && !args.force && !isInteractive) {
+    printError("`clio-coder uninstall` needs a terminal to confirm; pass --force to skip the prompt");
+    return 2;
+  }
+  const dirs = resolveClioDirs();
+  const method = detectInstallMethod();
+  const presenter = createLifecyclePresenter({ json: args.json });
+  presenter.header("Uninstall Clio Coder", "uninstall");
+  presenter.step(`Installation method: ${method === "source" ? "source symlink" : "npm global"}`);
+  const configSize = measurePath(dirs.config);
+  const dataSize = measurePath(dirs.data);
+  const stateSize = measurePath(dirs.state);
+  const cacheSize = measurePath(dirs.cache);
+  const linkPath = launcherLinkPath();
+  const linkSize = measurePath(linkPath);
+  const launcher = classifyLauncher(linkPath);
+  const shellEdits = detectShellRcEdits();
+  const items = [
+    {
+      label: "Data",
+      path: dirs.data,
+      bytes: dataSize.bytes,
+      status: args.keepData ? "keep" : dataSize.exists ? "remove" : "absent",
+      detail: args.keepData ? "kept by --keep-data" : void 0
+    },
+    {
+      label: "Cache",
+      path: dirs.cache,
+      bytes: cacheSize.bytes,
+      status: cacheSize.exists ? "remove" : "absent"
+    },
+    {
+      label: "Config",
+      path: dirs.config,
+      bytes: configSize.bytes,
+      status: args.keepConfig ? "keep" : configSize.exists ? "remove" : "absent",
+      detail: args.keepConfig ? "kept by --keep-config" : void 0
+    },
+    {
+      label: "State",
+      path: dirs.state,
+      bytes: stateSize.bytes,
+      status: stateSize.exists ? "remove" : "absent",
+      detail: stateSize.exists ? "sessions, audit, receipts" : void 0
+    },
+    {
+      label: "Launcher",
+      path: linkPath,
+      bytes: linkSize.bytes,
+      status: launcherItemStatus(launcher, args.removeBinary),
+      detail: launcherItemDetail(launcher, args.removeBinary)
+    }
+  ];
+  for (const file of shellEdits) {
+    items.push({ label: "Shell config", path: file, status: "skip", detail: "mentions clio-coder; edit it by hand" });
+  }
+  presenter.listItems("The following will be removed", items);
+  const projectInv = projectContextInventory(dirs.state);
+  if (projectInv.dirs.length > 0) {
+    presenter.note("Per-project context, which uninstall does not remove:");
+    for (const dir of projectInv.dirs) {
+      presenter.substep(shortenPath(join(dir, ".clio-coder")), "\u2013");
+    }
+    presenter.commandAdvice("To clear one, run inside that project:", "clio-coder context reset --all");
+  }
+  const survivor = survivingClioOnPath(linkPath);
+  const advice = binaryRemovalAdvice(method, linkPath);
+  if (args.dryRun) {
+    presenter.warn("Dry run: no changes made");
+    if (launcher.kind !== "absent" && !args.removeBinary) presenter.commandAdvice(advice.lead, advice.command);
+    if (survivor !== null)
+      presenter.warn(`Another clio-coder stays on your PATH at ${survivor}; it is a separate install`);
+    presenter.done("Done");
+    return 0;
+  }
+  if (!args.force) {
+    const confirmed = await presenter.confirm("Are you sure you want to uninstall?", false);
+    if (!confirmed) {
+      presenter.warn("Uninstall cancelled");
+      presenter.done("Cancelled");
+      return 0;
+    }
+  }
+  const failures = [];
+  if (cacheSize.exists) {
+    const failure = removePath("cache", dirs.cache, false);
+    if (failure) failures.push(failure);
+    else presenter.completedStep("Removed Cache");
+  }
+  if (!args.keepData && dataSize.exists) {
+    const failure = removePath("data", dirs.data, false);
+    if (failure) failures.push(failure);
+    else presenter.completedStep("Removed Data");
+  }
+  if (!args.keepConfig && configSize.exists) {
+    const failure = removePath("config", dirs.config, false);
+    if (failure) failures.push(failure);
+    else presenter.completedStep("Removed Config");
+  }
+  if (stateSize.exists) {
+    const failure = removePath("state", dirs.state, false);
+    if (failure) failures.push(failure);
+    else presenter.completedStep("Removed State");
+  }
+  let launcherRemoved = false;
+  if (args.removeBinary && launcher.kind === "remove") {
+    const failure = removePath("launcher", linkPath, false);
+    if (failure) failures.push(failure);
+    else {
+      presenter.completedStep("Removed launcher");
+      launcherRemoved = true;
+    }
+  }
+  resetXdgCache();
+  if (failures.length > 0) {
+    presenter.fail("uninstall did not remove everything");
+    reportRemovalFailures(
+      `clio-coder uninstall${args.removeBinary ? " --remove-binary" : ""}${args.keepConfig ? " --keep-config" : ""}${args.keepData ? " --keep-data" : ""} --force`,
+      failures
+    );
+    presenter.finish();
+    return 1;
+  }
+  if (launcher.kind !== "absent" && !launcherRemoved) presenter.commandAdvice(advice.lead, advice.command);
+  if (survivor !== null)
+    presenter.warn(`Another clio-coder stays on your PATH at ${survivor}; it is a separate install`);
+  presenter.message("Thank you for using Clio Coder.");
+  presenter.done("Done");
+  return 0;
+}
+export {
+  runUninstallCommand
+};
+//# sourceMappingURL=uninstall-5PEVOE5B.js.map