@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/chunk-YXFKLMX2.js

@@ -0,0 +1,222 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  extractCommandCdTargets,
+  extractCommandWriteTargets
+} from "./chunk-E2NSPYLC.js";
+import {
+  artifactDefaultPath
+} from "./chunk-NTTS3O53.js";
+import {
+  canonicalizeExistingPath
+} from "./chunk-KQ6IDQIB.js";
+import {
+  ToolNames,
+  isHarnessExtensionToolName
+} from "./chunk-WLHX3MM5.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/safety/action-classifier.ts
+init_esm_shims();
+import path from "node:path";
+var GIT_DESTRUCTIVE_PATTERNS = [
+  { name: "git-push-force-long", re: /\bgit\s+push\s+--force\b/i },
+  { name: "git-push-force-short", re: /\bgit\s+push\s+-f\b/i },
+  { name: "git-reset-hard", re: /\bgit\s+reset\s+--hard\b/i },
+  { name: "git-clean-fd", re: /\bgit\s+clean\s+-fd?\b/i },
+  { name: "git-checkout-dot", re: /\bgit\s+checkout\s+--\s+\./i },
+  { name: "git-branch-D", re: /\bgit\s+branch\s+-D\b/i },
+  { name: "git-restore-source", re: /\bgit\s+restore\s+--source\b/i }
+];
+var SYSTEM_MODIFY_PATTERNS = [
+  { name: "sudo-or-doas", re: /\b(sudo|doas)\b/i },
+  // allow rm -rf /tmp/... and /var/tmp/... but flag everything else rooted at /
+  { name: "rm-rf-root", re: /\brm\s+-rf?\s+\/(?!(tmp|var\/tmp)(?:\/|\s|$))/i },
+  { name: "apt-install", re: /\bapt(-get)?\s+(install|remove|purge)/i },
+  { name: "brew-install", re: /\bbrew\s+(install|uninstall|reinstall)/i },
+  { name: "npm-install-global", re: /\bnpm\s+install\s+-g\b/i },
+  { name: "pip-install", re: /\bpip\s+install\b/i },
+  { name: "systemctl", re: /\bsystemctl\s+/i },
+  { name: "chmod-root", re: /\bchmod\s+[0-7]{3,4}\s+\//i },
+  { name: "chown", re: /\bchown\s+/i }
+];
+var SYSTEM_WRITE_ROOT_PREFIXES = ["/etc", "/usr", "/var", "/bin", "/sbin", "/run"];
+var SYSTEM_WRITE_EXEMPT_PREFIXES = ["/var/tmp", "/var/folders"];
+function isUnderPrefix(abs, prefix) {
+  return abs === prefix || abs.startsWith(`${prefix}/`);
+}
+function baseClassify(tool) {
+  switch (tool) {
+    case ToolNames.Evidence:
+    case ToolNames.Read:
+    case ToolNames.Grep:
+    case ToolNames.Find:
+    case ToolNames.Ls:
+    case ToolNames.WebFetch:
+    case ToolNames.Git:
+    case ToolNames.CodeNav:
+    case ToolNames.Context:
+    case ToolNames.Monitor:
+    case ToolNames.AskUser:
+    case ToolNames.CredentialPresent:
+    // tasks pick mutates only Clio-owned session-ledger and project-local
+    // .clio-coder runtime state, never source-workspace files. By intentional
+    // policy it stays read class and ungated; the tool itself still requires
+    // a durable operator task id before it can mutate either store.
+    case ToolNames.Tasks:
+    // ledger posts a typed contribution to a coordination board and reads a
+    // local mirror. Neither touches the workspace, so it is never gated
+    // behind a confirmation.
+    case ToolNames.Ledger:
+    // panes focuses, opens, and closes terminal panes Clio itself created, in
+    // a pane host that lives outside the workspace. Nothing it does writes a
+    // file, runs a model-supplied command (its schema exposes presets only),
+    // or survives the session, so it is reversible, local, and never gated
+    // behind a confirmation.
+    case ToolNames.Panes:
+    // limitation appends a typed receipt to the session ledger and touches
+    // nothing else, so it is never gated behind a confirmation.
+    case ToolNames.Limitation:
+    // decide appends the model's own design decision to the session
+    // decision board. One ledger append, no workspace effect, never gated.
+    case ToolNames.Decide:
+      return "read";
+    case ToolNames.Write:
+    case ToolNames.Edit:
+    case ToolNames.Artifact:
+      return "write";
+    case ToolNames.Bash:
+    case ToolNames.Verify:
+      return "execute";
+    case ToolNames.Dispatch:
+    case ToolNames.Steer:
+      return "dispatch";
+    default:
+      return isHarnessExtensionToolName(tool) ? "execute" : null;
+  }
+}
+function scanStringOf(args) {
+  if (!args) return "";
+  const parts = [];
+  for (const value of Object.values(args)) {
+    if (value == null) continue;
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      parts.push(String(value));
+    } else {
+      try {
+        parts.push(JSON.stringify(value));
+      } catch {
+      }
+    }
+  }
+  return parts.join(" ");
+}
+function matchFirst(patterns, haystack) {
+  for (const p of patterns) {
+    if (p.re.test(haystack)) return p;
+  }
+  return null;
+}
+function resolveCandidate(p, baseCwd) {
+  if (p.startsWith("~")) return p;
+  const base = canonicalizeExistingPath(path.resolve(baseCwd ?? process.cwd()));
+  const resolved = path.isAbsolute(p) ? path.resolve(p) : path.resolve(base, p);
+  return canonicalizeExistingPath(resolved);
+}
+function isInsideCwd(abs) {
+  const cwd = canonicalizeExistingPath(path.resolve(process.cwd()));
+  const candidate = canonicalizeExistingPath(abs);
+  const rel = path.relative(cwd, candidate);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+function writePathClass(pathArg, baseCwd) {
+  if (pathArg.startsWith("~")) {
+    return { cls: "system_modify", reason: `write-path-home-escape: ${pathArg}` };
+  }
+  const abs = resolveCandidate(pathArg, baseCwd);
+  const exempt = SYSTEM_WRITE_EXEMPT_PREFIXES.some((prefix) => isUnderPrefix(abs, prefix));
+  if (!exempt) {
+    for (const prefix of SYSTEM_WRITE_ROOT_PREFIXES) {
+      if (isUnderPrefix(abs, prefix)) {
+        return { cls: "system_modify", reason: `write-path-system-root: ${prefix}` };
+      }
+    }
+  }
+  if (!isInsideCwd(abs)) {
+    return { cls: "system_modify", reason: `write-path-outside-cwd: ${abs}` };
+  }
+  return { cls: "write" };
+}
+function extractWritePath(tool, args) {
+  const candidate = args?.path ?? args?.file_path ?? args?.filePath;
+  if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  return tool === ToolNames.Artifact ? artifactDefaultPath(args?.kind) : null;
+}
+function webFetchIsOutward(args) {
+  const method = typeof args?.method === "string" && args.method.length > 0 ? args.method.toUpperCase() : "GET";
+  return method !== "GET" && method !== "HEAD" || args?.body !== void 0;
+}
+function classify(call) {
+  if (call.tool === ToolNames.WebFetch && webFetchIsOutward(call.args)) {
+    return { actionClass: "write", reasons: ["web-fetch:outward"] };
+  }
+  const base = baseClassify(call.tool);
+  if (base === null) {
+    return { actionClass: "unknown", reasons: [`unknown tool: ${call.tool}`] };
+  }
+  const reasons = [];
+  if (call.tool === ToolNames.Bash) {
+    const scan = scanStringOf(call.args);
+    const gitHit = matchFirst(GIT_DESTRUCTIVE_PATTERNS, scan);
+    if (gitHit) {
+      return { actionClass: "git_destructive", reasons: [`pattern:${gitHit.name}`] };
+    }
+    const sysHit = matchFirst(SYSTEM_MODIFY_PATTERNS, scan);
+    if (sysHit) {
+      return { actionClass: "system_modify", reasons: [`pattern:${sysHit.name}`] };
+    }
+    const command = typeof call.args?.command === "string" ? call.args.command : null;
+    const argCwd = typeof call.args?.cwd === "string" && call.args.cwd.length > 0 ? call.args.cwd : void 0;
+    if (command !== null) {
+      const targetReasons = [];
+      for (const target of extractCommandWriteTargets(command)) {
+        const decision = writePathClass(target, argCwd);
+        if (decision.cls === "system_modify") {
+          targetReasons.push(decision.reason ?? `bash-write-target: ${target}`);
+        }
+      }
+      for (const target of extractCommandCdTargets(command)) {
+        if (target.startsWith("~")) {
+          targetReasons.push(`bash-cd-home-escape: ${target}`);
+          continue;
+        }
+        const abs = resolveCandidate(target, argCwd);
+        if (!isInsideCwd(abs)) {
+          targetReasons.push(`bash-cd-outside-workspace: ${abs}`);
+        }
+      }
+      if (targetReasons.length > 0) {
+        return { actionClass: "system_modify", reasons: targetReasons };
+      }
+    }
+    return { actionClass: "execute", reasons };
+  }
+  if (base === "write") {
+    const pathArg = extractWritePath(call.tool, call.args);
+    if (pathArg) {
+      const decision = writePathClass(pathArg);
+      if (decision.cls === "system_modify") {
+        return { actionClass: "system_modify", reasons: decision.reason ? [decision.reason] : [] };
+      }
+    }
+    return { actionClass: "write", reasons };
+  }
+  return { actionClass: base, reasons };
+}
+
+export {
+  webFetchIsOutward,
+  classify
+};
+//# sourceMappingURL=chunk-YXFKLMX2.js.map

package/dist/chunk-ZST3FRCV.js

@@ -0,0 +1,132 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP,
+  bindExtensionSnapshotStore,
+  buildExtensionSnapshot,
+  createExtensionSnapshotStore,
+  diffExtensionSnapshots
+} from "./chunk-MZKYVIWW.js";
+import {
+  disableExtension,
+  discoverExtensionPackages,
+  enableExtension,
+  installExtension,
+  listInstalledExtensions,
+  removeExtension
+} from "./chunk-6TKOFFGE.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/extensions/index.ts
+init_esm_shims();
+
+// src/domains/extensions/extension.ts
+init_esm_shims();
+function failureDiagnostics(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    entries: [{ type: "error", message: message.slice(0, EXTENSION_SNAPSHOT_DIAGNOSTIC_MESSAGE_CAP) }],
+    truncated: 0
+  };
+}
+function createExtensionsBundle(_context, options = {}) {
+  const store = createExtensionSnapshotStore();
+  const cwd = options.cwd ?? (() => process.cwd());
+  const build = (generation) => buildExtensionSnapshot({
+    cwd: cwd(),
+    generation,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.listRecords !== void 0 ? { listRecords: options.listRecords } : {}
+  });
+  let inFlight = null;
+  const rejected = (reason, diagnostics) => ({
+    status: "rejected",
+    reason,
+    generation: store.current()?.generation ?? 0,
+    diagnostics
+  });
+  const extension = {
+    start() {
+      bindExtensionSnapshotStore(store);
+    },
+    stop() {
+      inFlight = null;
+      bindExtensionSnapshotStore(null);
+    }
+  };
+  const contract = {
+    list(cwd2, options2 = {}) {
+      return listInstalledExtensions(cwd2, options2);
+    },
+    discover(root) {
+      return discoverExtensionPackages(root);
+    },
+    install(root, options2 = {}) {
+      return installExtension(root, options2);
+    },
+    enable(id, options2 = {}) {
+      return enableExtension(id, options2);
+    },
+    disable(id, options2 = {}) {
+      return disableExtension(id, options2);
+    },
+    remove(id, options2 = {}) {
+      return removeExtension(id, options2);
+    },
+    snapshot() {
+      return store.current();
+    },
+    generation() {
+      return store.current()?.generation ?? 0;
+    },
+    prepareReload() {
+      if (inFlight !== null) return rejected("reentrant", { entries: [], truncated: 0 });
+      const previous = store.current();
+      const generation = store.nextGeneration();
+      let snapshot;
+      try {
+        snapshot = build(generation);
+      } catch (error) {
+        return rejected("build-failed", failureDiagnostics(error));
+      }
+      const candidate = {
+        generation,
+        previousGeneration: previous?.generation ?? 0,
+        snapshot,
+        ...diffExtensionSnapshots(previous, snapshot),
+        // Identity on the committed reference covers every intervening
+        // publish; the in-flight check covers discard and double publish.
+        current: () => inFlight === candidate && store.current() === previous,
+        publish() {
+          store.publish(snapshot);
+          inFlight = null;
+        },
+        discard() {
+          if (inFlight === candidate) inFlight = null;
+        }
+      };
+      inFlight = candidate;
+      return { status: "prepared", candidate };
+    }
+  };
+  return { extension, contract };
+}
+
+// src/domains/extensions/manifest.ts
+init_esm_shims();
+var ExtensionsManifest = {
+  name: "extensions",
+  dependsOn: ["config"]
+};
+
+// src/domains/extensions/index.ts
+var ExtensionsDomainModule = {
+  manifest: ExtensionsManifest,
+  createExtension: createExtensionsBundle
+};
+
+export {
+  ExtensionsDomainModule
+};
+//# sourceMappingURL=chunk-ZST3FRCV.js.map

