@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/chunk-BJGUKIG4.js

@@ -0,0 +1,302 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  describeYaziProfile,
+  inspectCurrentYaziProfile,
+  resetYaziProfile
+} from "./chunk-J5LZHVIT.js";
+import {
+  installTool,
+  installedToolVersions,
+  removeTool
+} from "./chunk-D4CJV46V.js";
+import {
+  describeFloorRejection,
+  describeResolution,
+  installRemedy,
+  toolStatus,
+  toolStatuses
+} from "./chunk-QSNYB6ZV.js";
+import {
+  PINNED_TOOLS,
+  findPinnedTool
+} from "./chunk-QDC3K2U3.js";
+import {
+  formatColumns,
+  printError,
+  printOk
+} from "./chunk-VPKWYKEY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/cli/tools.ts
+init_esm_shims();
+var HELP = `clio-coder tools <command>
+
+Manage the external terminal programs Clio can drive. Every one of them is
+optional: Clio works without them and only uses one when it is present. Each is
+pinned to an exact upstream version and checksum, and a copy already on PATH
+wins over Clio's own as long as it clears the pinned minimum.
+
+Commands:
+  clio-coder tools list [--json]           the pinned table and where each resolves
+  clio-coder tools status <id> [--json] [--reset-profile]  one tool in detail
+  clio-coder tools install <id> [--force] [--json]  download, verify, and vendor a tool
+  clio-coder tools remove <id>|--all [--json]  delete every vendored version of a tool
+
+Downloads happen only here. Nothing on a startup path fetches anything.
+
+An install keeps one version directory per tool: once the pinned version is in
+place, versions it superseded are pruned, along with any staging directory left
+by an install that was killed. Removal touches nothing outside <data>/tools/<id>
+and needs no confirmation, since every byte under it is re-downloadable from the
+checksum-pinned registry. "remove --all" sweeps every tool in the table.
+`;
+async function runToolsCommand(argv = []) {
+  let parsed;
+  try {
+    parsed = parse(argv);
+  } catch (error) {
+    printError(error instanceof Error ? error.message : String(error));
+    process.stderr.write(HELP);
+    return 2;
+  }
+  if (parsed.help || parsed.command === void 0) {
+    process.stdout.write(HELP);
+    return parsed.help ? 0 : 2;
+  }
+  if (parsed.all && parsed.command !== "remove") {
+    printError("--all is only valid with `tools remove`");
+    return 2;
+  }
+  switch (parsed.command) {
+    case "list":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return listTools(parsed.json);
+    case "status":
+      return statusTool(parsed.positional[0], parsed.json, parsed.resetProfile);
+    case "install":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return installOne(parsed.positional[0], parsed.force, parsed.json);
+    case "remove":
+      if (parsed.resetProfile) return invalidResetProfile();
+      return parsed.all ? removeAll(parsed.positional[0], parsed.json) : removeOne(parsed.positional[0], parsed.json);
+    default:
+      printError(`unknown tools command: ${parsed.command}`);
+      process.stderr.write(HELP);
+      return 2;
+  }
+}
+function parse(argv) {
+  const out = { positional: [], json: false, force: false, all: false, resetProfile: false, help: false };
+  for (const arg of argv) {
+    if (!out.command && !arg.startsWith("-")) {
+      out.command = arg;
+      continue;
+    }
+    switch (arg) {
+      case "--json":
+        out.json = true;
+        break;
+      case "--force":
+      case "-f":
+        out.force = true;
+        break;
+      case "--all":
+        out.all = true;
+        break;
+      case "--reset-profile":
+        out.resetProfile = true;
+        break;
+      case "--help":
+      case "-h":
+        out.help = true;
+        break;
+      default:
+        if (arg.startsWith("-")) throw new Error(`unknown flag: ${arg}`);
+        out.positional.push(arg);
+    }
+  }
+  return out;
+}
+function listTools(json) {
+  const statuses = toolStatuses();
+  if (json) {
+    process.stdout.write(`${JSON.stringify(statuses.map(jsonShape), null, 2)}
+`);
+    return 0;
+  }
+  const rows = statuses.map((status) => [
+    status.id,
+    status.version,
+    status.license,
+    status.resolution.source,
+    describeResolution(status)
+  ]);
+  process.stdout.write(formatColumns([["TOOL", "PIN", "LICENSE", "SOURCE", "RESOLVED"], ...rows]));
+  return 0;
+}
+function invalidResetProfile() {
+  printError("--reset-profile is only valid with `tools status yazi`");
+  return 2;
+}
+function unknownTool(id) {
+  printError(`unknown tool: ${id} (known: ${PINNED_TOOLS.map((row) => row.id).join(", ")})`);
+  return 2;
+}
+function statusTool(id, json, resetProfile) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools status <id>");
+    return 2;
+  }
+  const entry = findPinnedTool(id);
+  if (entry === null) {
+    return unknownTool(id);
+  }
+  if (resetProfile && id !== "yazi") return invalidResetProfile();
+  if (resetProfile) resetYaziProfile();
+  const status = toolStatus(entry);
+  const profile = id === "yazi" ? inspectCurrentYaziProfile() : null;
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ ...jsonShape(status), ...profile ? { profile, profileReset: resetProfile } : {} }, null, 2)}
+`
+    );
+    return 0;
+  }
+  const rejection = describeFloorRejection(status);
+  const installedVersions = installedToolVersions(entry.id);
+  const lines = [
+    `${entry.id} ${entry.version} (${entry.license})`,
+    `  ${entry.summary}`,
+    `  homepage    ${entry.homepage}`,
+    `  binaries    ${entry.binaries.join(", ")}`,
+    `  PATH floor  ${entry.minimumVersion}`,
+    `  platform    ${status.platform ?? `${process.platform}-${process.arch}`}${status.supported ? "" : " (no pinned asset)"}`,
+    `  vendor dir  ${status.installDir}${status.installed ? "" : " (not installed)"}`,
+    `  vendored    ${installedVersions.length === 0 ? "nothing" : installedVersions.join(", ")}`,
+    `  resolves to ${describeResolution(status)}`,
+    // Spelled out on its own line as well as inside the resolution sentence,
+    // because a rejected PATH copy is the one thing an operator reads this
+    // command to understand and the sentence above may be about something else.
+    ...rejection === null ? [] : [
+      `  floor       rejected: ${rejection}`,
+      ...status.resolution.source === "none" && status.supported ? [`  remedy      ${installRemedy(entry.id)}`] : []
+    ],
+    ...profile ? [
+      `  profile     ${describeYaziProfile(profile)}`,
+      ...resetProfile ? ["  profile reset; next open regenerates it"] : []
+    ] : []
+  ];
+  process.stdout.write(`${lines.join("\n")}
+`);
+  return 0;
+}
+async function installOne(id, force, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools install <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) {
+    return unknownTool(id);
+  }
+  const result = await installTool(id, {
+    force,
+    ...json ? {} : { onProgress: (message) => process.stderr.write(`  ${message}
+`) }
+  });
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  for (const path of result.documents) process.stdout.write(`  license  ${path}
+`);
+  for (const version of result.pruned) process.stdout.write(`  pruned   ${id} ${version}
+`);
+  return 0;
+}
+function removeOne(id, json) {
+  if (id === void 0) {
+    printError("usage: clio-coder tools remove <id>");
+    return 2;
+  }
+  if (findPinnedTool(id) === null) return unknownTool(id);
+  const result = removeTool(id);
+  if (json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+    return result.ok ? 0 : 1;
+  }
+  if (!result.ok) {
+    printError(result.message);
+    return 1;
+  }
+  printOk(result.message);
+  if (result.removed.length > 0) {
+    process.stdout.write(`  reinstall with \`${installRemedy(id)}\`
+`);
+  }
+  return 0;
+}
+function removeAll(id, json) {
+  if (id !== void 0) {
+    printError("`tools remove --all` takes no tool id; drop the id or drop --all");
+    return 2;
+  }
+  const results = PINNED_TOOLS.map((entry) => removeTool(entry.id));
+  if (json) {
+    process.stdout.write(`${JSON.stringify(results, null, 2)}
+`);
+    return results.every((result) => result.ok) ? 0 : 1;
+  }
+  for (const result of results) {
+    if (!result.ok) printError(result.message);
+    else if (result.removed.length > 0 || result.staleStaging.length > 0) printOk(result.message);
+  }
+  const touched = results.filter((result) => result.ok && result.removed.length > 0);
+  const untouched = results.filter((result) => result.ok && result.removed.length === 0);
+  if (touched.length > 0) {
+    process.stdout.write(`  reinstall with \`clio-coder tools install <id>\`
+`);
+  }
+  if (untouched.length > 0) {
+    process.stdout.write(`  ${untouched.length} of ${results.length} had nothing vendored
+`);
+  }
+  return results.every((result) => result.ok) ? 0 : 1;
+}
+function jsonShape(status) {
+  return {
+    id: status.id,
+    version: status.version,
+    license: status.license,
+    platform: status.platform,
+    supported: status.supported,
+    installed: status.installed,
+    installDir: status.installDir,
+    source: status.resolution.source,
+    binaryPath: status.resolution.binaryPath,
+    foundVersion: status.resolution.version,
+    minimumVersion: status.resolution.entry?.minimumVersion ?? null,
+    pathCandidate: status.resolution.pathCandidate,
+    // A script deciding whether to warn about a floor rejection should not have
+    // to parse `detail` for it, so the rejection and the command that answers
+    // it are their own fields. `remedy` is null exactly where installing would
+    // change nothing: already vendored, or no asset for this platform.
+    floorRejection: describeFloorRejection(status),
+    remedy: status.resolution.source === "none" && status.supported ? installRemedy(status.id) : null,
+    installedVersions: installedToolVersions(status.id),
+    detail: describeResolution(status)
+  };
+}
+
+export {
+  runToolsCommand
+};
+//# sourceMappingURL=chunk-BJGUKIG4.js.map

