@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-NFSK2VNU.js

@@ -0,0 +1,446 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  fleetCodeSteps,
+  fleetLoopCheckStepId,
+  fleetLoopRepairStepId,
+  fleetStepWriteBoundary,
+  resolveFleetCommandArgs,
+  validateFleetCommands
+} from "./chunk-5LP5FNNR.js";
+import {
+  resultContractShape
+} from "./chunk-LNOXCGN2.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/dispatch/execution-plan.ts
+init_esm_shims();
+import { createHash } from "node:crypto";
+function requireAgentSteps(steps) {
+  return steps.map((step) => {
+    if (step.kind === "code") throw new Error(`execution plan: step '${step.id}' is a code step and has no route`);
+    return step;
+  });
+}
+function canonicalSteps(steps) {
+  return steps.map(
+    (step) => step.kind === "code" ? { ...step, kind: "code", dependencies: [...step.dependencies].sort() } : { ...step, kind: "agent", dependencies: [...step.dependencies].sort() }
+  );
+}
+function executionPlanWaves(steps, maxWorkers) {
+  if (!Number.isInteger(maxWorkers) || maxWorkers < 1)
+    throw new Error("execution plan: maxWorkers must be a positive integer");
+  if (steps.length === 0) throw new Error("execution plan: plan must contain at least one step");
+  const ids = /* @__PURE__ */ new Set();
+  for (const step of steps) {
+    if (step.id.trim().length === 0) throw new Error("execution plan: step id must be non-empty");
+    if (ids.has(step.id)) throw new Error(`execution plan: duplicate step id '${step.id}'`);
+    ids.add(step.id);
+  }
+  for (const step of steps)
+    for (const dependency of step.dependencies) {
+      if (!ids.has(dependency))
+        throw new Error(`execution plan: step '${step.id}' has missing dependency '${dependency}'`);
+      if (dependency === step.id) throw new Error(`execution plan: cycle includes '${step.id}'`);
+    }
+  const remaining = new Set(steps.map((step) => step.id));
+  const completed = /* @__PURE__ */ new Set();
+  const waves = [];
+  while (remaining.size > 0) {
+    const ready = steps.filter((step) => remaining.has(step.id) && step.dependencies.every((id) => completed.has(id)));
+    if (ready.length === 0) throw new Error("execution plan: dependency cycle detected");
+    const codeReady = ready.filter((step) => step.kind === "code").map((step) => step.id);
+    const agentReady = ready.filter((step) => step.kind !== "code");
+    const chunks = [];
+    let chunk = [];
+    let endpointCounts = /* @__PURE__ */ new Map();
+    for (const step of agentReady) {
+      const endpoint = step.endpoint;
+      const endpointLimit = endpoint === void 0 ? Number.POSITIVE_INFINITY : Math.max(1, endpoint.limit - (endpoint.foregroundHeld ?? 0));
+      const endpointFull = endpoint !== void 0 && (endpointCounts.get(endpoint.key) ?? 0) >= endpointLimit;
+      if (chunk.length >= maxWorkers || endpointFull) {
+        chunks.push(chunk);
+        chunk = [];
+        endpointCounts = /* @__PURE__ */ new Map();
+      }
+      chunk.push(step.id);
+      if (endpoint !== void 0) endpointCounts.set(endpoint.key, (endpointCounts.get(endpoint.key) ?? 0) + 1);
+    }
+    if (chunk.length > 0) chunks.push(chunk);
+    if (chunks.length === 0) chunks.push([]);
+    chunks[0] = [...codeReady, ...chunks[0] ?? []];
+    for (const wave of chunks) {
+      waves.push(wave);
+      for (const id of wave) {
+        remaining.delete(id);
+        completed.add(id);
+      }
+    }
+  }
+  return waves;
+}
+function checkLoops(steps, loops) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const loop of loops) {
+    if (seen.has(loop.id)) throw new Error(`execution plan: duplicate loop id '${loop.id}'`);
+    seen.add(loop.id);
+    if (!Number.isInteger(loop.maxAttempts) || loop.maxAttempts < 1) {
+      throw new Error(`execution plan: loop '${loop.id}' must declare a positive attempt bound`);
+    }
+    if (loop.checkStepIds.length !== loop.maxAttempts || loop.repairStepIds.length !== loop.maxAttempts - 1) {
+      throw new Error(`execution plan: loop '${loop.id}' membership does not match its bound of ${loop.maxAttempts}`);
+    }
+    for (const id of [...loop.checkStepIds, ...loop.repairStepIds]) {
+      const step = byId.get(id);
+      if (step === void 0) throw new Error(`execution plan: loop '${loop.id}' names unknown step '${id}'`);
+      if (step.loop?.loopId !== loop.id) {
+        throw new Error(`execution plan: step '${id}' is not a member of loop '${loop.id}'`);
+      }
+    }
+  }
+  for (const step of steps) {
+    if (step.loop !== void 0 && !seen.has(step.loop.loopId)) {
+      throw new Error(`execution plan: step '${step.id}' belongs to undeclared loop '${step.loop.loopId}'`);
+    }
+  }
+}
+function checkWriteBoundaryWaves(steps, waves, writerLimit) {
+  const byId = new Map(steps.map((step) => [step.id, step]));
+  for (const [index, wave] of waves.entries()) {
+    const members = wave.flatMap((id) => {
+      const step = byId.get(id);
+      return step === void 0 ? [] : [step];
+    });
+    const declared = members.filter((step) => step.writes !== void 0);
+    if (declared.length === 0) continue;
+    const undeclared = members.filter((step) => step.writes === void 0);
+    if (undeclared.length > 0 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} mixes boundary-enforced steps (${declared.map((step) => step.id).join(", ")}) with steps that declare no boundary (${undeclared.map((step) => step.id).join(", ")}); they share one checkout, so the undeclared step's writes cannot be told from a violation`
+      );
+    }
+    const writers = declared.filter((step) => (step.writes?.length ?? 0) > 0);
+    if (writers.length > 1 && writerLimit !== 1) {
+      throw new Error(
+        `execution plan: wave ${index} schedules ${writers.length} steps that may write (${writers.map((step) => step.id).join(
+          ", "
+        )}); a write boundary is verified by diffing one shared checkout, so concurrent writers cannot be attributed. Order them with dependencies or lower maxWorkers`
+      );
+    }
+  }
+}
+function compileExecutionPlan(input) {
+  if (input.writers !== void 0 && input.writers !== 1) {
+    throw new Error("execution plan: writers must be 1 when present");
+  }
+  const steps = canonicalSteps(input.steps);
+  const loops = (input.loops ?? []).map((loop) => ({
+    ...loop,
+    checkStepIds: [...loop.checkStepIds],
+    repairStepIds: [...loop.repairStepIds]
+  }));
+  checkLoops(steps, loops);
+  const waves = executionPlanWaves(steps, input.maxWorkers);
+  checkWriteBoundaryWaves(steps, waves, input.writers);
+  const canonical = {
+    version: 4,
+    topology: input.topology,
+    rootTask: input.rootTask,
+    maxWorkers: input.maxWorkers,
+    ...input.writers === 1 ? { writers: 1 } : {},
+    onFailure: input.onFailure,
+    steps,
+    loops,
+    waves
+  };
+  return { ...canonical, hash: createHash("sha256").update(JSON.stringify(canonical)).digest("hex") };
+}
+function bindExecutionPlanEndpoints(plan, bindings) {
+  return compileExecutionPlan({
+    topology: plan.topology,
+    rootTask: plan.rootTask,
+    maxWorkers: plan.maxWorkers,
+    ...plan.writers === 1 ? { writers: 1 } : {},
+    onFailure: plan.onFailure,
+    steps: plan.steps.map((step) => {
+      if (step.kind === "code") return step;
+      const endpoint = bindings[step.id];
+      return endpoint === void 0 ? step : { ...step, endpoint: { ...endpoint } };
+    }),
+    loops: plan.loops
+  });
+}
+function executionPlanAncestors(plan, stepId) {
+  const byId = new Map(plan.steps.map((step) => [step.id, step]));
+  const ancestors = /* @__PURE__ */ new Set();
+  const pending = [...byId.get(stepId)?.dependencies ?? []];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === void 0 || ancestors.has(next)) continue;
+    ancestors.add(next);
+    pending.push(...byId.get(next)?.dependencies ?? []);
+  }
+  return ancestors;
+}
+function spliceExecutionPlan(plan, parentId, tasks) {
+  const parent = plan.steps.find((step) => step.id === parentId);
+  if (parent?.kind !== "agent" || parent.plan === void 0) {
+    throw new Error(`execution plan: '${parentId}' is not a plan step`);
+  }
+  const inserted = tasks.map((task) => ({
+    kind: "agent",
+    id: task.id,
+    agentId: task.agentId,
+    executionRole: task.executionRole,
+    scope: task.writes.length > 0 ? "workspace" : "readonly",
+    expectedResultContract: task.expectedResultContract,
+    requestedAuthority: task.requestedAuthority,
+    approvedAuthority: task.approvedAuthority,
+    dependencies: [parentId, ...task.dependencies],
+    task: task.task,
+    writes: [...task.writes],
+    ...task.target !== void 0 ? { target: task.target } : {},
+    ...task.profile !== void 0 ? { profile: task.profile } : {},
+    planParentId: parentId
+  }));
+  return compileExecutionPlan({
+    topology: plan.topology,
+    rootTask: plan.rootTask,
+    maxWorkers: plan.maxWorkers,
+    ...plan.writers === 1 ? { writers: 1 } : {},
+    onFailure: plan.onFailure,
+    steps: [...plan.steps, ...inserted],
+    loops: plan.loops
+  });
+}
+
+// src/domains/dispatch/fleet-plan.ts
+init_esm_shims();
+
+// src/domains/dispatch/fleet-node-prompt.ts
+init_esm_shims();
+function fleetNodeAnswerDirective(kind) {
+  if (kind === "architect-plan") return null;
+  return [
+    `Your result contract for this step is \`${kind}\`.`,
+    "The task above describes the whole chain. Any result shape it states belongs to the step that produces it, and does not apply to you.",
+    `End with exactly this shape and nothing else: ${resultContractShape({ kind })}`,
+    // The wire example carries literal names and evidence, and a small model
+    // handed one on a first attempt copies them: the first run of this
+    // directive came back claiming `npm run typecheck` / `exit 0` in the same
+    // breath as admitting it could not run a command. The fields are the
+    // contract; the values in the example are not.
+    "Its field values are an example. Fill them with what this run actually produced or observed, and never report a name or evidence you did not."
+  ].join("\n");
+}
+function renderFleetNodeTask(task, kind) {
+  const directive = fleetNodeAnswerDirective(kind);
+  return directive === null ? task : `${task}
+
+${directive}`;
+}
+
+// src/domains/dispatch/fleet-plan.ts
+function expandDependencies(dependencies, loopMembers) {
+  return dependencies.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.checkStepIds];
+  });
+}
+function expandCommitSources(sources, loopMembers) {
+  return sources.flatMap((id) => {
+    const loop = loopMembers.get(id);
+    return loop === void 0 ? [id] : [...loop.repairStepIds].reverse();
+  });
+}
+function declaredLoops(steps) {
+  const loops = /* @__PURE__ */ new Map();
+  for (const step of steps) {
+    if (step.kind !== "loop") continue;
+    const checkStepIds = [];
+    const repairStepIds = [];
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      checkStepIds.push(fleetLoopCheckStepId(step.id, attempt));
+      if (attempt < step.maxAttempts) repairStepIds.push(fleetLoopRepairStepId(step.id, attempt));
+    }
+    loops.set(step.id, {
+      id: step.id,
+      checkKind: step.check.kind === "gate" ? "code" : step.check.kind,
+      maxAttempts: step.maxAttempts,
+      checkStepIds,
+      repairStepIds
+    });
+  }
+  return loops;
+}
+function compileFleetExecutionPlan(input) {
+  const { contract, task, resolveAgent } = input;
+  if (input.commands !== void 0) validateFleetCommands(contract, input.commands, input.vars ?? {});
+  else if (fleetCodeSteps(contract).some((step) => (step.args?.length ?? 0) > 0))
+    throw new Error("fleet code args: admission requires the operator command registry");
+  const loops = declaredLoops(contract.steps);
+  const steps = [];
+  const boundary = (scope, writes) => {
+    const resolved = fleetStepWriteBoundary(contract.version, scope, writes);
+    return resolved === void 0 ? {} : { writes: [...resolved] };
+  };
+  const agentNode = (context, dependencies, writes, loop, extra) => {
+    const resolved = resolveAgent(context);
+    return {
+      kind: "agent",
+      id: context.stepId,
+      agentId: context.agentId,
+      scope: context.scope,
+      dependencies: [...dependencies],
+      task: renderFleetNodeTask(task, resolved.expectedResultContract),
+      expectedResultContract: resolved.expectedResultContract,
+      requestedAuthority: resolved.requestedAuthority,
+      approvedAuthority: resolved.approvedAuthority,
+      executionRole: resolved.executionRole,
+      ...boundary(context.scope, writes),
+      ...loop !== void 0 ? { loop } : {},
+      ...context.target !== void 0 ? { target: context.target } : {},
+      ...context.profile !== void 0 ? { profile: context.profile } : {},
+      ...extra
+    };
+  };
+  const routeOf = (value) => ({
+    ...value.target !== void 0 ? { target: value.target } : {},
+    ...value.profile !== void 0 ? { profile: value.profile } : {}
+  });
+  for (const step of contract.steps) {
+    const dependencies = expandDependencies(step.dependencies, loops);
+    if (step.kind === "agent") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, ...routeOf(step) },
+          dependencies,
+          step.writes
+        )
+      );
+      continue;
+    }
+    if (step.kind === "gate") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: "workspace", attempt: 0, gateAuthorRole: true, ...routeOf(step) },
+          dependencies,
+          [step.path],
+          void 0,
+          { gate: { path: step.path, commandId: step.run } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "plan") {
+      steps.push(
+        agentNode(
+          { stepId: step.id, agentId: step.agent, scope: step.scope, attempt: 0, planRole: true, ...routeOf(step) },
+          dependencies,
+          step.writes,
+          void 0,
+          { plan: { roster: [...step.roster], maxTasks: step.maxTasks, proposals: step.proposals } }
+        )
+      );
+      continue;
+    }
+    if (step.kind === "code") {
+      steps.push({
+        kind: "code",
+        id: step.id,
+        commandId: step.command,
+        ...step.args ? { args: resolveFleetCommandArgs(step.args, input.vars) } : {},
+        scope: step.scope,
+        dependencies,
+        ...boundary(step.scope, step.writes),
+        ...step.commitFrom !== void 0 ? { commitFrom: expandCommitSources(step.commitFrom, loops) } : {}
+      });
+      continue;
+    }
+    const loop = loops.get(step.id);
+    if (loop === void 0) throw new Error(`fleet plan: loop '${step.id}' failed to compile`);
+    for (let attempt = 1; attempt <= step.maxAttempts; attempt++) {
+      const checkId = loop.checkStepIds[attempt - 1] ?? "";
+      const previousRepair = attempt === 1 ? null : loop.repairStepIds[attempt - 2] ?? "";
+      const checkDependencies = previousRepair === null ? dependencies : [previousRepair];
+      const membership = { loopId: loop.id, role: "check", attempt };
+      if (step.check.kind === "code") {
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: step.check.command,
+          ...step.check.args ? { args: resolveFleetCommandArgs(step.check.args, input.vars) } : {},
+          scope: step.check.scope,
+          dependencies: checkDependencies,
+          ...boundary(step.check.scope, step.check.writes),
+          loop: membership,
+          // The green a later step may rely on; the scheduler re-runs it
+          // when a workspace step lands after it.
+          verification: true
+        });
+      } else if (step.check.kind === "gate") {
+        const gateId = step.check.gate;
+        const gate = contract.steps.find((candidate) => candidate.id === gateId);
+        if (gate?.kind !== "gate") throw new Error(`fleet plan: gate '${gateId}' failed to resolve`);
+        steps.push({
+          kind: "code",
+          id: checkId,
+          commandId: gate.run,
+          scope: "readonly",
+          dependencies: checkDependencies,
+          writes: [],
+          loop: membership,
+          verification: true,
+          gate: { gateId: gate.id, path: gate.path }
+        });
+      } else {
+        steps.push(
+          agentNode(
+            {
+              stepId: checkId,
+              agentId: step.check.agent,
+              scope: step.check.scope,
+              attempt: 0,
+              gateRole: "reviewer",
+              ...routeOf(step.check)
+            },
+            checkDependencies,
+            step.check.writes,
+            membership
+          )
+        );
+      }
+      if (attempt >= step.maxAttempts) continue;
+      const repairId = loop.repairStepIds[attempt - 1] ?? "";
+      steps.push(
+        agentNode(
+          { stepId: repairId, agentId: step.repair.agent, scope: step.repair.scope, attempt, ...routeOf(step.repair) },
+          [checkId],
+          step.repair.writes,
+          { loopId: loop.id, role: "repair", attempt }
+        )
+      );
+    }
+  }
+  return compileExecutionPlan({
+    topology: "fleet",
+    rootTask: task,
+    maxWorkers: contract.maxWorkers,
+    ...contract.writers === 1 ? { writers: 1 } : {},
+    onFailure: contract.onFailure,
+    steps,
+    loops: [...loops.values()]
+  });
+}
+
+export {
+  requireAgentSteps,
+  compileExecutionPlan,
+  bindExecutionPlanEndpoints,
+  executionPlanAncestors,
+  spliceExecutionPlan,
+  compileFleetExecutionPlan
+};
+//# sourceMappingURL=chunk-NFSK2VNU.js.map

