@iowarp/clio-coder 0.3.8 → 0.4.0

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

package/dist/{chunk-GOXNB3AO.js → chunk-RAPCMZL4.js}

@@ -1,7 +1,4 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  AUTONOMY_EXPOSURES
-} from "./chunk-HWUFFB6L.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -72,6 +69,73 @@ function isSkillActivation(value) {
   return typeof record.name === "string" && typeof record.filePath === "string" && typeof record.hash === "string" && typeof record.source === "string" && (record.sourceOrigin === void 0 || typeof record.sourceOrigin === "string") && (record.triggeredBy === "slash-command" || record.triggeredBy === "tool") && (record.turnId === void 0 || typeof record.turnId === "string") && (record.runId === void 0 || typeof record.runId === "string");
 }
 
+// src/domains/safety/autonomy.ts
+init_esm_shims();
+var AUTONOMY_LEVELS = ["read-only", "suggest", "auto-edit", "full-auto"];
+var DEFAULT_AUTONOMY_LEVEL = "auto-edit";
+function isAutonomyLevel(value) {
+  return typeof value === "string" && AUTONOMY_LEVELS.includes(value);
+}
+var AUTONOMY_EXPOSURES = ["local", "outward"];
+var DEFAULT_AUTONOMY_EXPOSURE = "local";
+function mapAutonomy(level, actionClass, options = {}) {
+  if (actionClass === "git_destructive") return "deny";
+  if ((level === "auto-edit" || level === "suggest") && options.exposure === "outward") return "ask";
+  if (actionClass === "read") return "allow";
+  if (level === "read-only") return "deny";
+  if (level === "suggest") return "ask";
+  switch (actionClass) {
+    case "write":
+      return "allow";
+    case "dispatch":
+      if (options.dispatchPlanScale === true && level !== "full-auto") return "ask";
+      return "allow";
+    case "execute": {
+      if (options.executeRecognized !== false) return "allow";
+      return level === "full-auto" ? "allow" : "ask";
+    }
+    case "unknown":
+      return "ask";
+    default:
+      return "ask";
+  }
+}
+function autonomyDenyRejection(level, tool, actionClass) {
+  return {
+    short: `${tool} denied: autonomy level is ${level}`,
+    detail: `Clio is at autonomy ${level}: ${actionClass} actions are denied without prompting. Describe the change you would make instead, so the operator can apply it or raise the autonomy level.`,
+    hints: ["Propose the exact edit or command as text.", "The operator can change the level in /settings."]
+  };
+}
+function autonomyAskRejection(level, tool, actionClass, exposure = DEFAULT_AUTONOMY_EXPOSURE) {
+  if (exposure === "outward") {
+    return {
+      short: `${tool} needs approval: outward-facing gate at autonomy ${level}`,
+      detail: `The call declared exposure=outward, so answering it publishes or sends something outside the workspace. Autonomy ${level} auto-answers local gates and parks outward-facing ones for the operator.`,
+      hints: [
+        "Approving resumes only this call.",
+        "Autonomy full-auto answers outward gates too; the safety net still applies there."
+      ]
+    };
+  }
+  return {
+    short: `${tool} needs approval (${actionClass}) at autonomy ${level}`,
+    detail: `Autonomy ${level} routes ${actionClass} actions through operator approval. The call is parked until the operator approves it once or cancels it.`,
+    hints: [
+      "Approving resumes only this call.",
+      "Recognized commands can be added to .clio-coder/safety.yaml.",
+      // The sanctioned pivots for a gated shell command: typed verification
+      // and read-class observe tools run without approval at this level,
+      // and models otherwise stall retrying denied bash for checks or
+      // directory listings.
+      ...actionClass === "execute" ? [
+        'A declared package or project-catalog check runs without approval through the verify tool: verify(check="<id>").',
+        "Read-only inspection runs without approval through the ls, read, grep, and find tools."
+      ] : []
+    ]
+  };
+}
+
 // src/domains/session/entries.ts
 init_esm_shims();
 var EVICTION_REASONS = [
@@ -255,7 +319,14 @@ export {
   agentSkillToolPolicy,
   skillActivationFromToolDetails,
   isSkillActivation,
+  AUTONOMY_LEVELS,
+  DEFAULT_AUTONOMY_LEVEL,
+  isAutonomyLevel,
+  DEFAULT_AUTONOMY_EXPOSURE,
+  mapAutonomy,
+  autonomyDenyRejection,
+  autonomyAskRejection,
   isSessionHeader,
   isSessionEntry
 };
-//# sourceMappingURL=chunk-GOXNB3AO.js.map
+//# sourceMappingURL=chunk-RAPCMZL4.js.map

package/dist/chunk-RKKLTLYB.js

@@ -0,0 +1,45 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  require_dist
+} from "./chunk-APJ265NV.js";
+import {
+  __toESM,
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/agents/frontmatter.ts
+init_esm_shims();
+var import_yaml = __toESM(require_dist(), 1);
+function parseFrontmatter(raw, sourcePath) {
+  const opening = raw.match(/^---\r?\n/);
+  if (!opening) {
+    throw new Error(`frontmatter: ${sourcePath}: missing YAML frontmatter opening delimiter`);
+  }
+  const closeRegex = /\r?\n---(?:\r?\n|$)/g;
+  closeRegex.lastIndex = opening[0].length;
+  const closing = closeRegex.exec(raw);
+  if (!closing) {
+    throw new Error(`frontmatter: ${sourcePath}: missing YAML frontmatter closing delimiter`);
+  }
+  const frontmatterText = raw.slice(opening[0].length, closing.index);
+  const body = raw.slice(closing.index + closing[0].length);
+  let parsed;
+  try {
+    parsed = import_yaml.default.parse(frontmatterText);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(`frontmatter: ${sourcePath}: invalid YAML frontmatter (${reason})`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`frontmatter: ${sourcePath}: frontmatter must be a YAML object`);
+  }
+  return {
+    frontmatter: parsed,
+    body
+  };
+}
+
+export {
+  parseFrontmatter
+};
+//# sourceMappingURL=chunk-RKKLTLYB.js.map

package/dist/{chunk-P43ETTHK.js → chunk-SJ5ZKQ4S.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-H7IXIC72.js";
 import {
   isAgentCapabilityClass
-} from "./chunk-AOCYTWAV.js";
+} from "./chunk-DYJP44XW.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -995,4 +995,4 @@ export {
   routingIntentRejection,
   explainRouteDecision
 };