package/dist/chunk-BMS5RKQY.js

@@ -0,0 +1,27 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  findExecutableOnPath,
+  resolveToolBinary
+} from "./chunk-QSNYB6ZV.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/executables.ts
+init_esm_shims();
+function resolveFdBinary() {
+  return findExecutableOnPath("fd") ?? findExecutableOnPath("fdfind");
+}
+function resolveRgBinary() {
+  return findExecutableOnPath("rg");
+}
+function resolveBinary(name) {
+  return resolveToolBinary(name).binaryPath;
+}
+
+export {
+  resolveFdBinary,
+  resolveRgBinary,
+  resolveBinary
+};
+//# sourceMappingURL=chunk-BMS5RKQY.js.map

package/dist/{chunk-TD7UE2L5.js → chunk-BTGG6BG2.js}

@@ -1,35 +1,39 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  migrateSettingsV1Document
+} from "./chunk-AP73CFDC.js";
 import {
   parseAgentRecipeSchema
-} from "./chunk-HCBCAYZU.js";
+} from "./chunk-ZJLUDYFY.js";
 import {
   parseFleetContract
-} from "./chunk-HPCTNZM2.js";
+} from "./chunk-CTJ4RNAA.js";
 import {
   parseFrontmatter
 } from "./chunk-RKKLTLYB.js";
 import {
   assertAgentSpecPolicy,
   normalizeAgentSpec
-} from "./chunk-S4COXYBG.js";
+} from "./chunk-IG7BCQBA.js";
 import {
   readSettings,
   settingsPath,
-  updateSettings
-} from "./chunk-PNY46YEY.js";
+  updateSettings,
+  validateSettings
+} from "./chunk-EIMVLWB3.js";
 import {
   readClioVersion
 } from "./chunk-IWHMRKLL.js";
 import {
   DEFAULT_SETTINGS
-} from "./chunk-XDOQXGFO.js";
+} from "./chunk-BWW4HLO4.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir,
   resolveClioDirs
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceBackupPath,
   safeResourceWrite
