@iowarp/clio-coder 0.3.0

package/dist/cli/index.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import {
+  traceBoot
+} from "../chunk-6CWDTGUC.js";
+import {
+  extractGlobalFlags,
+  parseFlags,
+  printError
+} from "../chunk-67MTHP2E.js";
+
+// src/cli/index.ts
+import { fileURLToPath } from "node:url";
+var HELP = `Clio Coder command line
+
+Coding agent for HPC and scientific-software work, part of IOWarp's CLIO ecosystem of agentic
+science. CLIO stands for Context Layer for Input/Output, named for the Greek muse of history.
+
+Usage:
+  clio-coder                      start interactive repository chat
+  clio-coder acp                  serve Clio as an ACP v1 agent over stdio
+  clio-coder run [flags] <task>   run one headless main-agent turn
+  clio-coder --version, -v        print the Clio Coder version
+  clio-coder --api-key <key>      override the active target API key for this run
+  clio-coder --no-context-files, -nc  skip CLIO-CODER.md project-context injection
+  clio-coder configure            interactive first-run/configuration wizard
+  clio-coder targets              list configured targets, health, auth, and capabilities
+  clio-coder targets add          add a target interactively or via flags
+  clio-coder targets use <id>     set chat and fleet defaults to a target
+  clio-coder targets profile      set a named fleet profile
+  clio-coder targets remove <id>  remove a target
+  clio-coder targets rename <old> <new>  rename a target
+  clio-coder models [search]      list models for configured targets
+  clio-coder auth list|status|login|logout [target-or-runtime]
+  clio-coder doctor [--fix]       diagnose state; --fix creates or repairs it
+  clio-coder paths [--json]       print resolved config/data/cache directories
+  clio-coder reset                recover or wipe Clio Coder state
+  clio-coder context              show project context status (CLIO-CODER.md, preload, codewiki)
+  clio-coder context init [--yes] [--preview|--heuristic]  explore the repo and bootstrap CLIO-CODER.md and codewiki
+  clio-coder context refresh [--wiki]  re-index the codewiki and optionally update the Markdown wiki
+  clio-coder context wiki [--update] [--status] [--depth auto|simple|medium|detailed] [--target <id>] [--model <id>]
+  clio-coder context reset [--all] [--yes]  clear accumulated project context artifacts
+  clio-coder context index [--json]  build the codewiki index without model calls
+  clio-coder uninstall            remove all Clio Coder state; --remove-binary also unlinks the launcher
+  clio-coder upgrade              upgrade Clio Coder and run pending migrations
+  clio-coder agents               list discovered agent recipes
+  clio-coder fleet list|run|status|drain|resume  fleet contracts, status, and admission control
+  clio-coder evidence             build, list, or inspect evidence artifacts
+  clio-coder eval                 run, report, or compare local eval task files
+  clio-coder memory               list, propose, approve, reject, or prune memory
+  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 docs [topic]         serve bundled HTML docs on 127.0.0.1 (--no-open to skip browser)
+  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'
+`;
+var DEV_COMMANDS = [
+  { name: "components", summary: "list, snapshot, or diff harness components" },
+  { name: "evolve", summary: "create, validate, or summarize change manifests" },
+  { name: "share", summary: "export or import Clio project/resource archives" }
+];
+var DEV_HELP = `Clio Coder harness instruments
+
+Usage:
+${DEV_COMMANDS.map((entry) => `  clio-coder dev ${entry.name.padEnd(20)}${entry.summary}`).join("\n")}
+
+Each also resolves without the 'dev' prefix, so existing scripts and agent
+callers keep working. The prefix exists so the default help stays the set of
+commands a person needs to read.
+`;
+function helpText(all) {
+  return all ? `${HELP}
+${DEV_HELP}` : HELP;
+}
+var MIN_NODE = [22, 19, 0];
+function nodeVersionError() {
+  const parts = process.versions.node.split(".").map((part) => Number.parseInt(part, 10));
+  for (let i = 0; i < MIN_NODE.length; i += 1) {
+    const actual = parts[i] ?? 0;
+    const wanted = MIN_NODE[i] ?? 0;
+    if (actual > wanted) return null;
+    if (actual < wanted) {
+      return `clio-coder requires Node.js >=${MIN_NODE.join(".")}; this is ${process.versions.node}. Upgrade Node and retry.`;
+    }
+  }
+  return null;
+}
+async function main(argv) {
+  traceBoot("cli entry");
+  const versionError = nodeVersionError();
+  if (versionError !== null) {
+    printError(versionError);
+    return 1;
+  }
+  const {
+    apiKey,
+    noContextFiles,
+    noSkills,
+    skillPaths,
+    rest,
+    error: globalFlagError
+  } = extractGlobalFlags(argv, isCommandToken);
+  if (globalFlagError) {
+    printError(globalFlagError);
+    return 2;
+  }
+  const { flags, positional } = parseFlags(rest);
+  const subcommand = positional[0];
+  const subcommandIndex = rest.findIndex((arg) => !arg.startsWith("-"));
+  const firstArg = rest[0];
+  if (firstArg === "--help" || firstArg === "-h" || (flags.has("help") || flags.has("h")) && !subcommand) {
+    process.stdout.write(helpText(flags.has("all")));
+    return 0;
+  }
+  if (flags.has("version") || flags.has("v")) {
+    const { runVersionCommand } = await import("../version-ROZ6CZKH.js");
+    return runVersionCommand();
+  }
+  const subArgs = subcommandIndex === -1 ? [] : rest.slice(subcommandIndex + 1);
+  const bootOptions = {
+    ...apiKey === void 0 ? {} : { apiKey },
+    ...noContextFiles ? { noContextFiles: true } : {},
+    ...noSkills ? { noSkills: true } : {},
+    ...skillPaths.length > 0 ? { skillPaths } : {}
+  };
+  if (!subcommand) {
+    const { runClioCommand } = await import("../clio-KIQ5SNDS.js");
+    return runClioCommand(bootOptions);
+  }
+  return dispatch(subcommand, subArgs, bootOptions);
+}
+var extensionsCommand = async (subArgs) => (await import("../extensions-SRG7XCAH.js")).runExtensionsCommand(subArgs);
+var COMMAND_HANDLERS = /* @__PURE__ */ new Map([
+  ["acp", async (subArgs, bootOptions) => (await import("../acp-UMLFVA3F.js")).runAcpCommand(subArgs, bootOptions)],
+  ["auth", async (subArgs) => (await import("../auth-O6HYIJ6J.js")).runAuthCommand(subArgs)],
+  ["config", async (subArgs) => (await import("../config-ZFCDBMDC.js")).runConfigCommand(subArgs)],
+  ["configure", async (subArgs) => (await import("../configure-G4E3A2PG.js")).runConfigureCommand(subArgs)],
+  ["targets", async (subArgs) => (await import("../targets-DZMEZAH4.js")).runTargetsCommand(subArgs)],
+  ["models", async (subArgs) => (await import("../models-DY35XI7Y.js")).runModelsCommand(subArgs)],
+  ["agents", async (subArgs) => (await import("../agents-Q4MYPMUW.js")).runAgentsCommand(subArgs)],
+  ["components", async (subArgs) => (await import("../components-JVHMUBEB.js")).runComponentsCommand(subArgs)],
+  ["evidence", async (subArgs) => (await import("../evidence-V67CHM35.js")).runEvidenceCommand(subArgs)],
+  ["eval", async (subArgs) => (await import("../eval-B3KZZESM.js")).runEvalCommand(subArgs)],
+  ["memory", async (subArgs) => (await import("../memory-3PIQQAKX.js")).runMemoryCommand(subArgs)],
+  ["usage", async (subArgs) => (await import("../usage-ULIDAGFF.js")).runUsageCommand(subArgs)],
+  ["trace", async (subArgs) => (await import("../trace-7NYCUI2J.js")).runTraceCommand(subArgs)],
+  ["evolve", async (subArgs) => (await import("../evolve-YDZSUQYA.js")).runEvolveCommand(subArgs)],
+  [
+    "dev",
+    async (subArgs, bootOptions) => {
+      const devSubcommand = subArgs[0];
+      if (devSubcommand === void 0 || devSubcommand === "--help" || devSubcommand === "-h") {
+        process.stdout.write(DEV_HELP);
+        return 0;
+      }
+      if (!DEV_COMMANDS.some((entry) => entry.name === devSubcommand)) {
+        printError(`unknown dev command: ${devSubcommand}`);
+        process.stdout.write(DEV_HELP);
+        return 2;
+      }
+      return dispatch(devSubcommand, subArgs.slice(1), bootOptions);
+    }
+  ],
+  ["extensions", extensionsCommand],
+  ["ext", extensionsCommand],
+  ["fleet", async (subArgs) => (await import("../fleet-CA2CRTVG.js")).runFleetCommand(subArgs)],
+  ["skills", async (subArgs) => (await import("../skills-F2MRLELY.js")).runSkillsCommand(subArgs)],
+  ["docs", async (subArgs) => (await import("../docs-YIETIWZI.js")).runDocsCommand(subArgs)],
+  ["share", async (subArgs) => (await import("../share-D36RQCXM.js")).runShareCommand(subArgs)],
+  ["export", async (subArgs) => (await import("../share-D36RQCXM.js")).runExportCommand(subArgs)],
+  ["import", async (subArgs) => (await import("../share-D36RQCXM.js")).runImportCommand(subArgs)],
+  ["context", async (subArgs) => (await import("../context-CDXTP2MP.js")).runContextCommand(subArgs)],
+  ["run", async (subArgs, bootOptions) => (await import("../run-3VSPP24F.js")).runClioRun(subArgs, bootOptions)],
+  ["doctor", async (subArgs) => (await import("../doctor-M5HJJZOL.js")).runDoctorCommand(subArgs)],
+  ["paths", async (subArgs) => (await import("../paths-5OMXW7Z4.js")).runPathsCommand(subArgs)],
+  ["reset", async (subArgs) => (await import("../reset-PIFYNOS3.js")).runResetCommand(subArgs)],
+  ["uninstall", async (subArgs) => (await import("../uninstall-AD3JWHBB.js")).runUninstallCommand(subArgs)],
+  ["upgrade", async (subArgs) => (await import("../upgrade-WYYBKGDY.js")).runUpgradeCommand(subArgs)],
+  ["version", async () => (await import("../version-ROZ6CZKH.js")).runVersionCommand()],
+  [
+    "worker",
+    async () => {
+      await import("../worker/entry.js");
+      return 0;
+    }
+  ]
+]);
+var RETIRED_SUBCOMMANDS = /* @__PURE__ */ new Set(["context-init", "context-index", "context-clear"]);
+function isCommandToken(token) {
+  return COMMAND_HANDLERS.has(token) || RETIRED_SUBCOMMANDS.has(token);
+}
+function incompleteInstallationAdvice(err) {
+  if (err?.code !== "ERR_MODULE_NOT_FOUND") return null;
+  const message = err instanceof Error ? err.message : String(err);
+  let outputDir;
+  try {
+    outputDir = fileURLToPath(new URL("../", import.meta.url));
+  } catch {
+    return null;
+  }
+  if (!message.includes(outputDir)) return null;
+  return [
+    `${message}`,
+    "",
+    "This Clio Coder installation is incomplete: the command's own module is missing from",
+    `${outputDir}`,
+    "Reinstall to restore it, using the line that matches how you installed:",
+    "  npm install -g @iowarp/clio-coder    # npm install",
+    "  npm run install:local                # source checkout"
+  ].join("\n");
+}
+async function dispatch(subcommand, subArgs, bootOptions) {
+  const handler = COMMAND_HANDLERS.get(subcommand);
+  if (handler) {
+    try {
+      return await handler(subArgs, bootOptions);
+    } catch (err) {
+      const advice = incompleteInstallationAdvice(err);
+      if (advice === null) throw err;
+      printError(advice);
+      return 1;
+    }
+  }
+  printError(`unknown subcommand: ${subcommand}`);
+  process.stdout.write(helpText(false));
+  return 2;
+}
+main(process.argv.slice(2)).then((code) => {
+  process.exitCode = code;
+}).catch((err) => {
+  printError(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map

package/dist/clio-KIQ5SNDS.js

@@ -0,0 +1,53 @@
+import {
+  runClioCommand
+} from "./chunk-PS4PFJQP.js";
+import "./chunk-AMFR5YA3.js";
+import "./chunk-O4EJEDHO.js";
+import "./chunk-4UQA7NCT.js";
+import "./chunk-3DANZDGR.js";
+import "./chunk-JPOWPFCU.js";
+import "./chunk-NI4DEJMC.js";
+import "./chunk-7RBKDI66.js";
+import "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import "./chunk-6CWDTGUC.js";
+import "./chunk-BYEU76JP.js";
+import "./chunk-HMYNFFY4.js";
+import "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import "./chunk-GNGDQYDU.js";
+import "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import "./chunk-XNISANGE.js";
+import "./chunk-KKKPTZLM.js";
+import "./chunk-ME6DNWIU.js";
+import "./chunk-262G75JS.js";
+import "./chunk-TFSSEXL6.js";
+import "./chunk-PIDUD6M2.js";
+import "./chunk-67MTHP2E.js";
+import "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+export {
+  runClioCommand
+};
+//# sourceMappingURL=clio-KIQ5SNDS.js.map