package/dist/cli/index.js

@@ -7,14 +7,14 @@ import {
   extractGlobalFlags,
   parseFlags,
   printError
-} from "../chunk-3T4DXWP6.js";
+} from "../chunk-ATB3Q7YO.js";
 import {
   incompleteInstallationAdvice
 } from "../chunk-3A3CUMKA.js";
-import "../chunk-E3LEPLQ2.js";
 import {
   AI_AGENT_NAME
 } from "../chunk-ZTNFYMIO.js";
+import "../chunk-E3LEPLQ2.js";
 import {
   init_esm_shims
 } from "../chunk-ECBHH7LU.js";
@@ -30,6 +30,7 @@ science. CLIO stands for Context Layer for Input/Output, named for the Greek mus
 
 Usage:
   clio-coder                      start interactive repository chat
+  clio-coder web [--open]         start the browser application
   clio-coder acp                  serve Clio as an ACP v1 agent over stdio
   clio-coder --acp                alias for clio-coder acp
   clio-coder run [flags] <task>   run one headless main-agent turn
@@ -70,14 +71,13 @@ Usage:
   clio-coder usage report         cross-session usage facts and opportunities (experimental)
   clio-coder trace                query or view the durable dispatch trace mirror
   clio-coder extensions           install, list, enable, disable, or remove extension packages