@@ -111,16 +115,45 @@ function addTree(files, type, scope, root, archivePrefix, filter) {
 }
 function settingsFragment(settings) {
   return {
-    autonomy: settings.autonomy,
-    scope: settings.scope,
-    budget: settings.budget,
-    theme: settings.theme,
-    terminal: settings.terminal,
-    keybindings: settings.keybindings,
-    compaction: settings.compaction,
-    retry: settings.retry
+    version: 2,
+    chat: {
+      modelPicker: { cycleSet: [...settings.chat.modelPicker.cycleSet] },
+      retry: structuredClone(settings.chat.retry)
+    },
+    fleet: { concurrency: settings.fleet.concurrency },
+    context: { compaction: structuredClone(settings.context.compaction) },
+    safety: {
+      autonomy: settings.safety.autonomy,
+      limits: { sessionCostUsd: settings.safety.limits.sessionCostUsd }
+    },
+    interface: structuredClone(settings.interface)
   };
 }
+var SETTINGS_FRAGMENT_ROOTS = ["chat", "fleet", "context", "safety", "interface"];
+function normalizedSettingsFragment(parsed) {
+  if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
+  let normalized = parsed;
+  if (parsed.version === void 0 || parsed.version === 1) {
+    normalized = migrateSettingsV1Document(parsed).document;
+  } else if (parsed.version !== 2) {
+    throw new Error(`settings fragment version must be 1 or 2, got ${String(parsed.version)}`);
+  }
+  const validation = validateSettings(normalized);
+  if (validation.issues.length > 0) {
+    throw new Error(
+      `invalid settings fragment: ${validation.issues.map((issue) => `${issue.path}: ${issue.message}`).join("; ")}`
+    );
+  }
+  return normalized;
+}
+function mergeFragmentValue(current, fragment) {
+  if (!isRecord(current) || !isRecord(fragment)) return structuredClone(fragment);
+  const merged = { ...current };
+  for (const [key, value] of Object.entries(fragment)) {
+    merged[key] = mergeFragmentValue(merged[key], value);
+  }
+  return merged;
+}
 function requestedScopes(scope) {
   if (scope === "both") return ["project", "user"];
   return [scope ?? "project"];
@@ -200,11 +233,11 @@ function createShareArchive(options = {}) {
   }
   const manifestFiles = files.map(({ data: _data, encoding: _encoding, ...entry }) => entry);
   return {
-    kind: "clio-share-archive",
+    kind: "clio-coder-share-archive",
     formatVersion: 1,
     manifest: {
-      format: "clio.share.v1",
-      clioVersion: readClioVersion(),
+      format: "clio-coder.share.v1",
+      clioCoderVersion: readClioVersion(),
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       files: manifestFiles
     },
@@ -221,13 +254,25 @@ function decodeArchiveFile(entry) {
   return Buffer.from(entry.data, entry.encoding);
 }
 function parseArchive(raw) {
-  if (!isRecord(raw) || raw.kind !== "clio-share-archive" || raw.formatVersion !== 1 || !isRecord(raw.manifest)) {
+  if (!isRecord(raw) || raw.kind !== "clio-coder-share-archive" && raw.kind !== "clio-share-archive" || raw.formatVersion !== 1 || !isRecord(raw.manifest)) {
     throw new Error("not a Clio share archive v1");
   }
-  if (raw.manifest.format !== "clio.share.v1" || !Array.isArray(raw.files)) {
+  if (raw.manifest.format !== "clio-coder.share.v1" && raw.manifest.format !== "clio.share.v1" || !Array.isArray(raw.files)) {
     throw new Error("share archive manifest is malformed");
   }
-  const archive = raw;
+  const clioCoderVersion = raw.manifest.clioCoderVersion ?? raw.manifest.clioVersion;
+  if (typeof clioCoderVersion !== "string") throw new Error("share archive manifest is malformed");
+  const archive = {
+    kind: "clio-coder-share-archive",
+    formatVersion: 1,
+    manifest: {
+      format: "clio-coder.share.v1",
+      clioCoderVersion,
+      createdAt: raw.manifest.createdAt,
+      files: raw.manifest.files
+    },
+    files: raw.files
+  };
   const allowedTypes = /* @__PURE__ */ new Set([
     "project-context",
     "prompt",
@@ -385,24 +430,30 @@ function preflightImportTargets(archive, options) {
 function versionDiagnostics(archive) {
   const current = readClioVersion();
   const [curMajor, curMinor] = current.split(".");
-  const [arcMajor, arcMinor] = archive.manifest.clioVersion.split(".");
+  const [arcMajor, arcMinor] = archive.manifest.clioCoderVersion.split(".");
   if (curMajor !== arcMajor || curMinor !== arcMinor) {
     return [
       {
         type: "warning",
-        message: `archive was created by Clio ${archive.manifest.clioVersion}; current Clio is ${current}`
+        message: `archive was created by Clio ${archive.manifest.clioCoderVersion}; current Clio is ${current}`
       }
     ];
   }
   return [];
 }
 function settingsPlan(buffer, options) {
-  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
-  if (!isRecord(parsed)) return [{ type: "error", message: "settings fragment must be a YAML object" }];
+  let parsed;
+  try {
+    parsed = normalizedSettingsFragment((0, import_yaml.parse)(buffer.toString("utf8")));
+  } catch (error) {
+    return [{ type: "error", message: error instanceof Error ? error.message : String(error) }];
+  }
   const settingsTarget = settingsFilePath();
   const current = settingsFragment(existsSync(settingsTarget) ? readSettings() : DEFAULT_SETTINGS);
   const diagnostics = [];
-  for (const [key, value] of Object.entries(parsed)) {
+  for (const [key, value] of Object.entries(parsed).filter(
+    ([key2]) => SETTINGS_FRAGMENT_ROOTS.includes(key2)
+  )) {
     if (key in current && JSON.stringify(current[key]) !== JSON.stringify(value)) {
       diagnostics.push({
         type: "conflict",
@@ -486,21 +537,11 @@ function planShareImport(filePath, options = {}) {
   return publicImportPlan(prepareShareImport(filePath, options));
 }
 function mergeSettingsFragment(buffer) {
-  const parsed = (0, import_yaml.parse)(buffer.toString("utf8"));
-  if (!isRecord(parsed)) throw new Error("settings fragment must be a YAML object");
+  const parsed = normalizedSettingsFragment((0, import_yaml.parse)(buffer.toString("utf8")));
   updateSettings((settings) => {
     const next = settings;
-    for (const key of [
-      "autonomy",
-      "scope",
-      "budget",
-      "theme",
-      "terminal",
-      "keybindings",
-      "compaction",
-      "retry"
-    ]) {
-      if (key in parsed) next[key] = parsed[key];
+    for (const key of SETTINGS_FRAGMENT_ROOTS) {
+      if (key in parsed) next[key] = mergeFragmentValue(next[key], parsed[key]);
     }
   });
   return settingsPath();
@@ -612,4 +653,4 @@ export {
   importShareArchive,
   ShareDomainModule
 };
-//# sourceMappingURL=chunk-TD7UE2L5.js.map
+//# sourceMappingURL=chunk-BTGG6BG2.js.map

package/dist/chunk-BTK3SSSK.js

@@ -0,0 +1,67 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/naming-events.ts
+init_esm_shims();
+var CLIO_CODER_EVENT_SUFFIXES = /* @__PURE__ */ new Set([
+  "permission_escalated",
+  "permission_resolved",
+  "plan_update",
+  "run_outcome",
+  "safety_decision",
+  "skill_activation",
+  "steer_received",
+  "tool_activity",
+  "tool_finish",
+  "tool_start",
+  "usage",
+  "verification",
+  "write_record_downgraded"
+]);
+function normalizeClioCoderEventType(type) {
+  if (!type.startsWith("clio_") || type.startsWith("clio_coder_")) return type;
+  const suffix = type.slice("clio_".length);
+  return CLIO_CODER_EVENT_SUFFIXES.has(suffix) ? `clio_coder_${suffix}` : type;
+}
+function normalizeClioCoderEventRecord(record) {
+  if (typeof record.type !== "string") return record;
+  const type = normalizeClioCoderEventType(record.type);
+  return type === record.type ? record : { ...record, type };
+}
+function normalizeClioCoderEventTree(value) {
+  if (Array.isArray(value)) {
+    let changed2 = false;
+    const next2 = value.map((entry) => {
+      const normalized = normalizeClioCoderEventTree(entry);
+      if (normalized !== entry) changed2 = true;
+      return normalized;
+    });
+    return changed2 ? next2 : value;
+  }
+  if (typeof value !== "object" || value === null) return value;
+  const record = value;
+  let changed = false;
+  const next = {};
+  for (const [key, entry] of Object.entries(record)) {
+    const normalized = normalizeClioCoderEventTree(entry);
+    next[key] = normalized;
+    if (normalized !== entry) changed = true;
+  }
+  if (typeof record.type === "string") {
+    const type = normalizeClioCoderEventType(record.type);
+    if (type !== record.type) {
+      next.type = type;
+      changed = true;
+    }
+  }
+  return changed ? next : value;
+}
+
+export {
+  normalizeClioCoderEventType,
+  normalizeClioCoderEventRecord,
+  normalizeClioCoderEventTree
+};
+//# sourceMappingURL=chunk-BTK3SSSK.js.map

package/dist/{chunk-M6L6IDJG.js → chunk-BWH6N36D.js}

@@ -1183,4 +1183,4 @@ export {
   updateCodewikiPaths,
   syncCodewiki
 };
-//# sourceMappingURL=chunk-M6L6IDJG.js.map
+//# sourceMappingURL=chunk-BWH6N36D.js.map