-//# sourceMappingURL=chunk-P43ETTHK.js.map
+//# sourceMappingURL=chunk-SJ5ZKQ4S.js.map

package/dist/{chunk-GPIEI3LY.js → chunk-SP2RXXYO.js}

@@ -3,13 +3,13 @@ import {
   INTEROP_AGENT_KINDS,
   interopAgentKind
 } from "./chunk-IHXBNWMM.js";
-import {
-  runCommandVector
-} from "./chunk-B5CSFE7B.js";
 import {
   readSettings,
   updateSettings
-} from "./chunk-IJ7RPIYJ.js";
+} from "./chunk-VFA6GDY5.js";
+import {
+  runCommandVector
+} from "./chunk-BBVJUZHB.js";
 import {
   withStateFileLockSync
 } from "./chunk-IKCO5N3L.js";
@@ -18,7 +18,7 @@ import {
 } from "./chunk-APJ265NV.js";
 import {
   clioStateDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -27,53 +27,6 @@ import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
 
-// src/domains/providers/probe/fingerprint.ts
-init_esm_shims();
-async function fetchWithTimeout(url, timeoutMs) {
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    return await fetch(url, { signal: controller.signal });
-  } catch {
-    return null;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function fingerprintNativeRuntime(baseUrl) {
-  const normalized = baseUrl.replace(/^ws:/u, "http:").replace(/^wss:/u, "https:");
-  const trimmed = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
-  const greeting = await fetchWithTimeout(`${trimmed}/lmstudio-greeting`, 750);
-  if (greeting?.ok) {
-    try {
-      const data = await greeting.json();
-      if (data.lmstudio === true) return { runtimeId: "lmstudio", displayName: "LM Studio" };
-    } catch {
-    }
-  }
-  const lmStudioV0 = await fetchWithTimeout(`${trimmed}/api/v0/models`, 750);
-  if (lmStudioV0?.ok) {
-    try {
-      const data = await lmStudioV0.json();
-      if (Array.isArray(data.data) && data.data.some((entry) => typeof entry === "object" && entry !== null && "compatibility_type" in entry)) {
-        return { runtimeId: "lmstudio", displayName: "LM Studio" };
-      }
-    } catch {
-    }
-  }
-  const ollama = await fetchWithTimeout(`${trimmed}/api/version`, 750);
-  if (ollama?.ok) {
-    try {
-      const data = await ollama.json();
-      if (typeof data.version === "string") {
-        return { runtimeId: "ollama-native", displayName: "Ollama" };
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-
 // src/domains/interop/index.ts
 init_esm_shims();
 
@@ -467,7 +420,6 @@ var InteropDomainModule = {
 };
 
 export {
-  fingerprintNativeRuntime,
   INHERITED_PROJECT_CONTEXT,
   delegationEntryForKind,
   interopProposals,
@@ -478,4 +430,4 @@ export {
   detectInteropAgents,
   InteropDomainModule
 };
-//# sourceMappingURL=chunk-GPIEI3LY.js.map
+//# sourceMappingURL=chunk-SP2RXXYO.js.map

package/dist/chunk-SUCTJL45.js

@@ -0,0 +1,45 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  PANES_PRESET_IDS
+} from "./chunk-YJX4SHTD.js";
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-K6BSR66V.js";
+import {
+  StringEnum
+} from "./chunk-UOSL25KY.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/panes-surface.ts
+init_esm_shims();
+var panesToolSurface = {
+  name: ToolNames.Panes,
+  description: `Look at, focus, and manage the terminal panes Clio owns beside this session. Use show to bring a dispatched run's live viewer pane to the front when the operator asks to see an agent ("show me the tester"). open starts one of the fixed utility presets; there is no way to run an arbitrary command. close removes a pane Clio created. list reports the current inventory and the pane layer's health.`,
+  parameters: typebox_exports.Object({
+    action: StringEnum(["show", "open", "close", "list"], {
+      description: "show focuses a run's viewer pane; open starts a preset utility pane; close removes a Clio-owned pane; list reports the inventory."
+    }),
+    target: typebox_exports.Optional(
+      typebox_exports.String({
+        description: 'action=show: an agent id or run id prefix, most recent match wins. action=close: a pane id, a pane label, an agent id, or "all".'
+      })
+    ),
+    preset: typebox_exports.Optional(
+      StringEnum([...PANES_PRESET_IDS], {
+        description: "action=open: which fixed utility pane to start."
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "sequential"
+};
+
+export {
+  panesToolSurface
+};
+//# sourceMappingURL=chunk-SUCTJL45.js.map