@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.9

package/dist/builtin/workflows/builtin/chunk-4febxsv4.js

@@ -0,0 +1,264 @@
+import"./chunk-5wgwscd0.js";
+
+// src/core/export-html/ansi-to-html.ts
+var ANSI_COLORS = [
+  "#000000",
+  "#800000",
+  "#008000",
+  "#808000",
+  "#000080",
+  "#800080",
+  "#008080",
+  "#c0c0c0",
+  "#808080",
+  "#ff0000",
+  "#00ff00",
+  "#ffff00",
+  "#0000ff",
+  "#ff00ff",
+  "#00ffff",
+  "#ffffff"
+];
+function color256ToHex(index) {
+  if (index < 16) {
+    return ANSI_COLORS[index];
+  }
+  if (index < 232) {
+    const cubeIndex = index - 16;
+    const r = Math.floor(cubeIndex / 36);
+    const g = Math.floor(cubeIndex % 36 / 6);
+    const b = cubeIndex % 6;
+    const toComponent = (n) => n === 0 ? 0 : 55 + n * 40;
+    const toHex = (n) => toComponent(n).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  const gray = 8 + (index - 232) * 10;
+  const grayHex = gray.toString(16).padStart(2, "0");
+  return `#${grayHex}${grayHex}${grayHex}`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
+}
+function createEmptyStyle() {
+  return {
+    fg: null,
+    bg: null,
+    bold: false,
+    dim: false,
+    italic: false,
+    underline: false
+  };
+}
+function styleToInlineCSS(style) {
+  const parts = [];
+  if (style.fg)
+    parts.push(`color:${style.fg}`);
+  if (style.bg)
+    parts.push(`background-color:${style.bg}`);
+  if (style.bold)
+    parts.push("font-weight:bold");
+  if (style.dim)
+    parts.push("opacity:0.6");
+  if (style.italic)
+    parts.push("font-style:italic");
+  if (style.underline)
+    parts.push("text-decoration:underline");
+  return parts.join(";");
+}
+function hasStyle(style) {
+  return style.fg !== null || style.bg !== null || style.bold || style.dim || style.italic || style.underline;
+}
+function applySgrCode(params, style) {
+  let i = 0;
+  while (i < params.length) {
+    const code = params[i];
+    if (code === 0) {
+      style.fg = null;
+      style.bg = null;
+      style.bold = false;
+      style.dim = false;
+      style.italic = false;
+      style.underline = false;
+    } else if (code === 1) {
+      style.bold = true;
+    } else if (code === 2) {
+      style.dim = true;
+    } else if (code === 3) {
+      style.italic = true;
+    } else if (code === 4) {
+      style.underline = true;
+    } else if (code === 22) {
+      style.bold = false;
+      style.dim = false;
+    } else if (code === 23) {
+      style.italic = false;
+    } else if (code === 24) {
+      style.underline = false;
+    } else if (code >= 30 && code <= 37) {
+      style.fg = ANSI_COLORS[code - 30];
+    } else if (code === 38) {
+      if (params[i + 1] === 5 && params.length > i + 2) {
+        style.fg = color256ToHex(params[i + 2]);
+        i += 2;
+      } else if (params[i + 1] === 2 && params.length > i + 4) {
+        const r = params[i + 2];
+        const g = params[i + 3];
+        const b = params[i + 4];
+        style.fg = `rgb(${r},${g},${b})`;
+        i += 4;
+      }
+    } else if (code === 39) {
+      style.fg = null;
+    } else if (code >= 40 && code <= 47) {
+      style.bg = ANSI_COLORS[code - 40];
+    } else if (code === 48) {
+      if (params[i + 1] === 5 && params.length > i + 2) {
+        style.bg = color256ToHex(params[i + 2]);
+        i += 2;
+      } else if (params[i + 1] === 2 && params.length > i + 4) {
+        const r = params[i + 2];
+        const g = params[i + 3];
+        const b = params[i + 4];
+        style.bg = `rgb(${r},${g},${b})`;
+        i += 4;
+      }
+    } else if (code === 49) {
+      style.bg = null;
+    } else if (code >= 90 && code <= 97) {
+      style.fg = ANSI_COLORS[code - 90 + 8];
+    } else if (code >= 100 && code <= 107) {
+      style.bg = ANSI_COLORS[code - 100 + 8];
+    }
+    i++;
+  }
+}
+var ANSI_REGEX = /\x1b\[([\d;]*)m/g;
+function ansiToHtml(text) {
+  const style = createEmptyStyle();
+  let result = "";
+  let lastIndex = 0;
+  let inSpan = false;
+  ANSI_REGEX.lastIndex = 0;
+  let match = ANSI_REGEX.exec(text);
+  while (match !== null) {
+    const beforeText = text.slice(lastIndex, match.index);
+    if (beforeText) {
+      result += escapeHtml(beforeText);
+    }
+    const paramStr = match[1];
+    const params = paramStr ? paramStr.split(";").map((p) => parseInt(p, 10) || 0) : [0];
+    if (inSpan) {
+      result += "</span>";
+      inSpan = false;
+    }
+    applySgrCode(params, style);
+    if (hasStyle(style)) {
+      result += `<span style="${styleToInlineCSS(style)}">`;
+      inSpan = true;
+    }
+    lastIndex = match.index + match[0].length;
+    match = ANSI_REGEX.exec(text);
+  }
+  const remainingText = text.slice(lastIndex);
+  if (remainingText) {
+    result += escapeHtml(remainingText);
+  }
+  if (inSpan) {
+    result += "</span>";
+  }
+  return result;
+}
+function ansiLinesToHtml(lines) {
+  return lines.map((line) => `<div class="ansi-line">${ansiToHtml(line) || "&nbsp;"}</div>`).join("");
+}
+
+// src/core/export-html/tool-renderer.ts
+var ANSI_ESCAPE_REGEX = /\x1b\[[\d;]*m/g;
+function isBlankRenderedLine(line) {
+  return line.replace(ANSI_ESCAPE_REGEX, "").trim().length === 0;
+}
+function trimRenderedResultLines(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && isBlankRenderedLine(lines[start]))
+    start++;
+  while (end > start && isBlankRenderedLine(lines[end - 1]))
+    end--;
+  return lines.slice(start, end);
+}
+function createToolHtmlRenderer(deps) {
+  const { getToolDefinition, theme, cwd, width = 100 } = deps;
+  const renderedCallComponents = new Map;
+  const renderedResultComponents = new Map;
+  const renderedStates = new Map;
+  const renderedArgs = new Map;
+  const getState = (toolCallId) => {
+    let state = renderedStates.get(toolCallId);
+    if (!state) {
+      state = {};
+      renderedStates.set(toolCallId, state);
+    }
+    return state;
+  };
+  const createRenderContext = (toolCallId, lastComponent, expanded, isPartial, isError) => {
+    return {
+      args: renderedArgs.get(toolCallId),
+      toolCallId,
+      invalidate: () => {},
+      lastComponent,
+      state: getState(toolCallId),
+      cwd,
+      executionStarted: true,
+      argsComplete: true,
+      isPartial,
+      expanded,
+      showImages: false,
+      isError
+    };
+  };
+  return {
+    renderCall(toolCallId, toolName, args) {
+      try {
+        renderedArgs.set(toolCallId, args);
+        const toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderCall) {
+          return;
+        }
+        const component = toolDef.renderCall(args, theme, createRenderContext(toolCallId, renderedCallComponents.get(toolCallId), false, true, false));
+        renderedCallComponents.set(toolCallId, component);
+        const lines = component.render(width);
+        return ansiLinesToHtml(lines);
+      } catch {
+        return;
+      }
+    },
+    renderResult(toolCallId, toolName, result, details, isError) {
+      try {
+        const toolDef = getToolDefinition(toolName);
+        if (!toolDef?.renderResult) {
+          return;
+        }
+        const agentToolResult = {
+          content: result,
+          details,
+          isError
+        };
+        const collapsedComponent = toolDef.renderResult(agentToolResult, { expanded: false, isPartial: false }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), false, false, isError));
+        renderedResultComponents.set(toolCallId, collapsedComponent);
+        const collapsed = ansiLinesToHtml(trimRenderedResultLines(collapsedComponent.render(width)));
+        const expandedComponent = toolDef.renderResult(agentToolResult, { expanded: true, isPartial: false }, theme, createRenderContext(toolCallId, renderedResultComponents.get(toolCallId), true, false, isError));
+        renderedResultComponents.set(toolCallId, expandedComponent);
+        const expanded = ansiLinesToHtml(trimRenderedResultLines(expandedComponent.render(width)));
+        return {
+          ...collapsed && collapsed !== expanded ? { collapsed } : {},
+          expanded
+        };
+      } catch {
+        return;
+      }
+    }
+  };
+}
+export {
+  createToolHtmlRenderer
+};