package/dist/chunk-NG3QQSXY.js

@@ -0,0 +1,43 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// apps/clio-coder-gui/contracts/common.ts
+init_esm_shims();
+var Id = typebox_exports.String({ pattern: "^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$" });
+var PageCursor = typebox_exports.String({ maxLength: 1024, pattern: "^[A-Za-z0-9_-]+$" });
+var Empty = typebox_exports.Object({}, { additionalProperties: false });
+var ProblemCode = typebox_exports.Union([
+  typebox_exports.Literal("validation"),
+  typebox_exports.Literal("unauthorized"),
+  typebox_exports.Literal("not_found"),
+  typebox_exports.Literal("conflict"),
+  typebox_exports.Literal("unsupported"),
+  typebox_exports.Literal("unavailable"),
+  typebox_exports.Literal("upstream_acp"),
+  typebox_exports.Literal("operation_failed"),
+  typebox_exports.Literal("internal")
+]);
+var Problem = typebox_exports.Object(
+  {
+    type: typebox_exports.String(),
+    title: typebox_exports.String(),
+    status: typebox_exports.Integer(),
+    detail: typebox_exports.String(),
+    code: ProblemCode,
+    instance: typebox_exports.String()
+  },
+  { additionalProperties: false }
+);
+
+export {
+  Id,
+  PageCursor,
+  Empty,
+  Problem
+};
+//# sourceMappingURL=chunk-NG3QQSXY.js.map

