@iowarp/clio-coder 0.3.8 → 0.3.9

package/dist/{chunk-DYIM5TJT.js → chunk-5QKCQQ3E.js}

@@ -1,4 +1,7 @@
 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";
@@ -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-5QKCQQ3E.js.map

package/dist/{chunk-TYPGUK6W.js → chunk-5T7RBWN2.js}

@@ -1,12 +1,14 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   inspectEvidence
-} from "./chunk-TLQJPP24.js";
+} from "./chunk-TEO2TLVN.js";
 import {
   TASK_MEMORY_CONTENT_MAX_CHARS,
   TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP,
-  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP
-} from "./chunk-ZVJ5BLO2.js";
+  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
+  TASK_MEMORY_TELEMETRY_FILE,
+  parseTaskMemoryTelemetryRecord
+} from "./chunk-O6I4CIEU.js";
 import {
   createRedactionTally,
   redactSecretsText
@@ -16,7 +18,10 @@ import {
 } from "./chunk-ECH6PKUQ.js";
 import {
   ceilChars
-} from "./chunk-RWSI4YD7.js";
+} from "./chunk-AEYBF3TB.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
@@ -1116,6 +1121,30 @@ function compareStrings3(a, b) {
   return a.localeCompare(b);
 }
 
+// src/domains/memory/task-bank-promotion.ts
+init_esm_shims();
+async function proposeInjectedTaskMemory(dataDir, input) {
+  const result = { records: [], errors: [] };
+  const sessionId = input.sessionId;
+  const repository = canonicalMemoryRepositoryIdentity(input.cwd);
+  if (sessionId === null || sessionId.length === 0 || repository === null) return result;
+  for (const entry of input.entries) {
+    if (entry.kind === "status") continue;
+    try {
+      const proposal = await proposeMemoryPromotion(
+        dataDir,
+        { kind: "task-bank-entry", sessionId, evidenceRefs: [`session:${sessionId}`], entry },
+        { scope: "repo", repository },
+        input.now ?? /* @__PURE__ */ new Date()
+      );
+      result.records.push(proposal.record);
+    } catch (error) {
+      result.errors.push(`${entry.id}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return result;
+}
+
 // src/domains/memory/task-memory-handoff.ts
 init_esm_shims();
 import { existsSync, readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
@@ -1367,6 +1396,80 @@ function compareStrings4(left, right) {
   return left < right ? -1 : left > right ? 1 : 0;
 }
 
+// src/domains/memory/task-memory-spend.ts
+init_esm_shims();
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function taskMemoryStepsPath(stateDir = clioStateDir()) {
+  return join3(stateDir, "memory", TASK_MEMORY_TELEMETRY_FILE);
+}
+function emptyTaskMemorySpendSummary() {
+  return {
+    llmSteps: 0,
+    injections: 0,
+    hitRate: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    modelMs: 0,
+    slowestStepMs: 0,
+    timeouts: 0,
+    endpointBusySkips: 0,
+    firstAt: null,
+    lastAt: null
+  };
+}
+function foldTaskMemorySpend(lines) {
+  const summary = emptyTaskMemorySpendSummary();
+  for (const line of lines) {
+    if (line.trim().length === 0) continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = parseTaskMemoryTelemetryRecord(parsed);
+    if (record === null) continue;
+    if (summary.firstAt === null || record.at < summary.firstAt) summary.firstAt = record.at;
+    if (summary.lastAt === null || record.at > summary.lastAt) summary.lastAt = record.at;
+    if (record.reason === "endpoint_busy") summary.endpointBusySkips += 1;
+    if (record.tier !== "llm") continue;
+    summary.llmSteps += 1;
+    if (record.decision === "injected") summary.injections += 1;
+    if (record.decision === "timeout") summary.timeouts += 1;
+    summary.inputTokens += record.tokenCost.input;
+    summary.outputTokens += record.tokenCost.output;
+    summary.totalTokens += record.tokenCost.total;
+    summary.modelMs += record.latencyMs;
+    summary.slowestStepMs = Math.max(summary.slowestStepMs, record.latencyMs);
+  }
+  summary.hitRate = summary.llmSteps === 0 ? 0 : summary.injections / summary.llmSteps;
+  return summary;
+}
+var spendCache = /* @__PURE__ */ new Map();
+function readTaskMemorySpendSummary(stateDir = clioStateDir()) {
+  const path = taskMemoryStepsPath(stateDir);
+  try {
+    const info = statSync2(path);
+    const cached = spendCache.get(path);
+    if (cached !== void 0 && cached.mtimeMs === info.mtimeMs && cached.size === info.size) return cached.summary;
+    const summary = foldTaskMemorySpend(readFileSync3(path, "utf8").split("\n"));
+    spendCache.set(path, { mtimeMs: info.mtimeMs, size: info.size, summary });
+    return summary;
+  } catch {
+    return emptyTaskMemorySpendSummary();
+  }
+}
+function formatTaskMemorySpend(summary) {
+  if (summary.llmSteps === 0) return "";
+  const tokens = summary.totalTokens >= 1e3 ? `${(summary.totalTokens / 1e3).toFixed(1)}k tok` : `${summary.totalTokens} tok`;
+  const seconds = summary.modelMs / 1e3;
+  const time = seconds >= 60 ? `${(seconds / 60).toFixed(1)}m` : `${seconds.toFixed(1)}s`;
+  const rate = `${Math.round(summary.hitRate * 100)}%`;
+  return `spend ${summary.llmSteps} steps \xB7 ${tokens} \xB7 ${time} \xB7 hit ${summary.injections}/${summary.llmSteps} (${rate})`;
+}
+
 // src/domains/memory/task-memory-status.ts
 init_esm_shims();
 function describeTaskMemoryActivity(event) {
@@ -1441,13 +1544,16 @@ export {
   proposeMemoryPromotion,
   buildMemoryPromptSection,
   proposeMemoryFromEvidence,
+  proposeInjectedTaskMemory,
   renderTaskMemoryHandoffSource,
   parseTaskMemoryHandoffSnapshot,
   taskMemoryHandoffSeedOffer,
   seedTaskMemoryFromNewestHandoff,
+  readTaskMemorySpendSummary,
+  formatTaskMemorySpend,
   describeTaskMemoryActivity,
   taskMemoryBankSize,
   taskMemoryTracePath,
   createTaskMemoryTrace
 };
-//# sourceMappingURL=chunk-TYPGUK6W.js.map
+//# sourceMappingURL=chunk-5T7RBWN2.js.map

package/dist/{chunk-IIZWH4XA.js → chunk-774ILSRL.js}

@@ -9,7 +9,7 @@ import {
 import {
   catalogProviderForRuntime,
   listCatalogModelsForRuntime
-} from "./chunk-PT7HYKEM.js";
+} from "./chunk-VO2LKSTM.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -169,4 +169,4 @@ export {
   configuredTargetsForRuntime,
   resolveProviderReference
 };
-//# sourceMappingURL=chunk-IIZWH4XA.js.map
+//# sourceMappingURL=chunk-774ILSRL.js.map