@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/reset-V7QSPZYE.js

@@ -0,0 +1,345 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  removePath,
+  reportRemovalFailures
+} from "./chunk-6ICZKDUC.js";
+import {
+  createLifecyclePresenter,
+  measurePath
+} from "./chunk-RNLAPBJL.js";
+import "./chunk-ZIDFQJRB.js";
+import "./chunk-YKIIWURD.js";
+import {
+  initializeClioHome
+} from "./chunk-PFZJMXIY.js";
+import {
+  printError
+} from "./chunk-ATB3Q7YO.js";
+import "./chunk-PAQVETLA.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import {
+  resetXdgCache,
+  resolveClioDirs
+} from "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-E3LEPLQ2.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/reset.ts
+init_esm_shims();
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+var HELP = `clio-coder reset [--state|--data|--cache|--auth|--config|--all] [--dry-run] [--force] [--json]
+
+Recover or wipe Clio Coder state while keeping the clio-coder launcher installed.
+Each level clears exactly the root (or file) it names and nothing else, then the
+empty roots are recreated so the next run has somewhere to write.
+
+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, vendored tools (durable products)
+  --cache       cache root only
+  --auth        credentials.yaml only
+  --config      settings.yaml only
+  --all         all four roots whole: config (settings, credentials, and anything
+                else under it), data, state, and cache
+
+Safety:
+  --force, -f   required for destructive execution in non-interactive environments
+  --dry-run     print what would be reset without changing anything
+  --json        emit machine-readable JSON output
+  --help, -h    show this message
+`;
+var ROOT_NOTES = {
+  state: "State holds every session transcript and the audit trail; resume and /view lose their history.",
+  data: "Data holds memory, evidence, evals, and vendored tools; the tools have to be downloaded again.",
+  config: "Settings return to their defaults.",
+  auth: "Saved API keys are gone; each target has to be authenticated again.",
+  cache: "Cache is disposable and rebuilds itself.",
+  all: "Everything goes: settings, credentials, memory, evidence, transcripts, and caches. A clean install remains."
+};
+function parseResetArgs(argv) {
+  const parsed = {
+    state: false,
+    data: false,
+    cache: false,
+    auth: false,
+    config: false,
+    all: false,
+    force: false,
+    dryRun: false,
+    json: 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 "--json":
+        parsed.json = 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 rootContents(path, limit = 4) {
+  let entries;
+  try {
+    entries = readdirSync(path, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  if (entries.length === 0) return void 0;
+  const names = entries.map((entry) => entry.isDirectory() ? `${entry.name}/` : entry.name).sort((left, right) => left.localeCompare(right));
+  const shown = names.slice(0, limit).join(", ");
+  return names.length > limit ? `${shown}, +${names.length - limit} more` : shown;
+}
+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`;
+}
+async function runResetCommand(argv) {
+  let args;
+  try {
+    args = parseResetArgs(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 reset` needs a terminal to confirm; pass --force to skip the prompt");
+    return 2;
+  }
+  const dirs = resolveClioDirs();
+  const settingsPath = join(dirs.config, "settings.yaml");
+  const credentialsPath = join(dirs.config, "credentials.yaml");
+  const presenter = createLifecyclePresenter({ json: args.json });
+  presenter.header("Reset Clio Coder", "reset");
+  const resetData = args.all || args.data;
+  const resetState = args.all || args.state;
+  const resetCache = args.all || args.cache;
+  const configSize = measurePath(dirs.config);
+  const dataSize = measurePath(dirs.data);
+  const stateSize = measurePath(dirs.state);
+  const cacheSize = measurePath(dirs.cache);
+  const items = [];
+  if (resetState) {
+    items.push({
+      label: "State",
+      path: dirs.state,
+      bytes: stateSize.bytes,
+      status: stateSize.exists ? "remove" : "absent",
+      detail: rootContents(dirs.state)
+    });
+  } else {
+    items.push({
+      label: "State",
+      path: dirs.state,
+      bytes: stateSize.bytes,
+      status: stateSize.exists ? "keep" : "absent",
+      detail: stateSize.exists ? "survives" : void 0
+    });
+  }
+  if (resetData) {
+    items.push({
+      label: "Data",
+      path: dirs.data,
+      bytes: dataSize.bytes,
+      status: dataSize.exists ? "remove" : "absent"
+    });
+  } else {
+    items.push({
+      label: "Data",
+      path: dirs.data,
+      bytes: dataSize.bytes,
+      status: dataSize.exists ? "keep" : "absent",
+      detail: dataSize.exists ? "survives" : void 0
+    });
+  }
+  if (args.all) {
+    items.push({
+      label: "Config",
+      path: dirs.config,
+      bytes: configSize.bytes,
+      status: configSize.exists ? "remove" : "absent"
+    });
+  } else {
+    const stSettings = measurePath(settingsPath);
+    if (args.config) {
+      items.push({
+        label: "Settings",
+        path: settingsPath,
+        bytes: stSettings.bytes,
+        status: stSettings.exists ? "remove" : "absent"
+      });
+    } else {
+      items.push({
+        label: "Settings",
+        path: settingsPath,
+        bytes: stSettings.bytes,
+        status: stSettings.exists ? "keep" : "absent",
+        detail: stSettings.exists ? "survives" : void 0
+      });
+    }
+    const stCreds = measurePath(credentialsPath);
+    if (args.auth) {
+      items.push({
+        label: "Credentials",
+        path: credentialsPath,
+        bytes: stCreds.bytes,
+        status: stCreds.exists ? "remove" : "absent"
+      });
+    } else {
+      items.push({
+        label: "Credentials",
+        path: credentialsPath,
+        bytes: stCreds.bytes,
+        status: stCreds.exists ? "keep" : "absent",
+        detail: stCreds.exists ? "survives" : void 0
+      });
+    }
+  }
+  if (resetCache) {
+    items.push({
+      label: "Cache",
+      path: dirs.cache,
+      bytes: cacheSize.bytes,
+      status: cacheSize.exists ? "remove" : "absent"
+    });
+  } else {
+    items.push({
+      label: "Cache",
+      path: dirs.cache,
+      bytes: cacheSize.bytes,
+      status: cacheSize.exists ? "keep" : "absent",
+      detail: cacheSize.exists ? "survives" : void 0
+    });
+  }
+  presenter.listItems("The following will be cleared", items);
+  const notes = args.all ? [ROOT_NOTES.all] : [
+    resetState ? ROOT_NOTES.state : null,
+    resetData ? ROOT_NOTES.data : null,
+    args.config ? ROOT_NOTES.config : null,
+    args.auth ? ROOT_NOTES.auth : null
+  ].filter((note) => note !== null);
+  for (const note of notes) presenter.note(note);
+  const surviving = items.filter((item) => item.status === "keep").map((item) => item.label);
+  if (surviving.length > 0) presenter.note(`Survives: ${surviving.join(", ")}`);
+  if (args.dryRun) {
+    presenter.warn("Dry run: no changes made");
+    presenter.done("Done");
+    return 0;
+  }
+  if (!args.force) {
+    const confirmed = await presenter.confirm("Are you sure you want to reset the selected state?", false);
+    if (!confirmed) {
+      presenter.warn("Reset cancelled");
+      presenter.done("Cancelled");
+      return 0;
+    }
+  }
+  const toRemove = [];
+  if (args.all) {
+    toRemove.push(
+      { label: "Config", path: dirs.config },
+      { label: "Data", path: dirs.data },
+      { label: "State", path: dirs.state },
+      { label: "Cache", path: dirs.cache }
+    );
+  } else {
+    if (args.config) toRemove.push({ label: "Settings", path: settingsPath });
+    if (args.auth) toRemove.push({ label: "Credentials", path: credentialsPath });
+    if (args.data) toRemove.push({ label: "Data", path: dirs.data });
+    if (args.state) toRemove.push({ label: "State", path: dirs.state });
+    if (args.cache) toRemove.push({ label: "Cache", path: dirs.cache });
+  }
+  const failures = [];
+  let cleared = 0;
+  for (const entry of toRemove) {
+    const existed = measurePath(entry.path).exists;
+    const failure = removePath(entry.label, entry.path, false);
+    if (failure) failures.push(failure);
+    else if (existed) {
+      presenter.completedStep(`Cleared ${entry.label}`);
+      cleared += 1;
+    }
+  }
+  if (failures.length === 0 && cleared === 0)
+    presenter.completedStep("Nothing to clear; every selected root was already empty");
+  resetXdgCache();
+  initializeClioHome();
+  presenter.completedStep("Recreated the empty roots");
+  if (failures.length > 0) {
+    presenter.fail("reset did not clear everything");
+    reportRemovalFailures(resetInvocation(args), failures);
+    presenter.finish();
+    return 1;
+  }
+  if (args.config || args.all) presenter.commandAdvice("Set up a model again:", "clio-coder configure");
+  else if (args.auth) presenter.commandAdvice("Reconnect your providers:", "clio-coder configure --section targets");
+  presenter.done("Done");
+  return 0;
+}
+export {
+  runResetCommand
+};
+//# sourceMappingURL=reset-V7QSPZYE.js.map

package/dist/resources-OJGDFHYT.js

@@ -0,0 +1,181 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ResourcesDomainModule,
+  ResourcesManifest,
+  checkSkillDrift,
+  createResourcesDomainModule,
+  createResourcesLoader,
+  parseSkillEvals,
+  parseSkillSourceSpec,
+  updateSkills
+} from "./chunk-H5DPSUBB.js";
+import {
+  applyLibraryLifecycle,
+  libraryImportOutcome,
+  libraryLifecyclePlanSummary,
+  planLibraryLifecycle,
+  pluginSnapshotRefreshHost,
+  releaseLibraryLifecycle,
+  retryLibraryRefresh,
+  verifyLibraryStep
+} from "./chunk-JCVIL6TY.js";
+import {
+  LIBRARY_INVENTORY_LIMITS,
+  classifyLibraryOrigin,
+  inspectLibraryCopy,
+  libraryCopyState,
+  libraryResourceKey,
+  parseLibraryResourceKey,
+  readLibraryInventory
+} from "./chunk-UB33F3YW.js";
+import "./chunk-ORRNGQDV.js";
+import {
+  expandPromptTemplateInput,
+  loadPromptTemplates,
+  parseCommandArgs,
+  promptTemplateDisplayText,
+  resolveResourceCollisions,
+  substituteArgs,
+  validateLibraryPackage
+} from "./chunk-OEMFEL26.js";
+import {
+  MARKETPLACE_UNCONFIGURED,
+  SKILL_SURFACE_CLEAR_ARG,
+  classifyLibraryRequirements,
+  commitLibraryInstallPlan,
+  confirmLibraryRemote,
+  defaultSkillRoots,
+  discoverLibrary,
+  discoverMarketplaceSkills,
+  expandSkillInvocationInput,
+  getMarketplaceSkills,
+  installLibraryPlan,
+  installSkill,
+  libraryEntryDrift,
+  libraryEntryInstalled,
+  libraryEntryPin,
+  libraryEntryRef,
+  libraryInstallPath,
+  loadSkills,
+  marketplaceInstallShaping,
+  modelVisibleSkills,
+  parsePendingSkillRequests,
+  parseSkillCommand,
+  pinLibraryEntry,
+  planLibraryInstall,
+  planLibraryUpdate,
+  releaseLibraryPlan,
+  removeLibraryEntry,
+  resolveLibraryPackage,
+  resolveLibraryRequirements,
+  resolveMarketplaceShaping,
+  skillCatalogValidity,
+  syncLibrary
+} from "./chunk-EXKUF426.js";
+import {
+  normalizedSkillHash
+} from "./chunk-DNCE23JJ.js";
+import "./chunk-YJCCMYYT.js";
+import "./chunk-7QQRPB2E.js";
+import {
+  LIBRARY_RESOURCE_KINDS,
+  isLibraryResourceKind
+} from "./chunk-6UJ7RDI7.js";
+import "./chunk-VNBICSS2.js";
+import "./chunk-ARRUMZ7X.js";
+import "./chunk-XW2UZICE.js";
+import "./chunk-PGEFOTJB.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-5EQO5NWP.js";
+import "./chunk-YXFKLMX2.js";
+import "./chunk-E2NSPYLC.js";
+import "./chunk-R2P2U3ZS.js";
+import "./chunk-NTTS3O53.js";
+import "./chunk-KQ6IDQIB.js";
+import "./chunk-M4KFUXS7.js";
+import "./chunk-WLHX3MM5.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-GJ24ODAX.js";
+import "./chunk-LTR5QCLS.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-ZTNFYMIO.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-SER7RRAE.js";
+import "./chunk-GH5ZR6JP.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-GD55RTIW.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  LIBRARY_INVENTORY_LIMITS,
+  LIBRARY_RESOURCE_KINDS,
+  MARKETPLACE_UNCONFIGURED,
+  ResourcesDomainModule,
+  ResourcesManifest,
+  SKILL_SURFACE_CLEAR_ARG,
+  applyLibraryLifecycle,
+  checkSkillDrift,
+  classifyLibraryOrigin,
+  classifyLibraryRequirements,
+  commitLibraryInstallPlan,
+  confirmLibraryRemote,
+  createResourcesDomainModule,
+  createResourcesLoader,
+  defaultSkillRoots,
+  discoverLibrary,
+  discoverMarketplaceSkills,
+  expandPromptTemplateInput,
+  expandSkillInvocationInput,
+  getMarketplaceSkills,
+  inspectLibraryCopy,
+  installLibraryPlan,
+  installSkill,
+  isLibraryResourceKind,
+  libraryCopyState,
+  libraryEntryDrift,
+  libraryEntryInstalled,
+  libraryEntryPin,
+  libraryEntryRef,
+  libraryImportOutcome,
+  libraryInstallPath,
+  libraryLifecyclePlanSummary,
+  libraryResourceKey,
+  loadPromptTemplates,
+  loadSkills,
+  marketplaceInstallShaping,
+  modelVisibleSkills,
+  normalizedSkillHash,
+  parseCommandArgs,
+  parseLibraryResourceKey,
+  parsePendingSkillRequests,
+  parseSkillCommand,
+  parseSkillEvals,
+  parseSkillSourceSpec,
+  pinLibraryEntry,
+  planLibraryInstall,
+  planLibraryLifecycle,
+  planLibraryUpdate,
+  pluginSnapshotRefreshHost,
+  promptTemplateDisplayText,
+  readLibraryInventory,
+  releaseLibraryLifecycle,
+  releaseLibraryPlan,
+  removeLibraryEntry,
+  resolveLibraryPackage,
+  resolveLibraryRequirements,
+  resolveMarketplaceShaping,
+  resolveResourceCollisions,
+  retryLibraryRefresh,
+  skillCatalogValidity,
+  substituteArgs,
+  syncLibrary,
+  updateSkills,
+  validateLibraryPackage,
+  verifyLibraryStep
+};
+//# sourceMappingURL=resources-OJGDFHYT.js.map