package/dist/builtin/workflows/builtin/chunk-5wgwscd0.js

@@ -0,0 +1,4 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+export { __require };

package/dist/builtin/workflows/builtin/chunk-6fqs7c01.js

@@ -0,0 +1,155 @@
+import {
+  VERIFICATION_SCALE
+} from "./chunk-cg9tmks0.js";
+
+// dist/builtin/workflows/builtin/progress-scoring.ts
+import { Type } from "typebox";
+var DEFAULT_TREND_WINDOW = 3;
+var DEFAULT_RISE_DELTA = 1.5;
+var DEFAULT_FALL_DELTA = -1.5;
+var DEFAULT_REPEATS = 1;
+var CALIBRATION_RULES = [
+  "Trust observed output, not the agent's narration.",
+  "Effort and step count are NOT progress.",
+  'Agent declarations of success ("done!", "all tests pass") are ZERO evidence.',
+  "Scores may plateau or fall; wrong approaches plateau, and regressions decrease."
+];
+var PROGRESS_SCALE_ORIENTATION = `${VERIFICATION_SCALE.min} = certainly would not satisfy the acceptance criteria … ${VERIFICATION_SCALE.max} = verified satisfaction with observed output`;
+var progressSchema = Type.Object({
+  scores: Type.Array(Type.Object({
+    checkpoint: Type.Integer({ minimum: 1 }),
+    score: VERIFICATION_SCALE.schema
+  }, { additionalProperties: false }))
+}, { additionalProperties: false });
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isProgressStructuredOutput(value) {
+  if (!isRecord(value) || Object.keys(value).length !== 1 || !Object.hasOwn(value, "scores"))
+    return false;
+  return Array.isArray(value.scores);
+}
+function nullScores(checkpointCount) {
+  return Array.from({ length: checkpointCount }, () => null);
+}
+function defaultCheckpoints(stepCount) {
+  const result = [];
+  for (let checkpoint = 2;checkpoint <= stepCount - 1; checkpoint += 1)
+    result.push(checkpoint);
+  return result;
+}
+function validateCheckpoints(checkpoints, stepCount) {
+  for (const checkpoint of checkpoints) {
+    if (!Number.isInteger(checkpoint) || checkpoint < 1 || checkpoint > stepCount) {
+      throw new RangeError(`Progress checkpoint ${checkpoint} is outside the step range 1..${stepCount}.`);
+    }
+  }
+}
+function scoresFromStructured(value, checkpoints) {
+  if (!isProgressStructuredOutput(value))
+    return nullScores(checkpoints.length);
+  const requested = new Set(checkpoints);
+  const seen = new Set;
+  const scoresByCheckpoint = new Map;
+  for (const candidate of value.scores) {
+    if (!isRecord(candidate) || Object.keys(candidate).length !== 2 || !Object.hasOwn(candidate, "checkpoint") || !Object.hasOwn(candidate, "score"))
+      continue;
+    const checkpoint = candidate.checkpoint;
+    const score = candidate.score;
+    if (typeof checkpoint !== "number" || !Number.isInteger(checkpoint) || seen.has(checkpoint))
+      continue;
+    if (!requested.has(checkpoint) || typeof score !== "number" || !Number.isInteger(score) || score < VERIFICATION_SCALE.min || score > VERIFICATION_SCALE.max)
+      continue;
+    seen.add(checkpoint);
+    scoresByCheckpoint.set(checkpoint, score);
+  }
+  return checkpoints.map((checkpoint) => scoresByCheckpoint.get(checkpoint) ?? null);
+}
+async function scoreRepeat(ctx, input, checkpoints, repeat) {
+  try {
+    const result = await ctx.task(`progress-score-${repeat + 1}`, {
+      prompt: build_progress_prompt({ ...input, checkpoints }),
+      context: "fresh",
+      schema: progressSchema
+    });
+    return scoresFromStructured(result.structured, checkpoints);
+  } catch {
+    return nullScores(checkpoints.length);
+  }
+}
+async function score_progress(ctx, input) {
+  if (input.steps.length === 0)
+    throw new RangeError("Progress scoring requires a non-empty step prefix.");
+  const checkpoints = Array.from(input.checkpoints ?? defaultCheckpoints(input.steps.length));
+  validateCheckpoints(checkpoints, input.steps.length);
+  const repeats = input.repeats ?? DEFAULT_REPEATS;
+  const perRepeat = [];
+  for (let repeat = 0;repeat < repeats; repeat += 1) {
+    perRepeat.push(await scoreRepeat(ctx, input, checkpoints, repeat));
+  }
+  const scores = checkpoints.map((_, checkpointIndex) => {
+    const valid = perRepeat.map((repeat) => repeat[checkpointIndex]).filter((score) => score !== null);
+    if (valid.length === 0)
+      return null;
+    return valid.reduce((total, score) => total + score, 0) / valid.length;
+  });
+  return { checkpoints, scores, perRepeat };
+}
+function build_progress_prompt(input) {
+  const numberedSteps = input.steps.map((step, index) => `${index + 1}. ${step}`);
+  const sharedHead = [
+    "<progress_head>",
+    "<problem>",
+    input.problem,
+    "</problem>",
+    "<steps>",
+    ...numberedSteps,
+    "</steps>",
+    "<calibration>",
+    ...CALIBRATION_RULES,
+    "</calibration>",
+    "<scale>",
+    `Use VERIFICATION_SCALE ${VERIFICATION_SCALE.min}..${VERIFICATION_SCALE.max} to answer: would the CURRENT state satisfy the acceptance criteria?`,
+    PROGRESS_SCALE_ORIENTATION,
+    "Score only the supplied current state from observed output.",
+    "</scale>",
+    "</progress_head>"
+  ].join(`
+`);
+  const checkpointTail = [
+    "<checkpoints>",
+    "Score each listed 1-indexed checkpoint.",
+    ...input.checkpoints.map((checkpoint) => `- ${checkpoint}`),
+    "</checkpoints>",
+    "<output_format>",
+    `Return structured_output with scores: [{ checkpoint, score }], using integer scores from ${VERIFICATION_SCALE.min} through ${VERIFICATION_SCALE.max}.`,
+    "</output_format>"
+  ].join(`
+`);
+  return `${sharedHead}
+
+${checkpointTail}`;
+}
+function mean(values) {
+  if (values.length === 0)
+    return 0;
+  return values.reduce((total, value) => total + value, 0) / values.length;
+}
+function classify_trend(series, config = {}) {
+  const window = config.window ?? DEFAULT_TREND_WINDOW;
+  const riseDelta = config.riseDelta ?? DEFAULT_RISE_DELTA;
+  const fallDelta = config.fallDelta ?? DEFAULT_FALL_DELTA;
+  if (series.length < window + 1) {
+    return { trend: "flat", evidence: { series, window, delta: 0 } };
+  }
+  const sample = series.slice(-2 * window);
+  const usableLength = sample.length % 2 === 1 ? sample.length - 1 : sample.length;
+  const halfLength = usableLength / 2;
+  const leading = sample.slice(0, halfLength);
+  const trailing = sample.slice(sample.length - halfLength);
+  const delta = halfLength === 0 ? 0 : mean(trailing) - mean(leading);
+  const trend = delta >= riseDelta ? "rising" : delta <= fallDelta ? "regressing" : "flat";
+  return { trend, evidence: { series, window, delta } };
+}
+
+export { DEFAULT_RISE_DELTA, DEFAULT_FALL_DELTA, score_progress, classify_trend };

