@iowarp/clio-coder 0.3.0

package/dist/trace-7NYCUI2J.js

@@ -0,0 +1,250 @@
+import {
+  TRACE_EVENT_POLL_LIMIT,
+  TraceReader,
+  traceDatabasePath
+} from "./chunk-E3NYWENM.js";
+import {
+  clioStatePath
+} from "./chunk-X3NE4WVW.js";
+
+// src/cli/trace.ts
+import { existsSync } from "node:fs";
+import { access } from "node:fs/promises";
+import { resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var HELP = `Usage:
+  clio-coder trace runs [--db PATH] [--limit N]
+  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 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.
+`;
+function parseTraceArgs(args) {
+  const positional = [];
+  let db = traceDatabasePath(clioStatePath());
+  let dbExplicit = false;
+  let follow = false;
+  let limit = 50;
+  let port = 0;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--follow") follow = true;
+    else if (arg === "--db" || arg === "--limit" || arg === "--port") {
+      const value = args[index + 1];
+      if (value === void 0) throw new Error(`${arg} requires a value`);
+      index += 1;
+      if (arg === "--db") {
+        db = resolve(value);
+        dbExplicit = true;
+      } else if (arg === "--limit") limit = parseInteger(value, "--limit", 1, 500);
+      else port = parseInteger(value, "--port", 0, 65535);
+    } else if (arg?.startsWith("--db=")) {
+      db = resolve(arg.slice(5));
+      dbExplicit = true;
+    } else if (arg?.startsWith("--limit=")) limit = parseInteger(arg.slice(8), "--limit", 1, 500);
+    else if (arg?.startsWith("--port=")) port = parseInteger(arg.slice(7), "--port", 0, 65535);
+    else if (arg?.startsWith("-")) throw new Error(`unknown trace flag: ${arg}`);
+    else if (arg !== void 0) positional.push(arg);
+  }
+  return { positional, db, dbExplicit, follow, limit, port };
+}
+async function runTraceCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  let parsed;
+  try {
+    parsed = parseTraceArgs(args);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+${HELP}`);
+    return 2;
+  }
+  const [command, runId] = parsed.positional;
+  if (!command || command === "help") {
+    process.stdout.write(HELP);
+    return command === "help" ? 0 : 2;
+  }
+  if (command === "ui") return runTraceUi(parsed.db, parsed.port);
+  if (!existsSync(parsed.db)) return missingDatabase(parsed);
+  let reader;
+  try {
+    reader = new TraceReader(parsed.db);
+  } catch (error) {
+    process.stderr.write(`trace database: ${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  }
+  try {
+    switch (command) {
+      case "runs":
+        printRuns(reader.runs(parsed.limit));
+        return 0;
+      case "phases":
+        if (!runId) return missingRunId(command);
+        printPhases(reader.phases(runId));
+        return 0;
+      case "tail":
+        if (!runId) return missingRunId(command);
+        await tail(reader, runId, parsed.follow);
+        return 0;
+      case "procs":
+        if (!runId) return missingRunId(command);
+        printProcesses(reader.processes(runId));
+        return 0;
+      case "sql": {
+        const query = parsed.positional.slice(1).join(" ");
+        if (!query) {
+          process.stderr.write("trace sql requires a SELECT query\n");
+          return 2;
+        }
+        process.stdout.write(`${JSON.stringify(reader.select(query), jsonBigInt, 2)}
+`);
+        return 0;
+      }
+      default:
+        process.stderr.write(`unknown trace command: ${command}
+${HELP}`);
+        return 2;
+    }
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+    return 1;
+  } finally {
+    reader.close();
+  }
+}
+async function tail(reader, runId, follow) {
+  let cursor = 0;
+  let idleTerminalPolls = 0;
+  for (; ; ) {
+    const rows = reader.events(runId, cursor, TRACE_EVENT_POLL_LIMIT);
+    for (const row of rows) {
+      process.stdout.write(`${formatEvent(row)}
+`);
+      cursor = Math.max(cursor, row.rowid);
+    }
+    if (!follow) return;
+    const status = reader.run(runId)?.status;
+    idleTerminalPolls = rows.length === 0 && status !== "queued" && status !== "running" ? idleTerminalPolls + 1 : 0;
+    if (idleTerminalPolls >= 2) return;
+    await new Promise((resolveWait) => setTimeout(resolveWait, 500));
+  }
+}
+function formatEvent(row) {
+  const duration = row.ended_at === null ? "" : ` ${Math.max(0, Date.parse(row.ended_at) - Date.parse(row.started_at))}ms`;
+  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");
+  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}
+`
+    );
+  }
+}
+function printPhases(rows) {
+  process.stdout.write("STATUS   TRY OWNER              TOKENS       COST PHASE\n");
+  for (const row of rows) {
+    process.stdout.write(
+      `${row.status.padEnd(8)} ${String(row.attempt + 1).padStart(3)} ${row.owner.slice(0, 18).padEnd(18)} ${formatNumber(row.total_tokens).padStart(8)} ${formatCost(row.total_cost_usd).padStart(10)} ${row.name}
+`
+    );
+  }
+}
+function printProcesses(rows) {
+  process.stdout.write("STATE  PID      KIND         NAME                 COMMAND\n");
+  for (const row of rows) {
+    process.stdout.write(
+      `${(row.ended_at === null ? "live" : "ended").padEnd(6)} ${String(row.pid).padEnd(8)} ${row.kind.padEnd(12)} ${row.name.slice(0, 20).padEnd(20)} ${row.command}
+`
+    );
+  }
+}
+async function runTraceUi(db, port) {
+  const candidates = [
+    fileURLToPath(new URL("../apps/trace-viewer/server.mjs", import.meta.url)),
+    fileURLToPath(new URL("../../apps/trace-viewer/server.mjs", import.meta.url))
+  ];
+  const entry = await firstExisting(candidates);
+  if (entry === null) {
+    process.stderr.write(
+      `trace viewer is available only from a source checkout; apps/trace-viewer/server.mjs was not found
+  the npm package does not carry the viewer, so an installed clio cannot start it
+  the same run is readable here: clio-coder trace runs --db ${db}
+  from a checkout of the repository: npm run trace:ui
+`
+    );
+    return 1;
+  }
+  const module = await import(pathToFileURL(entry).href);
+  const server = await module.startTraceViewer({ db, port });
+  process.stdout.write(`Trace viewer: ${server.url}
+`);
+  await new Promise((resolveStop) => {
+    const stop = () => {
+      process.off("SIGINT", stop);
+      process.off("SIGTERM", stop);
+      void server.close().finally(resolveStop);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+  });
+  return 0;
+}
+async function firstExisting(paths) {
+  for (const path of paths) {
+    try {
+      await access(path);
+      return path;
+    } catch {
+    }
+  }
+  return null;
+}
+function parseInteger(value, flag, min, max) {
+  const parsed = Number(value);
+  if (!Number.isInteger(parsed) || parsed < min || parsed > max)
+    throw new Error(`${flag} must be an integer in [${min}, ${max}]`);
+  return parsed;
+}
+function missingDatabase(parsed) {
+  if (parsed.dbExplicit) {
+    process.stderr.write(
+      `trace database not found: ${parsed.db}
+  --db named this path. omit it to read the default at ${traceDatabasePath(clioStatePath())}
+`
+    );
+    return 1;
+  }
+  process.stdout.write(
+    `no trace database yet at ${parsed.db}. rows are recorded when a dispatch executes or an interactive turn runs; run \`clio-coder run "<task>"\` or start a session to create one.
+`
+  );
+  return 0;
+}
+function missingRunId(command) {
+  process.stderr.write(`trace ${command} requires a run id
+`);
+  return 2;
+}
+function formatNumber(value) {
+  return value === null ? "\u2014" : value.toLocaleString("en-US");
+}
+function formatCost(value) {
+  return value === null ? "\u2014" : `$${value.toFixed(value < 0.01 ? 4 : 2)}`;
+}
+function jsonBigInt(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+export {
+  runTraceCommand
+};
+//# sourceMappingURL=trace-7NYCUI2J.js.map

package/dist/uninstall-AD3JWHBB.js

@@ -0,0 +1,322 @@
+import {
+  removePath,
+  reportRemovalFailures
+} from "./chunk-HBU5MTAM.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printHeader,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  resetXdgCache,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+import {
+  resolvePackageRoot
+} from "./chunk-DXQNI4PC.js";
+
+// src/cli/uninstall.ts
+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] [--dry-run] [--force]
+
+Remove all Clio Coder state: the config, data, state, and cache roots.
+
+Per-project \`.clio-coder/\` directories are outside those roots and are never removed
+here. Every project Clio has run in is recorded in the session metadata, so both
+the real run and --dry-run list them and name the command that clears one,
+before the launcher is touched.
+
+Flags:
+  --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          required for destructive execution
+`;
+function parseUninstallArgs(argv) {
+  const parsed = {
+    removeBinary: false,
+    force: false,
+    dryRun: false,
+    help: false
+  };
+  for (const arg of argv) {
+    switch (arg) {
+      case "--remove-binary":
+        parsed.removeBinary = true;
+        break;
+      case "--force":
+      case "-f":
+        parsed.force = true;
+        break;
+      case "--dry-run":
+        parsed.dryRun = true;
+        break;
+      case "--help":
+      case "-h":
+        parsed.help = true;
+        break;
+      default:
+        throw new Error(`unknown flag: ${arg}`);
+    }
+  }
+  return parsed;
+}
+function report(label, path) {
+  process.stdout.write(`  ${label.padEnd(8)} remove ${path}${existsSync(path) ? "" : "  (absent)"}
+`);
+}
+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 reportProjectContext(inventory, removeBinary) {
+  process.stdout.write("\nPer-project context (not removed by uninstall):\n");
+  if (inventory.storeAbsent) {
+    process.stdout.write("  no session store to read; any .clio-coder/ directories must be found by hand\n");
+    return;
+  }
+  if (inventory.dirs.length === 0) {
+    process.stdout.write(
+      `  none: ${inventory.recorded} project director${inventory.recorded === 1 ? "y" : "ies"} recorded, none still has a .clio-coder/
+`
+    );
+    return;
+  }
+  for (const dir of inventory.dirs) process.stdout.write(`  ${join(dir, ".clio-coder")}
+`);
+  process.stdout.write(
+    removeBinary ? "\nThis run also removes the launcher. Clear each one from inside it first, then re-run:\n" : "\nClear each one from inside it, while clio still runs:\n"
+  );
+  process.stdout.write("  clio-coder context reset --all\n\n");
+}
+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 removeLauncher(dryRun) {
+  const linkPath = launcherLinkPath();
+  const verdict = classifyLauncher(linkPath);
+  if (verdict.kind === "absent") {
+    process.stdout.write(`  binary   absent ${linkPath}
+`);
+    return null;
+  }
+  if (verdict.kind === "keep") {
+    process.stdout.write(`  binary   keep   ${linkPath} (${verdict.detail})
+`);
+    return null;
+  }
+  process.stdout.write(`  binary   remove ${linkPath} ${verdict.detail}
+`);
+  return removePath("binary", linkPath, dryRun);
+}
+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"],
+      // A read-only probe that writes. npm drops a debug log into
+      // $HOME/.npm/_logs on every invocation, so the documented
+      // side-effect-free `--dry-run` path left a file behind in the home
+      // directory it had just finished promising not to touch. `logs-max=0`
+      // keeps npm from retaining any; the notifier is off for the same reason.
+      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 printRemovalGuidance(removeBinaryRequested) {
+  const pathClio = findClioOnPath();
+  const npmPrefix = readNpmPrefix();
+  const localLink = launcherLinkPath();
+  const currentLauncher = process.argv[1];
+  process.stdout.write("\nBinary removal guidance:\n");
+  if (currentLauncher) process.stdout.write(`  current launcher: ${currentLauncher}
+`);
+  process.stdout.write(`  PATH lookup:      ${pathClio ?? "not currently found"}
+`);
+  if (npmPrefix) process.stdout.write(`  npm prefix bin:   ${join(npmPrefix, "bin")}
+`);
+  process.stdout.write(`  local source bin: ${localLink}${existsSync(localLink) ? "" : "  (absent)"}
+`);
+  const survivor = otherClioOnPath(pathClio, localLink);
+  if (survivor !== null) {
+    process.stdout.write(`
+another clio-coder remains on your PATH at ${survivor}
+`);
+    process.stdout.write("  it is a different installation from the one this uninstall touched\n");
+    process.stdout.write(`  check it with: ${survivor} --version
+`);
+  }
+  process.stdout.write("\nUse the removal path that matches how you installed Clio Coder:\n");
+  if (!removeBinaryRequested) {
+    process.stdout.write("  source symlink:  clio-coder uninstall --remove-binary --force\n");
+  }
+  process.stdout.write("  npm global:      npm uninstall -g @iowarp/clio-coder\n");
+  process.stdout.write("  npm link:        npm unlink -g @iowarp/clio-coder\n");
+  process.stdout.write("\nAfter removing or replacing a clio-coder link, clear shell command caches:\n");
+  process.stdout.write("  hash -r   # Bash\n");
+  process.stdout.write("  rehash    # Zsh\n");
+}
+function runUninstallCommand(argv) {
+  let args;
+  try {
+    args = parseUninstallArgs(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stdout.write(HELP);
+    return 2;
+  }
+  if (args.help) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  if (!args.dryRun && !args.force) {
+    printError("`clio-coder uninstall` requires --force unless you are using --dry-run");
+    process.stdout.write(HELP);
+    return 2;
+  }
+  const dirs = resolveClioDirs();
+  printHeader("Clio Coder uninstall");
+  const roots = [
+    ["config", dirs.config],
+    ["data", dirs.data],
+    ["state", dirs.state],
+    ["cache", dirs.cache]
+  ];
+  for (const [label, path] of roots) report(label, path);
+  reportProjectContext(projectContextInventory(dirs.state), args.removeBinary);
+  const failures = [];
+  for (const [label, path] of roots) {
+    const failure = removePath(label, path, args.dryRun);
+    if (failure) failures.push(failure);
+  }
+  if (args.removeBinary) {
+    const failure = removeLauncher(args.dryRun);
+    if (failure) failures.push(failure);
+  }
+  resetXdgCache();
+  if (failures.length > 0) {
+    printError("uninstall did not remove everything");
+    reportRemovalFailures(`clio-coder uninstall${args.removeBinary ? " --remove-binary" : ""} --force`, failures);
+    return 1;
+  }
+  printOk(args.dryRun ? "uninstall preview complete" : "removed Clio Coder state");
+  printRemovalGuidance(args.removeBinary);
+  return 0;
+}
+export {
+  otherClioOnPath,
+  projectContextInventory,
+  runUninstallCommand
+};
+//# sourceMappingURL=uninstall-AD3JWHBB.js.map