@iowarp/clio-coder 0.3.9 → 0.4.1

package/dist/{chunk-R7LNVMCS.js → chunk-QMXC4JB7.js}

@@ -5,19 +5,26 @@ import {
 import {
   hashToolCall
 } from "./chunk-UOV2BYIW.js";
+import {
+  resolveFdBinary,
+  resolveRgBinary
+} from "./chunk-BMS5RKQY.js";
+import {
+  webFetchToolSurface
+} from "./chunk-YPI3QQCF.js";
 import {
   gitTool,
   verifyToolSurface
-} from "./chunk-CA42X6KT.js";
+} from "./chunk-7OBGU7UB.js";
 import {
   codeNavToolSurface
-} from "./chunk-OEDBCISO.js";
+} from "./chunk-ABLSQ6JX.js";
 import {
   contextToolSurface
-} from "./chunk-5DQRIYDZ.js";
+} from "./chunk-PBP4B7XR.js";
 import {
   describeDispatchPlan
-} from "./chunk-VKBMFOYV.js";
+} from "./chunk-JZWT5J3Y.js";
 import {
   compileGlobRegex,
   fallbackIgnoredDirs,
@@ -27,37 +34,31 @@ import {
 } from "./chunk-VG7TBQIY.js";
 import {
   RESPONSE_SCHEMA_RUNTIME_ID,
-  applyToolProfile,
   bashTool,
   builtin,
-  describeCallAction,
   networkToolsDisabled,
   readMaxBytes,
   readTool,
   renderAgentLedger
-} from "./chunk-4H6ULJ3H.js";
+} from "./chunk-2VG7KLYV.js";
 import {
   createTaskBoardStore,
   taskBoardCounts
-} from "./chunk-2JDWVJND.js";
+} from "./chunk-6DWBAZ5U.js";
 import {
   formatModelRejection
-} from "./chunk-N3PBVRTZ.js";
+} from "./chunk-IXJT6DCX.js";
+import {
+  describeCallAction
+} from "./chunk-TVHHYFHE.js";
+import {
+  applyToolProfile
+} from "./chunk-42FMPA75.js";
 import {
   resolveReadPath,
   resolveToCwd,
   toPosixPath
 } from "./chunk-OQE5J4C6.js";
-import {
-  classify
-} from "./chunk-S4COXYBG.js";
-import {
-  CLIO_ARTIFACT_DIR,
-  artifactDefaultPath,
-  detectValidationCommand,
-  protectArtifact,
-  protectedArtifactMutationBlockReason
-} from "./chunk-MV3K5QF2.js";
 import {
   DEFAULT_AUTONOMY_EXPOSURE,
   DEFAULT_AUTONOMY_LEVEL,
@@ -66,7 +67,7 @@ import {
   evaluateSkillToolSurface,
   mapAutonomy,
   skillActivationFromToolDetails
-} from "./chunk-RAPCMZL4.js";
+} from "./chunk-FSP7CMNU.js";
 import {
   DEFAULT_TOOL_RESULT_MAX_BYTES,
   OBSERVATION_POLICY_SLACK_BYTES,
@@ -81,36 +82,43 @@ import {
   toolResultContextText,
   toolResultDigestFor,
   truncateHead
-} from "./chunk-ODFEOB4F.js";
+} from "./chunk-R23Z6K6I.js";
 import {
   GREP_MAX_LINE_LENGTH,
   truncateLine
 } from "./chunk-OZNBF4L3.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
 import {
   parseAgentLedgerBody
-} from "./chunk-CMZWFGD2.js";
+} from "./chunk-VAVR4IJY.js";
 import {
-  webFetchToolSurface
-} from "./chunk-ZI647VB5.js";
+  classify
+} from "./chunk-IG7BCQBA.js";
 import {
-  truncateUtf8
-} from "./chunk-6XLNIQDB.js";
+  CLIO_ARTIFACT_DIR,
+  artifactDefaultPath,
+  detectValidationCommand,
+  protectArtifact,
+  protectedArtifactMutationBlockReason
+} from "./chunk-GCSMB2KY.js";
 import {
   typebox_exports
 } from "./chunk-5B2AEOW5.js";
 import {
   ToolNames,
   isBuiltinToolName
-} from "./chunk-CGKSTWHD.js";
+} from "./chunk-K6BSR66V.js";
 import {
   incompleteInstallationAdvice
 } from "./chunk-65DEGPJ6.js";
