@iowarp/clio-coder 0.3.0

package/dist/version-ROZ6CZKH.js

@@ -0,0 +1,16 @@
+import {
+  getVersionInfo
+} from "./chunk-HMYNFFY4.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/version.ts
+function runVersionCommand() {
+  const v = getVersionInfo();
+  process.stdout.write(`Clio Coder ${v.clio}
+`);
+  return 0;
+}
+export {
+  runVersionCommand
+};
+//# sourceMappingURL=version-ROZ6CZKH.js.map

package/dist/wiki-generate-PKFIX6OB.js

@@ -0,0 +1,377 @@
+import {
+  armInternalDispatchDeadline
+} from "./chunk-4UQA7NCT.js";
+import {
+  SchedulingDomainModule,
+  createPromptsDomainModule
+} from "./chunk-3DANZDGR.js";
+import {
+  AgentsDomainModule,
+  SafetyDomainModule
+} from "./chunk-JPOWPFCU.js";
+import {
+  ConfigDomainModule,
+  loadDomains
+} from "./chunk-527KG6XR.js";
+import "./chunk-UU3R62TT.js";
+import {
+  ContextDomainModule,
+  buildWikiPagePrompt,
+  buildWikiPlanPrompt
+} from "./chunk-UWIJNAOB.js";
+import "./chunk-X3BR7HWV.js";
+import "./chunk-VOO7NYPP.js";
+import {
+  DispatchDomainModule,
+  MAX_PAGE_ATTEMPTS,
+  MiddlewareDomainModule,
+  SessionDomainModule,
+  createObservabilityDomainModule,
+  pendingPages,
+  readAuthoredWikiPlan,
+  writeWikiPlanFile
+} from "./chunk-GNGDQYDU.js";
+import {
+  ResourcesDomainModule
+} from "./chunk-2J63S4SF.js";
+import "./chunk-RQDWMVRB.js";
+import "./chunk-7BHLZB3A.js";
+import "./chunk-TPOCL34A.js";
+import "./chunk-E3NYWENM.js";
+import "./chunk-XV4ZJ6ZM.js";
+import "./chunk-26BZQOAD.js";
+import "./chunk-WD6AJM35.js";
+import {
+  ToolNames
+} from "./chunk-QV47YRF4.js";
+import "./chunk-CLJ5HLUD.js";
+import "./chunk-BBUH4VAA.js";
+import "./chunk-GOTUR54M.js";
+import "./chunk-KBR4MZZR.js";
+import {
+  ProvidersDomainModule,
+  canonicalizeWireModelId
+} from "./chunk-TKHQ4DGZ.js";
+import "./chunk-D5YD55AR.js";
+import "./chunk-JWHCJDCI.js";
+import "./chunk-UHTSULZS.js";
+import "./chunk-5LDRNKX2.js";
+import "./chunk-UGYAX5YI.js";
+import "./chunk-5N2FG33Q.js";
+import "./chunk-VPAWTYLY.js";
+import "./chunk-X3NE4WVW.js";
+import "./chunk-DXQNI4PC.js";
+
+// src/cli/wiki-generate.ts
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+var UNRESOLVED_DOCUMENTER_MODEL = "unresolved-documenter-target";
+var WIKI_AGENT_ID = "wiki-writer";
+var PAGE_DEADLINE_MS = 6 * 60 * 1e3;
+var PLAN_DEADLINE_MS = 8 * 60 * 1e3;
+var RUN_BUDGET_MS = 60 * 60 * 1e3;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function routeFields(route) {
+  return {
+    ...route.target !== void 0 ? { target: route.target } : {},
+    ...route.model !== void 0 ? { model: route.model } : {},
+    ...route.thinkingLevel !== void 0 ? { thinkingLevel: route.thinkingLevel } : {}
+  };
+}
+function eventPayloadString(event, key) {
+  if (!isRecord(event) || !isRecord(event.payload)) return null;
+  const value = event.payload[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function formatElapsed(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "elapsed unknown";
+  if (ms < 1e3) return `elapsed ${Math.round(ms)}ms`;
+  return `elapsed ${Math.round(ms / 1e3)}s`;
+}
+var BLOCK_REASON_MAX_CHARS = 80;
+function summarizeBlockReason(reason) {
+  const firstSentence = reason.split(/(?<=[.;])\s/, 1)[0]?.trim() ?? reason.trim();
+  const collapsed = firstSentence.replace(/\s+/g, " ");
+  return collapsed.length <= BLOCK_REASON_MAX_CHARS ? collapsed : `${collapsed.slice(0, BLOCK_REASON_MAX_CHARS - 1).trimEnd()}\u2026`;
+}
+var HEARTBEAT_MS = 3e4;
+async function drainDispatchEvents(events, onActivity) {
+  const tools = /* @__PURE__ */ new Map();
+  let completed = 0;
+  let errors = 0;
+  let blocked = 0;
+  let firstBlockReason = null;
+  for await (const event of events) {
+    if (!isRecord(event) || event.type !== "clio_tool_finish") continue;
+    const tool = eventPayloadString(event, "tool");
+    if (!tool) continue;
+    const outcome = eventPayloadString(event, "outcome") ?? "done";
+    completed += 1;
+    tools.set(tool, (tools.get(tool) ?? 0) + 1);
+    if (outcome === "error") errors += 1;
+    if (outcome === "blocked") {
+      blocked += 1;
+      firstBlockReason ??= eventPayloadString(event, "reason");
+    }
+    onActivity?.(completed);
+  }
+  const mix = [...tools.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([tool, count]) => `${tool}=${count}`).join(", ");
+  return { tools: completed, errors, blocked, firstBlockReason, mix };
+}
+function summaryDetail(summary, startedAt) {
+  const blockedDetail = summary.blocked > 0 ? `; blocked=${summary.blocked}${summary.firstBlockReason ? ` (${summarizeBlockReason(summary.firstBlockReason)})` : ""}` : "";
+  return `${formatElapsed(Date.now() - startedAt)}; ${summary.mix || "no tools completed"}${summary.errors > 0 ? `; errors=${summary.errors}` : ""}${blockedDetail}`;
+}
+async function runWikiDispatch(input) {
+  const startedAt = Date.now();
+  let handle;
+  try {
+    handle = await input.dispatch.dispatch({
+      agentId: WIKI_AGENT_ID,
+      executionRole: "builder",
+      task: input.task,
+      cwd: input.cwd,
+      requestOrigin: "internal",
+      noSkills: true,
+      ...routeFields(input.route),
+      // `git` cannot answer anything for this dispatch. The prompt already
+      // embeds `git status` and `git log` verbatim, and the staging dir is
+      // under the gitignored `.clio-coder/`, so `op=diff` cannot see the pages this
+      // run is writing.
+      denyTools: [ToolNames.Git],
+      // Containment: the worker safety seam blocks any write-class tool call
+      // whose target escapes the staging dir.
+      writeRoots: [input.outputDir],
+      // Admission patience must match execution patience. Without this the
+      // queue applies its 60s default while `deadlineMs` below allows six
+      // minutes to run, so a page waiting behind two in-flight writers was
+      // dropped before it ever started. Observed live: a 33-page plan lost
+      // `core.md` to `dispatch: admission timed_out` at 10/33 while every
+      // page ahead of it was taking 110 to 125 seconds. A page the caller is
+      // willing to wait six minutes for is a page it should be willing to
+      // queue for six minutes.
+      assignmentDeadlineAt: startedAt + input.deadlineMs
+    });
+  } catch (err) {
+    return { ok: false, detail: err instanceof Error ? err.message : String(err) };
+  }
+  const deadline = armInternalDispatchDeadline(input.dispatch, handle.runId, input.label, process.env, input.deadlineMs);
+  let lastHeartbeatAt = startedAt;
+  try {
+    const summary = await drainDispatchEvents(handle.events, (tools) => {
+      const nowMs = Date.now();
+      if (!input.onHeartbeat || nowMs - lastHeartbeatAt < HEARTBEAT_MS) return;
+      lastHeartbeatAt = nowMs;
+      input.onHeartbeat({ elapsedMs: nowMs - startedAt, tools });
+    });
+    const receipt = await handle.finalPromise;
+    if (deadline.timedOut()) return { ok: false, detail: `timed out; ${summaryDetail(summary, startedAt)}` };
+    if (receipt.exitCode !== 0) {
+      input.dispatch.abort(handle.runId);
+      return { ok: false, detail: `${receiptFailure(receipt)}; ${summaryDetail(summary, startedAt)}` };
+    }
+    return { ok: true, detail: summaryDetail(summary, startedAt) };
+  } catch (err) {
+    if (!deadline.timedOut()) input.dispatch.abort(handle.runId);
+    await handle.finalPromise.catch(() => void 0);
+    const reason = deadline.timedOut() ? "timed out" : err instanceof Error ? err.message : String(err);
+    return { ok: false, detail: `${reason}; ${formatElapsed(Date.now() - startedAt)}` };
+  } finally {
+    deadline.clear();
+  }
+}
+function receiptFailure(receipt) {
+  const code = receipt.outcomeCode ? ` (${receipt.outcomeCode})` : "";
+  return `exit ${receipt.exitCode}${code}`;
+}
+async function runPlanPhase(dispatch, input, route) {
+  input.progress?.({ phase: "generate", status: "running", message: "planning wiki pages" });
+  const outcome = await runWikiDispatch({
+    dispatch,
+    cwd: input.cwd,
+    outputDir: input.outputDir,
+    task: buildWikiPlanPrompt({
+      cwd: input.cwd,
+      mode: input.mode,
+      codewiki: input.codewiki,
+      generation: input.generation,
+      plan: input.plan,
+      unclaimedAreas: input.unclaimedAreas,
+      outputDir: input.outputDir,
+      gitHead: input.gitHead ?? null
+    }),
+    route,
+    deadlineMs: PLAN_DEADLINE_MS,
+    label: "wiki planner",
+    onHeartbeat: ({ elapsedMs, tools }) => input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `still planning (${formatElapsed(elapsedMs)}, ${tools} tool calls)`,
+      detail: `planner deadline ${Math.round(PLAN_DEADLINE_MS / 6e4)}m`
+    })
+  });
+  const revised = readAuthoredWikiPlan(input.outputDir, input.plan);
+  const plan = revised ?? input.plan;
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: outcome.ok ? `plan has ${plan.pages.length} page${plan.pages.length === 1 ? "" : "s"}` : "planner did not finish; using the indexed candidate plan",
+    detail: outcome.detail
+  });
+  return plan;
+}
+async function runPagePhase(dispatch, input, plan, page, route, position) {
+  const seeded = existsSync(join(input.outputDir, page.path));
+  const outcome = await runWikiDispatch({
+    dispatch,
+    cwd: input.cwd,
+    outputDir: input.outputDir,
+    task: buildWikiPagePrompt({
+      cwd: input.cwd,
+      mode: input.mode,
+      codewiki: input.codewiki,
+      page,
+      siblings: plan.pages,
+      outputDir: input.outputDir,
+      seeded
+    }),
+    route,
+    deadlineMs: PAGE_DEADLINE_MS,
+    label: `wiki page ${page.path}`,
+    onHeartbeat: ({ elapsedMs, tools }) => input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `still writing ${page.path} (${position.index}/${position.total}, ${formatElapsed(elapsedMs)}, ${tools} tool calls)`,
+      detail: `page deadline ${Math.round(PAGE_DEADLINE_MS / 6e4)}m`
+    })
+  });
+  const written = existsSync(join(input.outputDir, page.path));
+  const next = {
+    ...plan,
+    pages: plan.pages.map(
+      (entry) => entry.path === page.path ? { ...entry, status: written ? "written" : "pending", attempts: entry.attempts + 1 } : entry
+    )
+  };
+  writeWikiPlanFile(input.outputDir, next);
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: `${written ? "wrote" : "could not write"} ${page.path} (${position.index}/${position.total})`,
+    detail: outcome.detail
+  });
+  return next;
+}
+async function generateWikiWithDocumenter(dispatch, input, route = {}, runBudgetMs = RUN_BUDGET_MS) {
+  const startedAt = Date.now();
+  const routeDetail = [route.target, route.model, route.thinkingLevel ? `thinking=${route.thinkingLevel}` : void 0].filter((value) => value !== void 0).join("/");
+  input.progress?.({
+    phase: "generate",
+    status: "running",
+    message: "dispatching wiki writers",
+    detail: `one page per dispatch${routeDetail ? `; ${routeDetail}` : ""}`
+  });
+  let plan = input.resumed ? input.plan : await runPlanPhase(dispatch, input, route);
+  if (!input.resumed) writeWikiPlanFile(input.outputDir, plan);
+  const queue = pendingPages(plan);
+  if (queue.length === 0) {
+    input.progress?.({ phase: "generate", status: "running", message: "every planned page is already current" });
+    return;
+  }
+  {
+    const worstCaseMs = Math.min(runBudgetMs, queue.length * PAGE_DEADLINE_MS);
+    input.progress?.({
+      phase: "generate",
+      status: "running",
+      message: `${queue.length} page${queue.length === 1 ? "" : "s"} to write, one model run each`,
+      detail: `up to ${Math.round(worstCaseMs / 6e4)}m; progress is reported at least every ${Math.round(HEARTBEAT_MS / 1e3)}s and finished pages are kept if the run stops early`
+    });
+  }
+  for (const [index, page] of queue.entries()) {
+    if (Date.now() - startedAt >= runBudgetMs) {
+      const left = queue.length - index;
+      input.progress?.({
+        phase: "generate",
+        status: "running",
+        message: `run budget reached with ${left} page${left === 1 ? "" : "s"} unwritten`,
+        detail: `${formatElapsed(Date.now() - startedAt)}; staged pages are kept and promoted`
+      });
+      return;
+    }
+    const current = plan.pages.find((entry) => entry.path === page.path) ?? page;
+    if (current.status === "written" || current.attempts >= MAX_PAGE_ATTEMPTS) continue;
+    plan = await runPagePhase(dispatch, input, plan, current, route, {
+      index: index + 1,
+      total: queue.length
+    });
+  }
+}
+async function loadWikiDispatch() {
+  const loaded = await loadDomains([
+    ConfigDomainModule,
+    ResourcesDomainModule,
+    ContextDomainModule,
+    ProvidersDomainModule,
+    SafetyDomainModule,
+    createPromptsDomainModule({ noContextFiles: true }),
+    AgentsDomainModule,
+    MiddlewareDomainModule,
+    SessionDomainModule,
+    createObservabilityDomainModule({ dispatchTrace: false }),
+    SchedulingDomainModule,
+    DispatchDomainModule
+  ]);
+  const dispatch = loaded.getContract("dispatch");
+  if (!dispatch) {
+    await loaded.stop();
+    throw new Error("wiki writer dispatch unavailable");
+  }
+  return { dispatch, loaded };
+}
+async function resolveDocumenterModelId(route = {}) {
+  const loaded = await loadDomains([ConfigDomainModule, ResourcesDomainModule, ProvidersDomainModule]);
+  try {
+    const config = loaded.getContract("config");
+    const providers = loaded.getContract("providers");
+    if (!config || !providers) return UNRESOLVED_DOCUMENTER_MODEL;
+    const settings = config.get();
+    const workers = settings.workers;
+    const bindingProfileName = workers?.agentBindings?.[WIKI_AGENT_ID];
+    const profile = bindingProfileName ? workers?.profiles?.[bindingProfileName] : void 0;
+    const targetId = route.target ?? profile?.target ?? workers?.default?.target ?? settings.targets?.[0]?.id ?? null;
+    if (!targetId) return UNRESOLVED_DOCUMENTER_MODEL;
+    const target = providers.getTarget(targetId);
+    const requestedModel = route.model ?? profile?.model ?? workers?.default?.model ?? target?.defaultModel ?? null;
+    if (!requestedModel) return UNRESOLVED_DOCUMENTER_MODEL;
+    const status = providers.list().find((entry) => entry.target.id === targetId);
+    return status ? canonicalizeWireModelId(status, requestedModel) : requestedModel;
+  } catch {
+    return UNRESOLVED_DOCUMENTER_MODEL;
+  } finally {
+    await loaded.stop();
+  }
+}
+function modelWikiGenerate(options = {}) {
+  return async (input) => {
+    let loaded = null;
+    try {
+      if (options.dispatch) {
+        await generateWikiWithDocumenter(options.dispatch, input, options.route, options.runBudgetMs);
+        return;
+      }
+      const lazy = await loadWikiDispatch();
+      loaded = lazy.loaded;
+      await generateWikiWithDocumenter(lazy.dispatch, input, options.route, options.runBudgetMs);
+    } finally {
+      if (loaded) await loaded.stop();
+    }
+  };
+}
+export {
+  generateWikiWithDocumenter,
+  modelWikiGenerate,
+  resolveDocumenterModelId,
+  runWikiDispatch
+};
+//# sourceMappingURL=wiki-generate-PKFIX6OB.js.map