package/dist/builtin/workflows/builtin/chunk-7430zyas.js

@@ -0,0 +1,126 @@
+import {
+  VERIFICATION_SCALE
+} from "./chunk-cg9tmks0.js";
+
+// dist/builtin/workflows/builtin/verification-prompts.ts
+var MAX_INLINE_CANDIDATE_BYTES = 32 * 1024;
+var DEFAULT_WARM_CONCURRENCY = 4;
+var DEFAULT_OUTPUT_FORMAT = "Call structured_output with criterion_id, score (1–20), evidence, and findings containing finding and severity.";
+function inlineCandidates(head) {
+  return head.candidates.every((candidate) => Buffer.byteLength(candidate.body, "utf8") <= MAX_INLINE_CANDIDATE_BYTES);
+}
+function fallbackReadPaths(head) {
+  if (inlineCandidates(head))
+    return;
+  const paths = [];
+  for (const [index, candidate] of head.candidates.entries()) {
+    if (candidate.path === undefined) {
+      throw new TypeError(`Oversized candidate family requires a caller-bound path for every candidate; candidate ${index + 1} has no path.`);
+    }
+    paths.push(candidate.path);
+  }
+  return paths;
+}
+function candidateSection(head, readPaths) {
+  return head.candidates.map((candidate, index) => {
+    if (readPaths === undefined) {
+      return `<candidate index="${index + 1}">
+${candidate.body}
+</candidate>`;
+    }
+    return `<candidate index="${index + 1}" source="read">
+Read candidate from ${readPaths[index]}.
+</candidate>`;
+  }).join(`
+`);
+}
+function scoring_prompt_reads(head) {
+  return fallbackReadPaths(head) ?? [];
+}
+function build_scoring_prompt(head, criterion) {
+  const readPaths = fallbackReadPaths(head);
+  const sharedHead = [
+    "<scoring_head>",
+    "<task_statement>",
+    head.task,
+    "</task_statement>",
+    "<ground_truth_note>",
+    head.groundTruthNote,
+    "</ground_truth_note>",
+    "<candidates>",
+    candidateSection(head, readPaths),
+    "</candidates>",
+    "<scale_anchors>",
+    head.scaleAnchors ?? VERIFICATION_SCALE.anchors,
+    "</scale_anchors>"
+  ].join(`
+`);
+  const varyingTail = [
+    "<criterion>",
+    `<name>${criterion.name}</name>`,
+    `<description>${criterion.description}</description>`,
+    "</criterion>",
+    "<output_format>",
+    head.outputFormat ?? DEFAULT_OUTPUT_FORMAT,
+    "</output_format>"
+  ].join(`
+`);
+  return `${sharedHead}
+
+${varyingTail}`;
+}
+function boundedConcurrency(stepCount, phaseCap, inheritedCap) {
+  return Math.min(stepCount, phaseCap ?? stepCount, inheritedCap ?? stepCount);
+}
+async function warm_first_fan_out(ctx, steps, prefixKeyOf, options = {}) {
+  const warmIndices = [];
+  const restIndices = [];
+  const seen = new Set;
+  for (const [index, step] of steps.entries()) {
+    const prefixKey = prefixKeyOf(step, index);
+    if (seen.has(prefixKey))
+      restIndices.push(index);
+    else {
+      seen.add(prefixKey);
+      warmIndices.push(index);
+    }
+  }
+  const { warmConcurrency, ...parallelOptions } = options;
+  const inheritedConcurrency = parallelOptions.concurrency;
+  const resultsByIndex = new Map;
+  let warmFailure;
+  if (warmIndices.length > 0) {
+    const warmSteps = warmIndices.map((index) => steps[index]);
+    try {
+      const warmResults = await ctx.parallel(warmSteps, {
+        ...parallelOptions,
+        concurrency: boundedConcurrency(warmSteps.length, warmConcurrency ?? DEFAULT_WARM_CONCURRENCY, inheritedConcurrency),
+        failFast: false
+      });
+      for (const [resultIndex, result] of warmResults.entries()) {
+        const originalIndex = warmIndices[resultIndex];
+        if (originalIndex !== undefined)
+          resultsByIndex.set(originalIndex, result);
+      }
+    } catch (error) {
+      warmFailure = error instanceof Error ? error : new Error(String(error));
+    }
+  }
+  if (restIndices.length > 0) {
+    const restSteps = restIndices.map((index) => steps[index]);
+    const restResults = await ctx.parallel(restSteps, {
+      ...parallelOptions,
+      concurrency: boundedConcurrency(restSteps.length, undefined, inheritedConcurrency)
+    });
+    for (const [resultIndex, result] of restResults.entries()) {
+      const originalIndex = restIndices[resultIndex];
+      if (originalIndex !== undefined)
+        resultsByIndex.set(originalIndex, result);
+    }
+  }
+  if (warmFailure !== undefined)
+    throw warmFailure;
+  return steps.map((_, index) => resultsByIndex.get(index)).filter((result) => result !== undefined);
+}
+
+export { scoring_prompt_reads, build_scoring_prompt, warm_first_fan_out };

package/dist/builtin/workflows/builtin/chunk-7at6dnkr.js

@@ -0,0 +1,33 @@
+// dist/builtin/workflows/builtin/verification-usage.ts
+function fold_usage(results) {
+  const totals = {
+    calls: 0,
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0,
+    turns: 0
+  };
+  for (const result of results) {
+    for (const attempt of result.modelAttempts ?? []) {
+      totals.calls += 1;
+      const usage = attempt.usage;
+      if (usage === undefined)
+        continue;
+      totals.input += usage.input ?? 0;
+      totals.output += usage.output ?? 0;
+      totals.cacheRead += usage.cacheRead ?? 0;
+      totals.cacheWrite += usage.cacheWrite ?? 0;
+      totals.cost += usage.cost ?? 0;
+      totals.turns += usage.turns ?? 0;
+    }
+  }
+  const cacheDenominator = totals.input + totals.cacheRead;
+  return {
+    ...totals,
+    cacheHitRate: cacheDenominator === 0 ? 0 : totals.cacheRead / cacheDenominator
+  };
+}
+
+export { fold_usage };