@iowarp/clio-coder 0.4.2 → 0.4.3

package/dist/{trace-YMGMUM6A.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,
@@ -11,23 +15,19 @@ import {
   resolveTraceRetentionPolicy,
   traceDatabasePath
 } from "./chunk-VKPAQYEB.js";
-import {
-  codeStepDir,
-  readCodeStepRecords
-} from "./chunk-KPXDY6QF.js";
 import {
   sanitizeCallTargetText
 } from "./chunk-NEDJ26B5.js";
 import "./chunk-4BJ5BYCE.js";
-import "./chunk-MQXIVJ35.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";
-import "./chunk-WEPFGWHJ.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -568,4 +568,4 @@ function jsonBigInt(_key, value) {
 export {
   runTraceCommand
 };
-//# sourceMappingURL=trace-YMGMUM6A.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