package/dist/chunk-NOCSM22Y.js

@@ -0,0 +1,63 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  initializeClioHome
+} from "./chunk-URCXX7WJ.js";
+import {
+  clioStatePath
+} from "./chunk-CTTI7G3T.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/domains/lifecycle/state.ts
+init_esm_shims();
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+function readStateInfoResult() {
+  const path = join(clioStatePath(), "install.json");
+  try {
+    return { info: JSON.parse(readFileSync(path, "utf8")), problem: null };
+  } catch (error) {
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "";
+    if (code === "ENOENT") return { info: null, problem: null };
+    const message = error instanceof Error ? error.message : String(error);
+    return { info: null, problem: `${path} could not be read: ${message}` };
+  }
+}
+function readStateInfo() {
+  return readStateInfoResult().info;
+}
+function ensureClioState() {
+  initializeClioHome();
+  const info = readStateInfo();
+  if (!info) throw new Error("state metadata was not written by initializeClioHome()");
+  return info;
+}
+function takeUpgradeNotice() {
+  const path = join(clioStatePath(), "install.json");
+  let raw;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    raw = parsed;
+  } catch {
+    return null;
+  }
+  const { version, upgradedFrom, noticedVersion } = raw;
+  if (typeof version !== "string" || typeof upgradedFrom !== "string") return null;
+  if (upgradedFrom === version || noticedVersion === version) return null;
+  try {
+    writeFileSync(path, `${JSON.stringify({ ...raw, noticedVersion: version }, null, 2)}
+`, "utf8");
+  } catch {
+  }
+  return { from: upgradedFrom, to: version };
+}
+
+export {
+  readStateInfoResult,
+  readStateInfo,
+  ensureClioState,
+  takeUpgradeNotice
+};
+//# sourceMappingURL=chunk-NOCSM22Y.js.map