@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-6SGHMWE3.js

@@ -0,0 +1,277 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  assistantTextFromEvent
+} from "./chunk-XBXAASKX.js";
+import {
+  compileExecutionPlan,
+  durableAssistantTextFromEvent
+} from "./chunk-SRDMMSEP.js";
+import {
+  deriveExecutionRole
+} from "./chunk-GGXXDWE4.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  BusChannels
+} from "./chunk-OQ33BKR3.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/dispatch-run-events.ts
+init_esm_shims();
+var RUN_TAIL_ENTRY_LIMIT = 100;
+var RUN_TAIL_RUN_LIMIT = 64;
+var RUN_TAIL_TEXT_LIMIT = 600;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function eventDetail(event) {
+  const text = assistantTextFromEvent(event);
+  if (text.length > 0) return truncateUtf8(text, RUN_TAIL_TEXT_LIMIT, "...");
+  if (!isRecord(event)) return void 0;
+  if (event.type === "clio_tool_finish" && isRecord(event.payload)) {
+    const tool = typeof event.payload.tool === "string" ? event.payload.tool : "tool";
+    const outcome = typeof event.payload.outcome === "string" ? event.payload.outcome : "";
+    return `${tool} ${outcome}`.trim();
+  }
+  if (event.type === "attempt_start") {
+    const attempt = typeof event.attempt === "number" ? event.attempt : "?";
+    const runId = typeof event.runId === "string" ? event.runId : "?";
+    const reason = typeof event.reason === "string" ? event.reason : "retry";
+    return truncateUtf8(`attempt ${attempt} -> ${runId}: ${reason}`, RUN_TAIL_TEXT_LIMIT, "...");
+  }
+  return void 0;
+}
+function createDispatchRunEventRegistry() {
+  const runTails = /* @__PURE__ */ new Map();
+  const activeRuns = /* @__PURE__ */ new Set();
+  const activeBatches = /* @__PURE__ */ new Set();
+  const pruneRunTails = () => {
+    while (runTails.size > RUN_TAIL_RUN_LIMIT) {
+      let oldestKey = null;
+      let oldestSeen = Number.POSITIVE_INFINITY;
+      for (const [key, state] of runTails) {
+        if (activeRuns.has(key) || state.lastSeenAt >= oldestSeen) continue;
+        oldestKey = key;
+        oldestSeen = state.lastSeenAt;
+      }
+      if (oldestKey === null) break;
+      runTails.delete(oldestKey);
+    }
+  };
+  const recordRunEvent = (runId, agentId, event) => {
+    const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+    if (type === "heartbeat" || type === "message_update") return;
+    const state = runTails.get(runId) ?? { agentId, entries: [], lastSeenAt: Date.now() };
+    state.lastSeenAt = Date.now();
+    const entry = { at: (/* @__PURE__ */ new Date()).toISOString(), type };
+    const detail = eventDetail(event);
+    if (detail !== void 0) entry.detail = detail;
+    state.entries.push(entry);
+    if (state.entries.length > RUN_TAIL_ENTRY_LIMIT) {
+      state.entries.splice(0, state.entries.length - RUN_TAIL_ENTRY_LIMIT);
+    }
+    runTails.set(runId, state);
+    pruneRunTails();
+  };
+  const drainSingle = async (runId, agentId, events, bus) => {
+    const summary = {
+      count: 0,
+      types: [],
+      lastAssistantText: "",
+      terminalAttemptRunId: runId
+    };
+    for await (const event of events) {
+      summary.count += 1;
+      const type = isRecord(event) && typeof event.type === "string" ? event.type : "unknown";
+      summary.types.push(type);
+      if (type === "attempt_start") summary.lastAssistantText = "";
+      const text = durableAssistantTextFromEvent(event);
+      if (text.trim().length > 0) summary.lastAssistantText = text;
+      recordRunEvent(runId, agentId, event);
+      if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event });
+    }
+    return summary;
+  };
+  const drainBatch = async (batchId, events, bus) => {
+    const summaries = /* @__PURE__ */ new Map();
+    for await (const event of events) {
+      if (!isRecord(event) || event.type !== "batch_run_event") continue;
+      const runId = typeof event.runId === "string" ? event.runId : batchId;
+      const agentId = typeof event.agentId === "string" ? event.agentId : "batch";
+      const inner = event.event;
+      const summary = summaries.get(runId) ?? {
+        count: 0,
+        types: [],
+        lastAssistantText: "",
+        terminalAttemptRunId: runId
+      };
+      summary.count += 1;
+      const type = isRecord(inner) && typeof inner.type === "string" ? inner.type : "unknown";
+      summary.types.push(type);
+      const text = durableAssistantTextFromEvent(inner);
+      if (text.trim().length > 0) summary.lastAssistantText = text;
+      summaries.set(runId, summary);
+      recordRunEvent(runId, agentId, inner);
+      if (type !== "heartbeat") bus?.emit(BusChannels.DispatchProgress, { runId, agentId, event: inner });
+    }
+    return summaries;
+  };
+  return {
+    registerSingle(handle, agentId, bus) {
+      if (activeRuns.has(handle.runId)) {
+        throw new Error(`dispatch event registry: run '${handle.runId}' is already registered`);
+      }
+      activeRuns.add(handle.runId);
+      const summaryPromise = drainSingle(handle.runId, agentId, handle.events, bus);
+      const completion = Promise.allSettled([summaryPromise, handle.finalPromise]).then(
+        ([summaryResult, receiptResult]) => {
+          if (summaryResult.status === "rejected") throw summaryResult.reason;
+          if (receiptResult.status === "rejected") throw receiptResult.reason;
+          return { receipt: receiptResult.value, summary: summaryResult.value };
+        }
+      );
+      void completion.finally(() => {
+        activeRuns.delete(handle.runId);
+        pruneRunTails();
+      }).catch(() => {
+      });
+      return { runId: handle.runId, completion };
+    },
+    registerBatch(handle, agentIds, bus) {
+      if (activeBatches.has(handle.batchId)) {
+        throw new Error(`dispatch event registry: batch '${handle.batchId}' is already registered`);
+      }
+      const duplicateRunId = handle.assignmentIds.find(
+        (runId, index) => handle.assignmentIds.slice(0, index).includes(runId)
+      );
+      if (duplicateRunId !== void 0) {
+        throw new Error(`dispatch event registry: batch '${handle.batchId}' repeats run '${duplicateRunId}'`);
+      }
+      const activeRunId = handle.assignmentIds.find((runId) => activeRuns.has(runId));
+      if (activeRunId !== void 0) {
+        throw new Error(`dispatch event registry: run '${activeRunId}' is already registered`);
+      }
+      activeBatches.add(handle.batchId);
+      for (const runId of handle.assignmentIds) activeRuns.add(runId);
+      const completion = Promise.allSettled([drainBatch(handle.batchId, handle.events, bus), handle.finalPromise]).then(
+        ([summariesResult, receiptsResult]) => {
+          if (summariesResult.status === "rejected") throw summariesResult.reason;
+          if (receiptsResult.status === "rejected") throw receiptsResult.reason;
+          return { receipts: receiptsResult.value, summaries: summariesResult.value };
+        }
+      );
+      void completion.finally(() => {
+        activeBatches.delete(handle.batchId);
+        for (const runId of handle.assignmentIds) activeRuns.delete(runId);
+        pruneRunTails();
+      }).catch(() => {
+      });
+      for (const [index, runId] of handle.assignmentIds.entries()) {
+        if (!runTails.has(runId)) {
+          runTails.set(runId, {
+            agentId: agentIds[index] ?? "unknown",
+            entries: [],
+            lastSeenAt: Date.now()
+          });
+        }
+      }
+      return { batchId: handle.batchId, assignmentIds: handle.assignmentIds, completion };
+    },
+    recordEvent: recordRunEvent,
+    eventTail(runId) {
+      const state = runTails.get(runId);
+      return state === void 0 ? null : { agentId: state.agentId, entries: [...state.entries] };
+    }
+  };
+}
+
+// src/domains/dispatch/scout-transition.ts
+init_esm_shims();
+function scopeFor(authority) {
+  return authority === "read-only" || authority === "verification" ? "readonly" : "workspace";
+}
+function assertReceiptDigest(value) {
+  if (!/^[0-9a-f]{64}$/u.test(value)) throw new Error("scout transition: source receipt digest is invalid");
+}
+function compileScoutTransition(input) {
+  assertReceiptDigest(input.sourceReceiptDigest);
+  if (!input.scout.needsSplit) {
+    return {
+      kind: "settled",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      findings: input.scout.findings.map((finding) => ({ ...finding }))
+    };
+  }
+  const subtasks = input.scout.proposedSubtasks;
+  const byId = new Map(input.bindings.map((binding) => [binding.subtaskId, binding]));
+  if (byId.size !== input.bindings.length || byId.size !== subtasks.length) {
+    throw new Error("scout transition: coordinator bindings must match subtasks exactly");
+  }
+  for (const binding of input.bindings) {
+    if (!subtasks.some((subtask) => subtask.id === binding.subtaskId)) {
+      throw new Error(`scout transition: undeclared binding '${binding.subtaskId}'`);
+    }
+  }
+  const approved = new Set(input.authority.approvedAuthorities);
+  const missing = /* @__PURE__ */ new Set();
+  const steps = subtasks.map((subtask) => {
+    const binding = byId.get(subtask.id);
+    if (binding === void 0) throw new Error(`scout transition: subtask '${subtask.id}' has no agent binding`);
+    if (binding.spec.resultContract.kind !== subtask.expectedResultContract) {
+      throw new Error(`scout transition: subtask '${subtask.id}' result contract does not match its bound agent`);
+    }
+    if (binding.spec.capabilityClass !== subtask.requestedAuthority) {
+      throw new Error(`scout transition: subtask '${subtask.id}' authority does not match its bound agent`);
+    }
+    const granted = approved.has(subtask.requestedAuthority);
+    if (!granted) missing.add(subtask.requestedAuthority);
+    return {
+      id: subtask.id,
+      agentId: binding.spec.id,
+      executionRole: deriveExecutionRole({
+        attempt: 0,
+        capabilityClass: binding.spec.capabilityClass,
+        resultContractKind: binding.spec.resultContract.kind
+      }),
+      scope: scopeFor(subtask.requestedAuthority),
+      expectedResultContract: subtask.expectedResultContract,
+      requestedAuthority: subtask.requestedAuthority,
+      approvedAuthority: granted ? subtask.requestedAuthority : null,
+      dependencies: [...subtask.dependencies],
+      task: subtask.task
+    };
+  });
+  const plan = compileExecutionPlan({
+    topology: "fleet",
+    rootTask: input.rootTask,
+    maxWorkers: Math.max(1, Math.min(4, input.maxWorkers, steps.length)),
+    onFailure: "stop",
+    steps
+  });
+  if (missing.size > 0) {
+    return {
+      kind: "approval-required",
+      sourceReceiptDigest: input.sourceReceiptDigest,
+      plan,
+      requiredAuthorities: [...missing]
+    };
+  }
+  return {
+    kind: "ready",
+    sourceReceiptDigest: input.sourceReceiptDigest,
+    plan,
+    authority: {
+      basis: input.authority.basis,
+      approvedAuthorities: [...input.authority.approvedAuthorities]
+    }
+  };
+}
+
+export {
+  compileScoutTransition,
+  createDispatchRunEventRegistry
+};
+//# sourceMappingURL=chunk-6SGHMWE3.js.map