-import {
-  buildSafeToolEnv
-} from "./chunk-B5CSFE7B.js";
 import {
   BusChannels
-} from "./chunk-RKRLDWD3.js";
+} from "./chunk-HLW2MRKE.js";
+import {
+  buildSafeToolEnv
+} from "./chunk-HJWWJ6IL.js";
 import {
   GUARDRAIL_DEFAULTS,
   isWorkerToolCallCapExceededReason,
@@ -119,14 +127,14 @@ import {
   workerSynthesisReserveDirective,
   workerToolCallCapExceededReason,
   workerToolCallCapSynthesisReason
-} from "./chunk-4ZG3XFUR.js";
+} from "./chunk-NLFAQR7Z.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   StringEnum,
   engineStreamSimple
-} from "./chunk-UOSL25KY.js";
+} from "./chunk-VXMFAE2W.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -757,7 +765,7 @@ async function persistAskUserTranscript(policy, options) {
     await mkdir(dir, { recursive: true });
     if (!policy.transcriptPath) policy.transcriptPath = path.join(dir, transcriptFileName(policy));
     const transcript = {
-      schema: "clio.ask_user.interview.v1",
+      schema: "clio-coder.ask_user.interview.v1",
       id: policy.id,
       status: policy.status,
       startedAt: policy.startedAt,
@@ -3740,31 +3748,9 @@ var editTool = {
 
 // src/tools/find.ts
 init_esm_shims();
-import { existsSync, statSync as statSync2 } from "node:fs";
+import { existsSync, statSync } from "node:fs";
 import { readdir } from "node:fs/promises";
-import { join as join2, relative } from "node:path";
-
-// src/tools/executables.ts
-init_esm_shims();
-import { statSync } from "node:fs";
-import { delimiter, join } from "node:path";
-function findExecutableOnPath(name) {
-  const pathEnv = process.env.PATH;
-  if (!pathEnv) return null;
-  for (const dir of pathEnv.split(delimiter)) {
-    if (!dir) continue;
-    const candidate = join(dir, name);
-    const stat = statSync(candidate, { throwIfNoEntry: false });
-    if (stat?.isFile() && (stat.mode & 73) !== 0) return candidate;
-  }
-  return null;
-}
-function resolveFdBinary() {
-  return findExecutableOnPath("fd") ?? findExecutableOnPath("fdfind");
-}
-function resolveRgBinary() {
-  return findExecutableOnPath("rg");
-}
+import { join, relative } from "node:path";
 
 // src/tools/spawn-hygiene.ts
 init_esm_shims();
@@ -3940,7 +3926,7 @@ async function fallbackFind(pattern, searchPath, collectLimit, includeIgnored, s
     }
     for (const entry of entries) {
       if (out.length >= collectLimit || signal?.aborted) return;
-      const absPath = join2(dir, entry.name);
+      const absPath = join(dir, entry.name);
       if (entry.isDirectory() && !entry.isSymbolicLink()) {
         if (ignored.has(entry.name)) continue;
         const relDir = `${toPosixPath(relative(searchPath, absPath))}/`;
@@ -3961,7 +3947,7 @@ function orderByMtime(paths, searchPath, limit, candidateCap) {
   const stamped = paths.map((relPath) => {
     let mtimeMs = 0;
     try {
-      mtimeMs = statSync2(join2(searchPath, relPath)).mtimeMs;
+      mtimeMs = statSync(join(searchPath, relPath)).mtimeMs;
     } catch {
     }
     return { relPath, mtimeMs };
@@ -4042,7 +4028,7 @@ var findTool = {
     }
     const searchPath = resolveReadPath(typeof args.path === "string" && args.path.length > 0 ? args.path : ".");
     if (!existsSync(searchPath)) return { kind: "error", message: `find: path not found: ${searchPath}` };
-    if (!statSync2(searchPath).isDirectory()) return { kind: "error", message: `find: not a directory: ${searchPath}` };
+    if (!statSync(searchPath).isDirectory()) return { kind: "error", message: `find: not a directory: ${searchPath}` };
     const limit = typeof args.limit === "number" && args.limit > 0 ? Math.floor(args.limit) : DEFAULT_LIMIT;
     const includeIgnored = args.include_ignored === true;
     const reservation = reserveObservation(OBSERVE_SELF_CAPS.find, options);
@@ -4090,8 +4076,8 @@ var findTool = {
 
 // src/tools/grep.ts
 init_esm_shims();
-import { readdirSync, readFileSync as readFileSync2, statSync as statSync3 } from "node:fs";
-import path3, { join as join3, relative as relative2 } from "node:path";
+import { readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import path3, { join as join2, relative as relative2 } from "node:path";
 var DEFAULT_LIMIT2 = 100;
 var FALLBACK_MAX_FILE_BYTES = 2e7;
 var MODE_UNITS = {
@@ -4113,7 +4099,7 @@ function formatPath(filePath, searchPath, isDirectory) {
 }
 function statIsDirectory(searchPath) {
   try {
-    return { ok: true, isDirectory: statSync3(searchPath).isDirectory() };
+    return { ok: true, isDirectory: statSync2(searchPath).isDirectory() };
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     return { ok: false, message };
@@ -4313,7 +4299,7 @@ function fallbackGrep(input) {
     if (limitHit) return;
     let buffer;
     try {
-      const stat = statSync3(filePath);
+      const stat = statSync2(filePath);
       if (!stat.isFile() || stat.size > FALLBACK_MAX_FILE_BYTES) return;
       buffer = readFileSync2(filePath);
     } catch {
@@ -4365,7 +4351,7 @@ function fallbackGrep(input) {
     }
     for (const entry of entries) {
       if (limitHit || signal?.aborted) return;
-      const absPath = join3(dir, entry.name);
+      const absPath = join2(dir, entry.name);
       if (entry.isDirectory()) {
         if (ignored.has(entry.name)) continue;
         walk(absPath);
@@ -4617,7 +4603,7 @@ ${output}`,
 
 // src/tools/ls.ts
 init_esm_shims();
-import { readdirSync as readdirSync2, statSync as statSync4 } from "node:fs";
+import { readdirSync as readdirSync2, statSync as statSync3 } from "node:fs";
 import path4 from "node:path";
 var DEFAULT_LIMIT3 = 500;
 function parseLimit(value) {
@@ -4637,7 +4623,7 @@ var lsTool = {
     const root = resolveReadPath(rootArg);
     const limit = parseLimit(args.limit);
     try {
-      const rootStat = statSync4(root);
+      const rootStat = statSync3(root);
       if (!rootStat.isDirectory()) {
         return { kind: "error", message: `ls: not a directory: ${root}` };
       }
@@ -4665,7 +4651,7 @@ var lsTool = {
           break;
         }
         try {
-          const entryStat = statSync4(path4.join(root, entry));
+          const entryStat = statSync3(path4.join(root, entry));
           outputEntries.push(entryStat.isDirectory() ? `${entry}/` : entry);
         } catch {
         }
@@ -4740,6 +4726,10 @@ var TOOL_PLANES = {
   // review the board depends on. Sequential so two posts in one batch do not
   // interleave against the local post cap.
   [ToolNames.Ledger]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
+  // panes projects Clio's own runs onto a pane host and opens preset utility
+  // panes. It mutates no workspace, so it stays read class; sequential because
+  // two pane operations in one batch would race the same pane registry.
+  [ToolNames.Panes]: { plane: "orchestrate", actionClass: "read", executionMode: "sequential" },
   [ToolNames.WebFetch]: { plane: "retrieve", actionClass: "read", executionMode: "parallel" },
   [ToolNames.AskUser]: { plane: "interact", actionClass: "read", executionMode: "sequential" },
   [ToolNames.Artifact]: { plane: "artifact", actionClass: "write", executionMode: "sequential" }
@@ -4758,6 +4748,7 @@ var OBSERVE_ENVELOPE_SELF_CAPS = [
 var SESSION_BOUND_TOOLS = /* @__PURE__ */ new Set([]);
 var DISPATCH_BOUND_TOOLS = /* @__PURE__ */ new Set([ToolNames.Dispatch, ToolNames.Monitor, ToolNames.Steer]);
 var INTERACTIVE_BOUND_TOOLS = /* @__PURE__ */ new Set([ToolNames.AskUser]);
+var PANES_BOUND_TOOLS = /* @__PURE__ */ new Set([ToolNames.Panes]);
 var NETWORK_BOUND_TOOLS = /* @__PURE__ */ new Set([ToolNames.WebFetch]);
 function validateBuiltinToolPolicy(specs, options = {}) {
   const errors = [];
@@ -4796,12 +4787,14 @@ function validateBuiltinToolPolicy(specs, options = {}) {
   const includeSessionTools = options.includeSessionTools ?? false;
   const includeDispatchTools = options.includeDispatchTools ?? false;
   const includeInteractiveTools = options.includeInteractiveTools ?? false;
+  const includePanesTools = options.includePanesTools ?? false;
   const includeNetworkTools = options.includeNetworkTools ?? true;
   const required = new Set(Object.values(ToolNames));
   for (const tool of [...required]) {
     if (!includeSessionTools && SESSION_BOUND_TOOLS.has(tool)) required.delete(tool);
     if (!includeDispatchTools && DISPATCH_BOUND_TOOLS.has(tool)) required.delete(tool);
     if (!includeInteractiveTools && INTERACTIVE_BOUND_TOOLS.has(tool)) required.delete(tool);
+    if (!includePanesTools && PANES_BOUND_TOOLS.has(tool)) required.delete(tool);
     if (!includeNetworkTools && NETWORK_BOUND_TOOLS.has(tool)) required.delete(tool);
   }
   for (const tool of required) {
@@ -5099,7 +5092,7 @@ function registerCoreTools(registry, deps = {}) {
   if (includeNetworkTools) {
     registry.register({
       ...builtin(
-        lazyTool(webFetchToolSurface, async () => (await import("./web-fetch-2YHJ3KTG.js")).webFetchTool),
+        lazyTool(webFetchToolSurface, async () => (await import("./web-fetch-MPIFL3LL.js")).webFetchTool),
         { path: "src/tools/web-fetch.ts", scope: "core" }
       )
     });
@@ -5109,13 +5102,13 @@ function registerCoreTools(registry, deps = {}) {
   });
   registry.register({
     ...builtin(
-      lazyTool(verifyToolSurface, async () => (await import("./verify-BVKWTNDL.js")).verifyTool),
+      lazyTool(verifyToolSurface, async () => (await import("./verify-YJL6XET2.js")).verifyTool),
       { path: "src/tools/verify/index.ts", scope: "core" }
     )
   });
   registry.register({
     ...builtin(
-      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-LMW275PA.js")).codeNavTool),
+      lazyTool(codeNavToolSurface, async () => (await import("./code-nav-RK6S7F6E.js")).codeNavTool),
       { path: "src/tools/codewiki/code-nav.ts", scope: "core" }
     )
   });
@@ -5140,7 +5133,7 @@ function registerCoreTools(registry, deps = {}) {
   registry.register({
     ...builtin(
       lazyTool(contextToolSurface, async () => {
-        const { createContextTool } = await import("./context-PALKKQYL.js");
+        const { createContextTool } = await import("./context-XNHL75JV.js");
         if (!session) return createContextTool(skillToolDeps);
         const { probeWorkspace } = await import("./workspace-ZJ6BFM3Q.js");
         return createContextTool({
@@ -5199,8 +5192,8 @@ function registerCoreTools(registry, deps = {}) {
     includeInteractiveTools: Boolean(deps.askUser)
   };
 }
-function assertRegisteredBuiltinTools(registry, registration, includeDispatchTools) {
-  assertBuiltinToolPolicy(registry.listAll(), { ...registration, includeDispatchTools });
+function assertRegisteredBuiltinTools(registry, registration, includeDispatchTools, includePanesTools = false) {
+  assertBuiltinToolPolicy(registry.listAll(), { ...registration, includeDispatchTools, includePanesTools });
 }
 
 export {
@@ -5237,10 +5230,9 @@ export {
   applyEditsToNormalizedContent,
   generateDiffString,
   askAxis,
-  resolveFdBinary,
   lazyTool,
   registerCoreTools,
   assertRegisteredBuiltinTools,
   createRegistry
 };
-//# sourceMappingURL=chunk-R7LNVMCS.js.map
+//# sourceMappingURL=chunk-QMXC4JB7.js.map

package/dist/chunk-QSNYB6ZV.js

@@ -0,0 +1,195 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PINNED_TOOLS,
+  currentToolPlatform,
+  findPinnedTool,
+  findPinnedToolByBinary,
+  toolVersionDir,
+  vendoredBinaryPath
+} from "./chunk-QDC3K2U3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/toolchain/resolve.ts
+init_esm_shims();
+import { statSync } from "node:fs";
+import { delimiter, join } from "node:path";
+
+// src/domains/toolchain/version.ts
+init_esm_shims();
+import { spawnSync } from "node:child_process";
+var VERSION_PATTERN = /(\d+)\.(\d+)\.(\d+)/;
+var PROBE_TIMEOUT_MS = 2e3;
+function parseVersion(output) {
+  const match = VERSION_PATTERN.exec(output);
+  if (!match) return null;
+  return `${match[1]}.${match[2]}.${match[3]}`;
+}
+function compareVersions(a, b) {
+  const left = numericParts(a);
+  const right = numericParts(b);
+  for (let i = 0; i < 3; i += 1) {
+    const diff = (left[i] ?? 0) - (right[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+function satisfiesMinimum(found, minimum) {
+  if (found === null) return false;
+  return compareVersions(found, minimum) >= 0;
+}
+function probeBinaryVersion(binaryPath, args) {
+  const cached = probeCache.get(binaryPath);
+  if (cached !== void 0) return cached;
+  let version = null;
+  try {
+    const result = spawnSync(binaryPath, [...args], {
+      timeout: PROBE_TIMEOUT_MS,
+      encoding: "utf8",
+      // A version probe must never inherit a terminal or wait on input: some
+      // of these binaries are full-screen programs when given a tty.
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.error === void 0) {
+      version = parseVersion(`${result.stdout ?? ""}
+${result.stderr ?? ""}`);
+    }
+  } catch {
+    version = null;
+  }
+  probeCache.set(binaryPath, version);
+  return version;
+}
+var probeCache = /* @__PURE__ */ new Map();
+function numericParts(value) {
+  const match = VERSION_PATTERN.exec(value);
+  if (!match) return [0, 0, 0];
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+
+// src/domains/toolchain/resolve.ts
+function findExecutableOnPath(name) {
+  const pathEnv = process.env.PATH;
+  if (!pathEnv) return null;
+  const candidates = process.platform === "win32" ? [`${name}.exe`, name] : [name];
+  for (const dir of pathEnv.split(delimiter)) {
+    if (!dir) continue;
+    for (const candidate of candidates) {
+      const full = join(dir, candidate);
+      const stat = statSync(full, { throwIfNoEntry: false });
+      if (stat?.isFile() && (process.platform === "win32" || (stat.mode & 73) !== 0)) return full;
+    }
+  }
+  return null;
+}
+function resolveToolBinary(name) {
+  const entry = findPinnedToolByBinary(name) ?? findPinnedTool(name);
+  if (entry === null) {
+    const found = findExecutableOnPath(name);
+    return {
+      source: found === null ? "none" : "path",
+      binaryPath: found,
+      version: null,
+      entry: null,
+      pathCandidate: found === null ? null : { path: found, version: null, satisfiesMinimum: true },
+      vendoredPath: null
+    };
+  }
+  const binary = entry.binaries.includes(name) ? name : entry.primaryBinary;
+  return resolveEntryBinary(entry, binary);
+}
+function resolveEntryBinary(entry, binary) {
+  const pathCandidate = probePathCandidate(entry, binary);
+  const vendored = vendoredBinaryPath(entry.id, entry.version, binary);
+  const vendoredStat = statSync(vendored, { throwIfNoEntry: false });
+  const vendoredPath = vendoredStat?.isFile() ? vendored : null;
+  if (pathCandidate?.satisfiesMinimum) {
+    return {
+      source: "path",
+      binaryPath: pathCandidate.path,
+      version: pathCandidate.version,
+      entry,
+      pathCandidate,
+      vendoredPath
+    };
+  }
+  if (vendoredPath !== null) {
+    return {
+      source: "vendored",
+      binaryPath: vendoredPath,
+      version: entry.version,
+      entry,
+      pathCandidate,
+      vendoredPath
+    };
+  }
+  return { source: "none", binaryPath: null, version: null, entry, pathCandidate, vendoredPath: null };
+}
+function toolStatus(entry) {
+  const platform = currentToolPlatform();
+  const supported = platform !== null && entry.downloads[platform] !== void 0;
+  const resolution = resolveEntryBinary(entry, entry.primaryBinary);
+  return {
+    id: entry.id,
+    version: entry.version,
+    license: entry.license,
+    platform,
+    supported,
+    installed: resolution.vendoredPath !== null,
+    installDir: toolVersionDir(entry.id, entry.version),
+    resolution
+  };
+}
+function toolStatuses() {
+  return PINNED_TOOLS.map((entry) => toolStatus(entry));
+}
+function installRemedy(id) {
+  return `clio-coder tools install ${id}`;
+}
+function describeFloorRejection(status) {
+  const candidate = status.resolution.pathCandidate;
+  if (candidate === null || candidate.satisfiesMinimum) return null;
+  const floor = status.resolution.entry?.minimumVersion ?? status.version;
+  const found = candidate.version === null ? "an unreadable version" : candidate.version;
+  return `PATH copy ${candidate.path} is ${found}, below the ${floor} floor`;
+}
+function describeResolution(status) {
+  const { resolution } = status;
+  const rejection = describeFloorRejection(status);
+  if (resolution.source === "path") {
+    const version = resolution.version ?? "unreadable version";
+    return `PATH ${resolution.binaryPath} (${version}, pin ${status.version})`;
+  }
+  if (resolution.source === "vendored") {
+    const rejected = rejection === null ? "" : `; ${rejection}, so Clio runs the vendored copy`;
+    return `vendored ${resolution.binaryPath} (${status.version})${rejected}`;
+  }
+  if (!status.supported) {
+    const platform = status.platform ?? `${process.platform}-${process.arch}`;
+    const rejected = rejection === null ? "" : `; ${rejection}`;
+    return `not installed and no pinned asset for this platform (${platform})${rejected}`;
+  }
+  if (rejection !== null) {
+    return `${rejection}, and nothing is vendored (install with \`${installRemedy(status.id)}\`)`;
+  }
+  return `not found (install with \`${installRemedy(status.id)}\`)`;
+}
+function probePathCandidate(entry, binary) {
+  const found = findExecutableOnPath(binary);
+  if (found === null) return null;
+  const probeTarget = binary === entry.primaryBinary ? found : findExecutableOnPath(entry.primaryBinary) ?? found;
+  const version = probeBinaryVersion(probeTarget, entry.versionArgs);
+  return { path: found, version, satisfiesMinimum: satisfiesMinimum(version, entry.minimumVersion) };
+}
+
+export {
+  findExecutableOnPath,
+  resolveToolBinary,
+  toolStatus,
+  toolStatuses,
+  installRemedy,
+  describeFloorRejection,
+  describeResolution
+};
+//# sourceMappingURL=chunk-QSNYB6ZV.js.map