-  clio-coder skills               list, inspect, validate, or install skills
-  clio-coder library              list, search, add, or sync agents, prompts, fleets, and skills from catalogs
+  clio-coder library              register, install, update, import, inspect, and manage packages of every kind
   clio-coder tasks                list, add, hand, finish, or drop project operator tasks
   clio-coder verifiers            discover, inspect, author, validate, edit, or dry-run project checks
   clio-coder tools list|status|install|remove <id>  pinned external programs Clio can drive
   clio-coder interop inspect --json  detected external coding agents and how far each one is wired
   clio-coder panes install|theme  install the pane multiplexer (alias for 'tools install herdr'), or print Clio's theme as a herdr block
-  clio-coder docs [topic]         serve the HTML docs of a source checkout on 127.0.0.1 (--no-open to skip browser)
+  clio-coder docs [topic]         open documentation in the web app (--no-open to print the launch link)
   clio-coder dev <command>        harness instruments; run 'clio-coder dev' for the list
   clio-coder --help, -h           this message
   clio-coder --help --all         this message plus every command under 'clio-coder dev'
@@ -155,7 +155,7 @@ async function main(argv) {
   };
   if (!subcommand) {
     await enableBootCompileCache();
-    const { runClioCommand } = await import("../clio-QQCMTUZE.js");
+    const { runClioCommand } = await import("../clio-BPBAPZGA.js");
     return runClioCommand(bootOptions);
   }
   return dispatch(subcommand, subArgs, bootOptions);