package/dist/chunk-6XLNIQDB.js

@@ -0,0 +1,27 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/truncate-utf8.ts
+init_esm_shims();
+function truncateUtf8(text, maxBytes, marker) {
+  const buf = Buffer.from(text, "utf8");
+  if (buf.byteLength <= maxBytes) return text;
+  let cut = maxBytes;
+  while (cut > 0) {
+    const nextByte = buf[cut];
+    if (nextByte === void 0 || (nextByte & 192) !== 128) break;
+    cut -= 1;
+  }
+  return `${buf.subarray(0, cut).toString("utf8")}${marker}`;
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf8");
+}
+
+export {
+  truncateUtf8,
+  byteLength
+};
+//# sourceMappingURL=chunk-6XLNIQDB.js.map

package/dist/chunk-7CR24IG7.js

@@ -0,0 +1,242 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/c-header-language.ts
+init_esm_shims();
+function isAmbiguousHeaderPath(path) {
+  return path.endsWith(".h");
+}
+var CPP_ONLY_STD_INCLUDES = /* @__PURE__ */ new Set([
+  "algorithm",
+  "any",
+  "array",
+  "atomic",
+  "barrier",
+  "bit",
+  "bitset",
+  "cassert",
+  "cctype",
+  "cerrno",
+  "cfenv",
+  "cfloat",
+  "charconv",
+  "chrono",
+  "cinttypes",
+  "climits",
+  "clocale",
+  "cmath",
+  "codecvt",
+  "compare",
+  "complex",
+  "concepts",
+  "condition_variable",
+  "coroutine",
+  "csetjmp",
+  "csignal",
+  "cstdarg",
+  "cstddef",
+  "cstdint",
+  "cstdio",
+  "cstdlib",
+  "cstring",
+  "ctime",
+  "cuchar",
+  "cwchar",
+  "cwctype",
+  "deque",
+  "exception",
+  "execution",
+  "expected",
+  "filesystem",
+  "flat_map",
+  "flat_set",
+  "format",
+  "forward_list",
+  "fstream",
+  "functional",
+  "future",
+  "generator",
+  "initializer_list",
+  "iomanip",
+  "ios",
+  "iosfwd",
+  "iostream",
+  "istream",
+  "iterator",
+  "latch",
+  "limits",
+  "list",
+  "locale",
+  "map",
+  "mdspan",
+  "memory",
+  "memory_resource",
+  "mutex",
+  "new",
+  "numbers",
+  "numeric",
+  "optional",
+  "ostream",
+  "print",
+  "queue",
+  "random",
+  "ranges",
+  "ratio",
+  "regex",
+  "scoped_allocator",
+  "semaphore",
+  "set",
+  "shared_mutex",
+  "source_location",
+  "span",
+  "spanstream",
+  "sstream",
+  "stack",
+  "stacktrace",
+  "stdexcept",
+  "stop_token",
+  "streambuf",
+  "string",
+  "string_view",
+  "syncstream",
+  "system_error",
+  "thread",
+  "tuple",
+  "type_traits",
+  "typeindex",
+  "typeinfo",
+  "unordered_map",
+  "unordered_set",
+  "utility",
+  "valarray",
+  "variant",
+  "vector",
+  "version"
+]);
+var CPP_SYNTAX_PATTERNS = [
+  /\bnamespace\s+[A-Za-z_{:]/,
+  /\btemplate\s*</,
+  /\btypename\b/,
+  /\bclass\s+[A-Za-z_]/,
+  /\benum\s+(?:class|struct)\b/,
+  /\w::~?[A-Za-z_~]/,
+  /::/,
+  /^\s*(?:public|private|protected)\s*:(?!:)/m,
+  /\b(?:static_cast|dynamic_cast|reinterpret_cast|const_cast)\s*</,
+  /\busing\s+[A-Za-z_]\w*\s*=/,
+  /\busing\s+namespace\b/,
+  /\boperator\s*(?:[+\-*/%^&|~!=<>]|\(\)|\[\])/,
+  /\b(?:constexpr|consteval|constinit|noexcept|nullptr|decltype|thread_local)\b/,
+  /\b(?:virtual|override|friend|mutable)\b/,
+  /\)\s*(?:const|noexcept|override|final)\b/,
+  /^[ \t]*[A-Za-z_]\w*(?:::\w+)*(?:\s*<[^;{}()]+>)?\s*&&?\s*[A-Za-z_]\w*\s*\([^;{}]*\)\s*;/m,
+  /\bauto\s+[A-Za-z_]\w*\s*\([^;{}]*\)\s*->/
+];
+function blank(ch) {
+  return ch === "\n" ? "\n" : " ";
+}
+function stripForScan(text) {
+  let withStrings = "";
+  let code = "";
+  let state = "code";
+  for (let index = 0; index < text.length; index += 1) {
+    const ch = text[index];
+    const next = text[index + 1];
+    if (state === "code") {
+      if (ch === "/" && next === "/") {
+        state = "line-comment";
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      if (ch === "/" && next === "*") {
+        state = "block-comment";
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      if (ch === '"') state = "string";
+      else if (ch === "'") state = "char";
+      withStrings += ch;
+      code += state === "code" ? ch : " ";
+      continue;
+    }
+    if (state === "line-comment") {
+      if (ch === "\n") state = "code";
+      withStrings += blank(ch);
+      code += blank(ch);
+      continue;
+    }
+    if (state === "block-comment") {
+      if (ch === "*" && next === "/") {
+        state = "code";
+        index += 1;
+        withStrings += " ";
+        code += " ";
+        continue;
+      }
+      withStrings += blank(ch);
+      code += blank(ch);
+      continue;
+    }
+    if (ch === "\\" && next !== void 0) {
+      withStrings += ch + next;
+      code += blank(ch) + blank(next);
+      index += 1;
+      continue;
+    }
+    if (state === "string" && ch === '"' || state === "char" && ch === "'" || ch === "\n") {
+      state = "code";
+      withStrings += ch;
+      code += blank(ch);
+      continue;
+    }
+    withStrings += ch;
+    code += blank(ch);
+  }
+  return { withStrings, code };
+}
+function hasCppInclude(withStrings) {
+  for (const match of withStrings.matchAll(/^[ \t]*#[ \t]*include[ \t]*([<"])([^>"\n]+)[>"]/gm)) {
+    const delimiter = match[1];
+    const target = match[2]?.trim() ?? "";
+    if (/\.(?:hpp|hh|hxx|cuh)$/.test(target)) return true;
+    if (delimiter === "<" && CPP_ONLY_STD_INCLUDES.has(target)) return true;
+  }
+  return false;
+}
+function hasCppMemberDeclaration(code) {
+  for (const match of code.matchAll(/\b(?:class|struct)\s+[A-Za-z_]\w*[^;{]*\{([\s\S]*?)\}/g)) {
+    const body = match[1] ?? "";
+    for (const rawStatement of body.split(";")) {
+      const statement = rawStatement.trim();
+      if (statement.length === 0 || /\(\s*[*&]/.test(statement)) continue;
+      const member = /(?:^|\s)(operator\s*[^\s(]+|~?[A-Za-z_]\w*)\s*\([^{};]*\)\s*(?:const\b|noexcept\b|override\b|final\b|=\s*0\s*)*$/.exec(
+        statement
+      );
+      if (!member) continue;
+      const name = member[1] ?? "";
+      const prefix = statement.slice(0, member.index);
+      if (prefix.includes("[") || /^[_A-Z][_A-Z0-9]*$/.test(name)) continue;
+      return true;
+    }
+  }
+  return false;
+}
+function classifyCHeaderLanguage(text) {
+  const { withStrings, code } = stripForScan(text);
+  if (hasCppInclude(withStrings)) return "c++";
+  if (hasCppMemberDeclaration(code)) return "c++";
+  for (const pattern of CPP_SYNTAX_PATTERNS) {
+    if (pattern.test(code)) return "c++";
+  }
+  return "c";
+}
+
+export {
+  isAmbiguousHeaderPath,
+  classifyCHeaderLanguage
+};
+//# sourceMappingURL=chunk-7CR24IG7.js.map

package/dist/chunk-7MNJORFF.js

@@ -0,0 +1,22 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/verification-scripts.ts
+init_esm_shims();
+var VERIFICATION_SCRIPT_FAMILY_HINT = "test*/lint*/build*/typecheck*/check*/format*/ci*";
+var VERIFICATION_SCRIPT_PATTERN = /^(?:test|lint|build|typecheck|check|format|ci)(?:[:.-].*)?$/;
+function isVerificationScriptName(name) {
+  return VERIFICATION_SCRIPT_PATTERN.test(name);
+}
+function declaredVerificationScripts(scripts) {
+  return Object.keys(scripts).filter((name) => isVerificationScriptName(name)).sort((a, b) => a.localeCompare(b));
+}
+
+export {
+  VERIFICATION_SCRIPT_FAMILY_HINT,
+  isVerificationScriptName,
+  declaredVerificationScripts
+};
+//# sourceMappingURL=chunk-7MNJORFF.js.map