@iowarp/clio-coder 0.3.8 → 0.4.0

package/dist/{chunk-DYIM5TJT.js → chunk-SUW5DORT.js}

@@ -1,10 +1,13 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getVersionInfo
+} from "./chunk-XPLRXC72.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
 import {
   clioConfigDir
-} from "./chunk-BNAZZHFG.js";
+} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -18,6 +21,220 @@ init_esm_shims();
 var import_yaml = __toESM(require_dist(), 1);
 import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import path from "node:path";
+
+// src/domains/extensions/compatibility.ts
+init_esm_shims();
+var MAX_RANGE_CHARS = 256;
+var NUMERIC = "(?:0|[1-9]\\d*)";
+var IDENTIFIER = "[0-9A-Za-z-]+";
+var VERSION_RE = new RegExp(
+  `^v?(${NUMERIC})\\.(${NUMERIC})\\.(${NUMERIC})(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+var PARTIAL_RE = new RegExp(
+  `^v?(${NUMERIC}|[xX*])(?:\\.(${NUMERIC}|[xX*]))?(?:\\.(${NUMERIC}|[xX*]))?(?:-(${IDENTIFIER}(?:\\.${IDENTIFIER})*))?(?:\\+${IDENTIFIER}(?:\\.${IDENTIFIER})*)?$`
+);
+function prerelease(value) {
+  if (value === void 0) return [];
+  const out = [];
+  for (const identifier of value.split(".")) {
+    if (identifier.length === 0) return null;
+    if (/^\d+$/u.test(identifier)) {
+      if (identifier.length > 1 && identifier.startsWith("0")) return null;
+      const parsed = Number(identifier);
+      if (!Number.isSafeInteger(parsed)) return null;
+      out.push(parsed);
+    } else {
+      out.push(identifier);
+    }
+  }
+  return out;
+}
+function parseSemVer(value) {
+  const match = VERSION_RE.exec(value);
+  if (match === null) return null;
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  const patch = Number(match[3]);
+  if (![major, minor, patch].every(Number.isSafeInteger)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function parsePart(value) {
+  if (value === void 0 || value === "x" || value === "X" || value === "*") return null;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+function parsePartial(value) {
+  const match = PARTIAL_RE.exec(value);
+  if (match === null) return null;
+  for (const part of match.slice(1, 4)) {
+    if (part === void 0 || part === "x" || part === "X" || part === "*") continue;
+    if (!Number.isSafeInteger(Number(part))) return null;
+  }
+  const major = parsePart(match[1]);
+  const minor = parsePart(match[2]);
+  const patch = parsePart(match[3]);
+  if (major === null && (match[2] !== void 0 || match[3] !== void 0) || minor === null && match[3] !== void 0) {
+    return null;
+  }
+  const parsedPrerelease = prerelease(match[4]);
+  if (parsedPrerelease === null) return null;
+  if (parsedPrerelease.length > 0 && (major === null || minor === null || patch === null)) return null;
+  return { major, minor, patch, prerelease: parsedPrerelease };
+}
+function compareIdentifiers(left, right) {
+  if (left === right) return 0;
+  if (typeof left === "number" && typeof right === "number") return left < right ? -1 : 1;
+  if (typeof left === "number") return -1;
+  if (typeof right === "number") return 1;
+  return left < right ? -1 : 1;
+}
+function compare(left, right) {
+  for (const key of ["major", "minor", "patch"]) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1;
+  }
+  if (left.prerelease.length === 0 || right.prerelease.length === 0) {
+    if (left.prerelease.length === right.prerelease.length) return 0;
+    return left.prerelease.length === 0 ? 1 : -1;
+  }
+  const length = Math.max(left.prerelease.length, right.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = left.prerelease[index];
+    const rightPart = right.prerelease[index];
+    if (leftPart === void 0 || rightPart === void 0) {
+      if (leftPart === rightPart) return 0;
+      return leftPart === void 0 ? -1 : 1;
+    }
+    const order = compareIdentifiers(leftPart, rightPart);
+    if (order !== 0) return order;
+  }
+  return 0;
+}
+function floor(partial) {
+  return {
+    major: partial.major ?? 0,
+    minor: partial.minor ?? 0,
+    patch: partial.patch ?? 0,
+    prerelease: partial.prerelease
+  };
+}
+function nextWildcard(partial) {
+  if (partial.major === null) return null;
+  if (partial.minor === null) return { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] };
+  if (partial.patch === null) return { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+  return null;
+}
+function lowerBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) >= 0 : compare(candidate, version) > 0;
+}
+function upperBound(version, inclusive) {
+  return (candidate) => inclusive ? compare(candidate, version) <= 0 : compare(candidate, version) < 0;
+}
+function core(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+function predicatesForToken(token) {
+  const match = /^(<=|>=|<|>|=|~|\^)?(.+)$/u.exec(token);
+  if (match === null) return null;
+  const operator = match[1] ?? "";
+  const partial = parsePartial(match[2] ?? "");
+  if (partial === null) return null;
+  const base = floor(partial);
+  const wildcardUpper = nextWildcard(partial);
+  const prereleaseCore = partial.prerelease.length > 0 ? core(base) : null;
+  if (operator === "" || operator === "=") {
+    if (partial.major === null) return { predicates: [], prereleaseCore };
+    if (wildcardUpper !== null) {
+      return { predicates: [lowerBound(base, true), upperBound(wildcardUpper, false)], prereleaseCore };
+    }
+    return { predicates: [(candidate) => compare(candidate, base) === 0], prereleaseCore };
+  }
+  if (operator === ">=") return { predicates: [lowerBound(base, true)], prereleaseCore };
+  if (operator === "<") return { predicates: [upperBound(base, false)], prereleaseCore };
+  if (operator === ">") {
+    return {
+      predicates: [wildcardUpper === null ? lowerBound(base, false) : lowerBound(wildcardUpper, true)],
+      prereleaseCore
+    };
+  }
+  if (operator === "<=") {
+    return {
+      predicates: [wildcardUpper === null ? upperBound(base, true) : upperBound(wildcardUpper, false)],
+      prereleaseCore
+    };
+  }
+  if (partial.major === null) return { predicates: [], prereleaseCore };
+  if (operator === "~") {
+    const upper2 = partial.minor === null ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : { major: partial.major, minor: partial.minor + 1, patch: 0, prerelease: [] };
+    return { predicates: [lowerBound(base, true), upperBound(upper2, false)], prereleaseCore };
+  }
+  const upper = partial.major > 0 ? { major: partial.major + 1, minor: 0, patch: 0, prerelease: [] } : partial.minor === null ? { major: 1, minor: 0, patch: 0, prerelease: [] } : (partial.minor ?? 0) > 0 ? { major: 0, minor: (partial.minor ?? 0) + 1, patch: 0, prerelease: [] } : partial.patch === null ? { major: 0, minor: 1, patch: 0, prerelease: [] } : { major: 0, minor: 0, patch: (partial.patch ?? 0) + 1, prerelease: [] };
+  return { predicates: [lowerBound(base, true), upperBound(upper, false)], prereleaseCore };
+}
+function predicatesForSet(raw) {
+  const hyphen = /^(\S+)\s+-\s+(\S+)$/u.exec(raw);
+  if (hyphen !== null) {
+    const left = parsePartial(hyphen[1] ?? "");
+    const right = parsePartial(hyphen[2] ?? "");
+    if (left === null || right === null || left.major === null || right.major === null) return null;
+    const rightUpper = nextWildcard(right);
+    return {
+      predicates: [
+        lowerBound(floor(left), true),
+        rightUpper === null ? upperBound(floor(right), true) : upperBound(rightUpper, false)
+      ],
+      prereleaseCores: new Set(
+        [
+          left.prerelease.length > 0 ? core(floor(left)) : null,
+          right.prerelease.length > 0 ? core(floor(right)) : null
+        ].filter((entry) => entry !== null)
+      )
+    };
+  }
+  const normalized = raw.replace(/(<=|>=|<|>|=|~|\^)\s+/gu, "$1");
+  const tokens = normalized.split(/\s+/u).filter((entry) => entry.length > 0);
+  if (tokens.length === 0) return null;
+  const predicates = [];
+  const prereleaseCores = /* @__PURE__ */ new Set();
+  for (const token of tokens) {
+    const parsed = predicatesForToken(token);
+    if (parsed === null) return null;
+    predicates.push(...parsed.predicates);
+    if (parsed.prereleaseCore !== null) prereleaseCores.add(parsed.prereleaseCore);
+  }
+  return { predicates, prereleaseCores };
+}
+function parseRange(range) {
+  const trimmed = range.trim();
+  if (trimmed.length === 0 || trimmed.length > MAX_RANGE_CHARS) return null;
+  const sets = trimmed.split("||");
+  if (sets.some((set) => set.trim().length === 0)) return null;
+  const parsed = sets.map((set) => predicatesForSet(set.trim()));
+  return parsed.every((set) => set !== null) ? parsed : null;
+}
+function isValidSemVerRange(range) {
+  return parseRange(range) !== null;
+}
+function satisfiesSemVerRange(version, range) {
+  const candidate = parseSemVer(version);
+  const sets = parseRange(range);
+  if (candidate === null || sets === null) return false;
+  return sets.some((set) => {
+    if (candidate.prerelease.length > 0 && !set.prereleaseCores.has(core(candidate))) return false;
+    return set.predicates.every((predicate) => predicate(candidate));
+  });
+}
+function evaluateClioCompatibility(range, runningVersion = getVersionInfo().clio) {
+  const rangeValid = isValidSemVerRange(range);
+  return {
+    rangeValid,
+    satisfied: rangeValid && satisfiesSemVerRange(runningVersion, range),
+    runningVersion
+  };
+}
+
+// src/domains/extensions/discovery.ts
 var MANIFEST_NAMES = ["clio-coder-extension.yaml", "clio-coder-extension.yml", "clio-coder-extension.json"];
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -150,7 +367,32 @@ function parseExtensionManifest(value, manifestPath) {
   const resources = normalizeResources(value.resources);
   const tools = stringArray(value.tools);
   const settings = stringArray(value.settings);
-  const compatibility = isRecord(value.compatibility) ? { ...trimString(value.compatibility.clio) ? { clio: trimString(value.compatibility.clio) } : {} } : void 0;
+  let compatibility;
+  if (value.compatibility !== void 0) {
+    if (!isRecord(value.compatibility)) {
+      diagnostics.push({ type: "error", message: "compatibility must be an object", path: manifestPath });
+    } else if ("clio" in value.compatibility) {
+      const range = trimString(value.compatibility.clio);
+      if (range === void 0) {
+        diagnostics.push({
+          type: "error",
+          message: "compatibility.clio must be a non-empty semver range",
+          path: manifestPath
+        });
+      } else {
+        const evaluation = evaluateClioCompatibility(range);
+        if (!evaluation.rangeValid) {
+          diagnostics.push({
+            type: "error",
+            message: `extension ${id ?? "<unknown>"} declares malformed compatibility.clio range '${range}'`,
+            path: manifestPath
+          });
+        } else {
+          compatibility = { clio: range };
+        }
+      }
+    }
+  }
   if (!id || !name || !version || !description || diagnostics.some((diag) => diag.type === "error")) {
     return { diagnostics };
   }
@@ -165,6 +407,17 @@ function parseExtensionManifest(value, manifestPath) {
   if (tools) manifest.tools = tools;
   if (settings) manifest.settings = settings;
   if (compatibility && Object.keys(compatibility).length > 0) manifest.compatibility = compatibility;
+  const clioRange = manifest.compatibility?.clio;
+  if (clioRange !== void 0) {
+    const evaluation = evaluateClioCompatibility(clioRange);
+    if (!evaluation.satisfied) {
+      diagnostics.push({
+        type: "error",
+        message: `extension ${manifest.id} requires Clio '${clioRange}', but running Clio version is '${evaluation.runningVersion}'`,
+        path: manifestPath
+      });
+    }
+  }
   return { manifest, diagnostics };
 }
 function findExtensionManifestPath(root) {
@@ -296,6 +549,8 @@ function installedFromRoot(root, scope, state) {
   const candidate = loadManifestFromRoot(root);
   const manifest = candidate.manifest;
   if (!manifest || !candidate.manifestPath) return null;
+  const clioRange = manifest.compatibility?.clio;
+  const compatible = clioRange === void 0 || evaluateClioCompatibility(clioRange).satisfied;
   return {
     id: manifest.id,
     name: manifest.name,
@@ -305,6 +560,7 @@ function installedFromRoot(root, scope, state) {
     rootPath: root,
     manifestPath: candidate.manifestPath,
     enabled: !state.disabled.includes(manifest.id),
+    compatible,
     effective: false,
     resources: manifest.resources,
     diagnostics: candidate.diagnostics
@@ -333,13 +589,13 @@ function listInstalledExtensions(cwd = process.cwd(), options = {}) {
     byId.set(entry.id, list);
   }
   for (const group of byId.values()) {
-    const winner = [...group].sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
+    const winner = group.filter((entry) => entry.compatible).sort((a, b) => scopeRank(a.scope) - scopeRank(b.scope)).at(-1);
     for (const entry of group) {
       entry.effective = entry === winner;
-      if (!entry.effective && winner) entry.overriddenBy = winner.scope;
+      if (entry.compatible && !entry.effective && winner) entry.overriddenBy = winner.scope;
     }
   }
-  const all = options.all === true ? entries : entries.filter((entry) => entry.effective);
+  const all = options.all === true ? entries : entries.filter((entry) => entry.effective || !entry.compatible);
   return all.sort((a, b) => {
     const id = a.id.localeCompare(b.id);
     if (id !== 0) return id;
@@ -481,7 +737,7 @@ function extensionResourcePath(rootPath, resourcePath) {
 function enabledExtensionResourceRoots(kind, cwd = process.cwd()) {
   const roots = [];
   for (const entry of listInstalledExtensions(cwd)) {
-    if (!entry.enabled || !entry.effective) continue;
+    if (!entry.enabled || !entry.compatible || !entry.effective) continue;
     const rel = entry.resources[kind];
     if (!rel) continue;
     const full = extensionResourcePath(entry.rootPath, rel);
@@ -560,4 +816,4 @@ export {
   enabledExtensionResourceRoots,
   ExtensionsDomainModule
 };
-//# sourceMappingURL=chunk-DYIM5TJT.js.map
+//# sourceMappingURL=chunk-SUW5DORT.js.map

package/dist/chunk-T56WDKA5.js

@@ -0,0 +1,183 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/dispatch/event-pump.ts
+init_esm_shims();
+var EVENT_TEE_LIMIT = 1024;
+function startDispatchEventPump(source, fold, options = {}) {
+  const limit = options.limit ?? EVENT_TEE_LIMIT;
+  const pending = [...options.prelude ?? []];
+  const waiters = [];
+  let finished = false;
+  let abandoned = false;
+  let dropped = 0;
+  const push = (value) => {
+    if (abandoned) return;
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter({ value, done: false });
+      return;
+    }
+    pending.push(value);
+    while (pending.length > limit) {
+      pending.shift();
+      dropped += 1;
+    }
+  };
+  const end = () => {
+    finished = true;
+    while (waiters.length > 0) {
+      waiters.shift()?.({ value: void 0, done: true });
+    }
+  };
+  const notify = (event) => {
+    try {
+      options.onEvent?.(event);
+    } catch (error) {
+      options.onError?.(error);
+    }
+  };
+  const done = (async () => {
+    try {
+      for (const event of options.prelude ?? []) notify(event);
+      for await (const event of source) {
+        try {
+          fold(event);
+        } catch (error) {
+          options.onError?.(error);
+        }
+        notify(event);
+        push(event);
+      }
+    } catch (error) {
+      options.onError?.(error);
+    } finally {
+      end();
+    }
+  })();
+  const events = {
+    next() {
+      if (pending.length > 0) {
+        return Promise.resolve({ value: pending.shift(), done: false });
+      }
+      if (finished || abandoned) return Promise.resolve({ value: void 0, done: true });
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+      });
+    },
+    return() {
+      abandoned = true;
+      pending.length = 0;
+      while (waiters.length > 0) {
+        waiters.shift()?.({ value: void 0, done: true });
+      }
+      return Promise.resolve({ value: void 0, done: true });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  return { events, done, droppedEvents: () => dropped };
+}
+var WORKER_OUTPUT_MAX_BYTES = 8192;
+var WORKER_OUTPUT_TRUNCATION_MARKER = "\n[worker output truncated]";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assistantTextFromContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((block) => {
+    if (typeof block === "string") return block;
+    if (!isRecord(block)) return "";
+    return typeof block.text === "string" ? block.text : "";
+  }).join("");
+}
+function isDurableAssistantMessage(message) {
+  const stopReason = message.stopReason;
+  if (stopReason === "toolUse" || stopReason === "error" || stopReason === "aborted" || stopReason === "cancelled") {
+    return false;
+  }
+  if (!Array.isArray(message.content)) return true;
+  return !message.content.some((block) => isRecord(block) && block.type === "toolCall");
+}
+function durableAssistantTextFromEvent(event) {
+  if (!isRecord(event) || event.type !== "message_end" || !isRecord(event.message)) return "";
+  if (event.message.role !== "assistant" || !isDurableAssistantMessage(event.message)) return "";
+  return assistantTextFromContent(event.message.content);
+}
+function boundedOutput(state, text) {
+  const bytes = Buffer.byteLength(text, "utf8");
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+  return { state, text: bounded, bytes, truncated: bounded !== text };
+}
+function createWorkerOutputCapture() {
+  let finalText = null;
+  let partialText = "";
+  let partialBytes = 0;
+  let partialStored = 0;
+  return {
+    observe(event) {
+      if (!isRecord(event)) return;
+      if (event.type === "message_end") {
+        const message = isRecord(event.message) ? event.message : null;
+        partialText = "";
+        partialBytes = 0;
+        partialStored = 0;
+        if (message === null || message.role !== "assistant") return;
+        if (!isDurableAssistantMessage(message)) return;
+        const text = assistantTextFromContent(message.content).trim();
+        if (text.length > 0) finalText = text;
+        return;
+      }
+      if (event.type !== "message_update") return;
+      const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+      if (assistantEvent === null || assistantEvent.type !== "text_delta") return;
+      const delta = assistantEvent.delta;
+      if (typeof delta !== "string" || delta.length === 0) return;
+      partialBytes += Buffer.byteLength(delta, "utf8");
+      if (partialStored < WORKER_OUTPUT_MAX_BYTES) {
+        partialText += delta;
+        partialStored += Buffer.byteLength(delta, "utf8");
+      }
+    },
+    snapshot() {
+      if (partialBytes > 0 && partialText.trim().length > 0) {
+        const bounded = truncateUtf8(partialText.trim(), WORKER_OUTPUT_MAX_BYTES, WORKER_OUTPUT_TRUNCATION_MARKER);
+        return {
+          state: "partial",
+          text: bounded,
+          bytes: partialBytes,
+          truncated: bounded !== partialText.trim() || partialBytes > partialStored
+        };
+      }
+      if (finalText !== null) return boundedOutput("final", finalText);
+      return void 0;
+    }
+  };
+}
+
+// src/domains/dispatch/admission-error.ts
+init_esm_shims();
+var AdmissionCanceledError = class extends Error {
+  code = "admission_canceled";
+  constructor(message = "dispatch: admission canceled before a capacity slot opened") {
+    super(message);
+    this.name = "AdmissionCanceledError";
+  }
+};
+
+export {
+  EVENT_TEE_LIMIT,
+  startDispatchEventPump,
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent,
+  createWorkerOutputCapture,
+  AdmissionCanceledError
+};
+//# sourceMappingURL=chunk-T56WDKA5.js.map