@@ -165,28 +165,28 @@ async function enableBootCompileCache(subArgs = []) {
   const { enableClioCompileCache } = await import("../compile-cache-WJEPUZEJ.js");
   enableClioCompileCache();
 }
-var extensionsCommand = async (subArgs) => (await import("../extensions-YVRHX6ZI.js")).runExtensionsCommand(subArgs);
+var extensionsCommand = async (subArgs) => (await import("../extensions-YIZ7W3DA.js")).runExtensionsCommand(subArgs);
 var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   [
     "acp",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../acp-UVEVWSDL.js")).runAcpCommand(subArgs, bootOptions);
+      return (await import("../acp-JWPQZM2D.js")).runAcpCommand(subArgs, bootOptions);
     }
   ],
-  ["auth", async (subArgs) => (await import("../auth-PCV2XQDV.js")).runAuthCommand(subArgs)],
-  ["config", async (subArgs) => (await import("../config-IIM7YOD3.js")).runConfigCommand(subArgs)],
-  ["configure", async (subArgs) => (await import("../configure-4ZM5HWJX.js")).runConfigureCommand(subArgs)],
-  ["targets", async (subArgs) => (await import("../targets-KILZEOCE.js")).runTargetsCommand(subArgs)],
-  ["models", async (subArgs) => (await import("../models-D4YDIQZQ.js")).runModelsCommand(subArgs)],
-  ["agents", async (subArgs) => (await import("../agents-VWY37DTK.js")).runAgentsCommand(subArgs)],
-  ["components", async (subArgs) => (await import("../components-TNIKXCBH.js")).runComponentsCommand(subArgs)],
-  ["evidence", async (subArgs) => (await import("../evidence-CIGGKI6J.js")).runEvidenceCommand(subArgs)],
-  ["eval", async (subArgs) => (await import("../eval-V2RTN3UH.js")).runEvalCommand(subArgs)],
-  ["memory", async (subArgs) => (await import("../memory-I76I5VUH.js")).runMemoryCommand(subArgs)],
-  ["usage", async (subArgs) => (await import("../usage-PIASNUS4.js")).runUsageCommand(subArgs)],
-  ["trace", async (subArgs) => (await import("../trace-JHLXWUMN.js")).runTraceCommand(subArgs)],
-  ["evolve", async (subArgs) => (await import("../evolve-33SM3NJP.js")).runEvolveCommand(subArgs)],
+  ["auth", async (subArgs) => (await import("../auth-SYAKTDQE.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-FWL5JK2H.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-ZIZ4YV62.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-VSZX2J2S.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-3FTREYPY.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-4GCDIRVX.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-6DKAXWFN.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-Y35YSXH6.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-VJYJ2BV3.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-Z2LSKNV6.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-BIDVTO6V.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-P4MQZD33.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-GPG72VB6.js")).runEvolveCommand(subArgs)],
   [
     "dev",
     async (subArgs, bootOptions) => {
@@ -205,31 +205,31 @@ var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
   ],
   ["extensions", extensionsCommand],
   ["ext", extensionsCommand],
-  ["fleet", async (subArgs) => (await import("../fleet-LFO7SIPC.js")).runFleetCommand(subArgs)],
-  ["skills", async (subArgs) => (await import("../skills-OXFEAWMT.js")).runSkillsCommand(subArgs)],
-  ["library", async (subArgs) => (await import("../library-CTKZA7K3.js")).runLibraryCommand(subArgs)],
-  ["tasks", async (subArgs) => (await import("../tasks-R6P6OV22.js")).runTasksCommand(subArgs)],
-  ["verifiers", async (subArgs) => (await import("../verifiers-LTHUY2PX.js")).runVerifiersCommand(subArgs)],
-  ["docs", async (subArgs) => (await import("../docs-BL7ROUFN.js")).runDocsCommand(subArgs)],
-  ["share", async (subArgs) => (await import("../share-NPZZMUXG.js")).runShareCommand(subArgs)],
-  ["export", async (subArgs) => (await import("../share-NPZZMUXG.js")).runExportCommand(subArgs)],
-  ["import", async (subArgs) => (await import("../share-NPZZMUXG.js")).runImportCommand(subArgs)],
-  ["context", async (subArgs) => (await import("../context-44BZLJ3J.js")).runContextCommand(subArgs)],
+  ["fleet", async (subArgs) => (await import("../fleet-W2AF3TOJ.js")).runFleetCommand(subArgs)],
+  ["library", async (subArgs) => (await import("../library-HUTAS57T.js")).runLibraryCommand(subArgs)],
+  ["tasks", async (subArgs) => (await import("../tasks-AN567LYH.js")).runTasksCommand(subArgs)],
+  ["verifiers", async (subArgs) => (await import("../verifiers-LTGCAMXS.js")).runVerifiersCommand(subArgs)],
+  ["web", async (subArgs) => (await import("../web-EU6ATJWA.js")).runWebCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-VMMWFVHL.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-Y5ZKJPND.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-Y5ZKJPND.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-Y5ZKJPND.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-Z3GOBHDK.js")).runContextCommand(subArgs)],
   [
     "run",
     async (subArgs, bootOptions) => {
       await enableBootCompileCache(subArgs);
-      return (await import("../run-OWQNNSJU.js")).runClioRun(subArgs, bootOptions);
+      return (await import("../run-T354SMDW.js")).runClioRun(subArgs, bootOptions);
     }
   ],
-  ["tools", async (subArgs) => (await import("../tools-6OCQ6SVB.js")).runToolsCommand(subArgs)],
-  ["interop", async (subArgs) => (await import("../interop-RVCAYECG.js")).runInteropCommand(subArgs)],
-  ["panes", async (subArgs) => (await import("../panes-WPOMEMRH.js")).runPanesCommand(subArgs)],
-  ["doctor", async (subArgs) => (await import("../doctor-JJVGPZWT.js")).runDoctorCommand(subArgs)],
-  ["paths", async (subArgs) => (await import("../paths-J3KN7UAO.js")).runPathsCommand(subArgs)],
-  ["reset", async (subArgs) => (await import("../reset-4XMQKDNZ.js")).runResetCommand(subArgs)],
-  ["uninstall", async (subArgs) => (await import("../uninstall-FXYMFFRT.js")).runUninstallCommand(subArgs)],
-  ["upgrade", async (subArgs) => (await import("../upgrade-D2OZH6IQ.js")).runUpgradeCommand(subArgs)],
+  ["tools", async (subArgs) => (await import("../tools-AGRK3V5J.js")).runToolsCommand(subArgs)],
+  ["interop", async (subArgs) => (await import("../interop-IU6BNA7C.js")).runInteropCommand(subArgs)],
+  ["panes", async (subArgs) => (await import("../panes-736XB73K.js")).runPanesCommand(subArgs)],
+  ["doctor", async (subArgs) => (await import("../doctor-V5L4IQGP.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-JQ4QYIYB.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-V7QSPZYE.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-BRUTEPIC.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-SBCGHQGJ.js")).runUpgradeCommand(subArgs)],
   ["version", async () => (await import("../version-RFPKO6T7.js")).runVersionCommand()],
   [
     "worker",

package/dist/clio-BPBAPZGA.js

@@ -0,0 +1,26 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  runClioCommand
+} from "./chunk-IILXVWJY.js";
+import "./chunk-PFZJMXIY.js";
+import "./chunk-FXFVDPWY.js";
+import "./chunk-44U2OUSM.js";
+import "./chunk-X6FLVUM5.js";
+import "./chunk-DXVMLM3Z.js";
+import "./chunk-PGEFOTJB.js";
+import "./chunk-DVNAPPXU.js";
+import "./chunk-3XE4NRLF.js";
+import "./chunk-U2MSJ57E.js";
+import "./chunk-C27U2TYG.js";
+import "./chunk-B5GGDIHT.js";
+import "./chunk-6EXUUOSN.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-CTTI7G3T.js";
+import "./chunk-ZZFWWYLX.js";
+import "./chunk-E3LEPLQ2.js";
+import "./chunk-ECBHH7LU.js";
+export {
+  runClioCommand
+};
+//# sourceMappingURL=clio-BPBAPZGA.js.map