@iowarp/clio-coder 0.3.0

package/dist/paths-5OMXW7Z4.js

@@ -0,0 +1,57 @@
+import "./chunk-PIDUD6M2.js";
+import {
+  printError
+} from "./chunk-67MTHP2E.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+
+// src/cli/paths.ts
+import { existsSync } from "node:fs";
+var HELP = `clio-coder paths [--json]
+
+Print the resolved Clio Coder directories. Read-only: nothing is created.
+This is the single source of truth for scripts; parse the --json form instead
+of re-implementing the resolution rules.
+
+Resolution order per directory: CLIO_CODER_CONFIG_DIR / CLIO_CODER_DATA_DIR /
+CLIO_CODER_STATE_DIR / CLIO_CODER_CACHE_DIR beat CLIO_CODER_HOME, which beats the platform
+defaults (XDG base dirs on Linux).
+`;
+function runPathsCommand(args = []) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  const json = args.includes("--json");
+  const unknown = args.find((arg) => arg !== "--json");
+  if (unknown) {
+    printError(`unknown flag: ${unknown}`);
+    process.stderr.write(HELP);
+    return 2;
+  }
+  const dirs = resolveClioDirs();
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ config: dirs.config, data: dirs.data, state: dirs.state, cache: dirs.cache }, null, 2)}
+`
+    );
+    return 0;
+  }
+  for (const [label, path] of [
+    ["config", dirs.config],
+    ["data", dirs.data],
+    ["state", dirs.state],
+    ["cache", dirs.cache]
+  ]) {
+    process.stdout.write(`${label.padEnd(8)} ${path}${existsSync(path) ? "" : "  (absent)"}
+`);
+  }
+  return 0;
+}
+export {
+  runPathsCommand
+};
+//# sourceMappingURL=paths-5OMXW7Z4.js.map

package/dist/preload-KZVHET2B.js

@@ -0,0 +1,11 @@
+import {
+  FULL_PROJECT_CONTEXT_MAX_CHARS,
+  FULL_PROJECT_CONTEXT_MAX_LINES,
+  classifyProjectPreload
+} from "./chunk-KBR4MZZR.js";
+export {
+  FULL_PROJECT_CONTEXT_MAX_CHARS,
+  FULL_PROJECT_CONTEXT_MAX_LINES,
+  classifyProjectPreload
+};
+//# sourceMappingURL=preload-KZVHET2B.js.map

package/dist/reset-PIFYNOS3.js

@@ -0,0 +1,216 @@
+import {
+  removePath,
+  reportRemovalFailures
+} from "./chunk-HBU5MTAM.js";
+import {
+  terminalColumns,
+  wrapPlain
+} from "./chunk-ME6DNWIU.js";
+import {
+  initializeClioHome
+} from "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import {
+  printError,
+  printHeader,
+  printOk
+} from "./chunk-67MTHP2E.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-VPAWTYLY.js";
+import {
+  resetXdgCache,
+  resolveClioDirs
+} from "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/reset.ts
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+var HELP = `clio-coder reset [--state|--data|--cache|--auth|--config|--all] [--dry-run] [--force]
+
+Recover or wipe Clio Coder state while keeping the clio binary installed.
+Each level clears exactly the root (or file) it names and nothing else.
+
+Levels (combinable except --all):
+  --state       state root only (default). Holds every session transcript, so a
+                reset is the end of resume, /view, and the audit behind them.
+  --data        data root only: memory, evidence, evals (durable products)
+  --cache       cache root only
+  --auth        credentials.yaml only
+  --config      settings.yaml only
+  --all         all four roots: config, data, state, and cache
+
+Every run reads each selected root and lists what is inside it before removing
+anything, so what a level covers is read off that listing rather than off this
+text. --dry-run prints the same listing and changes nothing.
+
+Safety:
+  --force       required for destructive execution
+  --dry-run     print what would be reset without changing anything
+`;
+var ROOT_NOTES = {
+  state: "the state root holds every session transcript and the audit trail beside it; resume and /view lose their history",
+  data: "the data root holds durable products (memory, evidence, evals)"
+};
+function parseResetArgs(argv) {
+  const parsed = {
+    state: false,
+    data: false,
+    cache: false,
+    auth: false,
+    config: false,
+    all: false,
+    force: false,
+    dryRun: false,
+    help: false
+  };
+  for (const arg of argv) {
+    switch (arg) {
+      case "--state":
+        parsed.state = true;
+        break;
+      case "--data":
+        parsed.data = true;
+        break;
+      case "--cache":
+        parsed.cache = true;
+        break;
+      case "--auth":
+        parsed.auth = true;
+        break;
+      case "--config":
+        parsed.config = true;
+        break;
+      case "--all":
+        parsed.all = 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}`);
+    }
+  }
+  const levels = [parsed.state, parsed.data, parsed.cache, parsed.auth, parsed.config];
+  if (!parsed.help && parsed.all && levels.some(Boolean)) {
+    throw new Error("--all cannot be combined with --state, --data, --cache, --auth, or --config");
+  }
+  if (!parsed.help && !parsed.all && !levels.some(Boolean)) {
+    parsed.state = true;
+  }
+  return parsed;
+}
+function report(label, path) {
+  process.stdout.write(`  ${label.padEnd(12)} ${path}${existsSync(path) ? "" : "  (absent)"}
+`);
+}
+function rootContents(path) {
+  let entries;
+  try {
+    entries = readdirSync(path, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.map((entry) => {
+    if (!entry.isDirectory()) return entry.name;
+    let count;
+    try {
+      count = readdirSync(join(path, entry.name)).length;
+    } catch {
+      return `${entry.name}/`;
+    }
+    return `${entry.name}/ (${count})`;
+  }).sort((left, right) => left.localeCompare(right));
+}
+function writeIndented(text, indent) {
+  const [first = "", ...rest] = wrapPlain(text, Math.max(20, terminalColumns() - indent), indent);
+  process.stdout.write(`${" ".repeat(indent)}${first}
+`);
+  for (const line of rest) process.stdout.write(`${line}
+`);
+}
+function resetInvocation(args) {
+  const levels = [
+    ["all", args.all],
+    ["config", args.config],
+    ["auth", args.auth],
+    ["data", args.data],
+    ["state", args.state],
+    ["cache", args.cache]
+  ].filter(([, on]) => on).map(([name]) => `--${name}`);
+  return `clio-coder reset ${levels.join(" ")} --force`;
+}
+function runResetCommand(argv) {
+  let args;
+  try {
+    args = parseResetArgs(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 reset` requires --force unless you are using --dry-run");
+    process.stdout.write(HELP);
+    return 2;
+  }
+  const dirs = resolveClioDirs();
+  const settingsPath = join(dirs.config, "settings.yaml");
+  const credentialsPath = join(dirs.config, "credentials.yaml");
+  printHeader("Clio Coder reset");
+  const selected = args.all ? [
+    { label: "config", path: dirs.config },
+    { label: "data", path: dirs.data },
+    { label: "state", path: dirs.state },
+    { label: "cache", path: dirs.cache }
+  ] : [
+    ...args.config ? [{ label: "settings", path: settingsPath }] : [],
+    ...args.auth ? [{ label: "credentials", path: credentialsPath }] : [],
+    ...args.data ? [{ label: "data", path: dirs.data }] : [],
+    ...args.state ? [{ label: "state", path: dirs.state }] : [],
+    ...args.cache ? [{ label: "cache", path: dirs.cache }] : []
+  ];
+  for (const entry of selected) {
+    report(entry.label, entry.path);
+    const contents = rootContents(entry.path);
+    if (contents.length > 0) writeIndented(contents.join(", "), 4);
+    const note = ROOT_NOTES[entry.label];
+    if (note) writeIndented(`note: ${note}`, 2);
+  }
+  const failures = [];
+  for (const entry of selected) {
+    const failure = removePath(entry.label, entry.path, args.dryRun);
+    if (failure) failures.push(failure);
+  }
+  resetXdgCache();
+  if (!args.dryRun) initializeClioHome();
+  if (failures.length > 0) {
+    printError("reset did not remove everything");
+    reportRemovalFailures(resetInvocation(args), failures);
+    return 1;
+  }
+  if (args.dryRun) {
+    printOk(args.all ? "reset --all preview complete" : "reset preview complete");
+  } else {
+    printOk(args.all ? "reset config, data, state, and cache" : "reset complete");
+  }
+  return 0;
+}
+export {
+  rootContents,
+  runResetCommand
+};
+//# sourceMappingURL=reset-PIFYNOS3.js.map