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

package/dist/builtin/workflows/builtin/chunk-hzzn6adg.js

@@ -0,0 +1,221 @@
+import {
+  build_scoring_prompt,
+  scoring_prompt_reads
+} from "./chunk-7430zyas.js";
+import {
+  stableArtifactRoot
+} from "./chunk-wpckd35c.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/generate-and-filter.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/generate-and-filter-runner.ts
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+
+// dist/builtin/workflows/builtin/generate-and-filter-prompts.ts
+var GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
+var READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
+function renderGeneratorPrompt(task, ordinal) {
+  return `<role>
+You independently generate candidate ${ordinal}; do not imitate or assume other candidates.
+</role>
+
+<success_criteria>
+One distinct, concrete candidate states its value, constraints, risks, and how it can be evaluated.
+</success_criteria>
+
+<stop_rules>
+Stop after one self-contained, evaluable candidate; do not add alternatives.
+</stop_rules>
+
+<output_format>
+A candidate artifact with title, proposal, criteria-based rationale, risks, and evaluation evidence. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+${task}
+</objective>`;
+}
+function renderFilterPrompt(task, candidatePaths, shortlistSize) {
+  return `<artifacts>
+Read every candidate: ${candidatePaths.join(", ")}
+</artifacts>
+
+<role>
+You deduplicate and filter independently generated candidates.
+</role>
+
+<rubric>
+First collapse substantively equivalent candidates. Then score fit to the task, feasibility, evidence, distinctiveness, and risk. Near-duplicates must not gain weight by repetition. Record every discarded candidate and a concrete reason.
+</rubric>
+
+<success_criteria>
+At most ${shortlistSize} strongest distinct candidates remain, ranked by the rubric, and every discarded candidate has a concrete reason.
+</success_criteria>
+
+<stop_rules>
+Stop after every candidate is shortlisted once or recorded as discarded.
+</stop_rules>
+
+<output_format>
+Call structured_output with shortlist (candidate artifact paths in ranked order) and discarded entries containing path and a concise, criteria-based reason.
+</output_format>
+
+<objective>
+Select at most ${shortlistSize} strongest candidates for: ${task}
+</objective>`;
+}
+function renderJudgePrompt(task, filterPath, shortlistSize, candidates = []) {
+  const head = {
+    task: `Rank at most ${shortlistSize} distinct candidate paths for: ${task}.`,
+    groundTruthNote: `Read the filter report at ${filterPath} and every candidate path it references before judging.`,
+    candidates,
+    outputFormat: "Call structured_output with shortlist (candidate paths in ranked order) and rationale (a concise, criteria-based explanation)."
+  };
+  const prompt = build_scoring_prompt(head, {
+    id: "filtered_shortlist",
+    name: "Filtered shortlist",
+    description: "Check task fit, feasibility, evidence, distinctiveness, and material risk; do not restore a duplicate merely because it is phrased differently."
+  });
+  return { prompt, reads: [filterPath, ...scoring_prompt_reads(head)] };
+}
+function renderFinalShortlistPrompt(task, decisionPath) {
+  return `<artifact>
+Read the authoritative selection at ${decisionPath}; follow its order and do not add candidates.
+</artifact>
+
+<role>
+You present a concise, actionable final shortlist so the reader can choose the next evaluation without reading the selection session.
+</role>
+
+<success_criteria>
+Every selected candidate appears once in authoritative order with its differentiator, evidence, tradeoffs, and recommended next evaluation.
+</success_criteria>
+
+<stop_rules>
+Stop after presenting every selected candidate once; do not add or reorder candidates.
+</stop_rules>
+
+<output_format>
+Ranked markdown shortlist with candidate path, differentiator, evidence, tradeoffs, and recommended next evaluation. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+Summarize the selected candidates for: ${task}
+</objective>`;
+}
+
+// dist/builtin/workflows/builtin/generate-and-filter-runner.ts
+var filterSchema = Type.Object({
+  shortlist: Type.Array(Type.String()),
+  discarded: Type.Array(Type.Object({ path: Type.String(), reason: Type.String() }, { additionalProperties: false }))
+}, { additionalProperties: false });
+var judgeSchema = Type.Object({ shortlist: Type.Array(Type.String()), rationale: Type.String() }, { additionalProperties: false });
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function strings(value) {
+  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function filterDecision(value) {
+  if (value === undefined || !isRecord(value) || !strings(value.shortlist) || !Array.isArray(value.discarded))
+    return;
+  const valid = value.discarded.every((entry) => isRecord(entry) && typeof entry.path === "string" && typeof entry.reason === "string");
+  return valid ? value : undefined;
+}
+function judgeDecision(value) {
+  return value !== undefined && isRecord(value) && strings(value.shortlist) && typeof value.rationale === "string" ? value : undefined;
+}
+async function runGenerateAndFilter(ctx) {
+  const root = await stableArtifactRoot(ctx, "generate-and-filter");
+  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join(root, `candidate-${index + 1}.md`));
+  const shortlistLimit = Math.min(ctx.inputs.shortlist_size, ctx.inputs.num_candidates);
+  await ctx.parallel(candidatePaths.map((path, index) => ({
+    name: `generate-${index + 1}`,
+    prompt: renderGeneratorPrompt(ctx.inputs.prompt, index + 1),
+    context: "fresh",
+    output: path,
+    outputMode: "file-only"
+  })), { concurrency: ctx.inputs.max_concurrency, failFast: false });
+  const manifestPath = join(root, "manifest.json");
+  await writeFile(manifestPath, JSON.stringify({ task: ctx.inputs.prompt, candidate_artifact_paths: candidatePaths }, null, 2));
+  const filterPath = join(root, "filter.json");
+  const filtered = await ctx.task("dedupe-and-filter", {
+    prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit),
+    context: "fresh",
+    reads: [manifestPath, ...candidatePaths],
+    schema: filterSchema
+  });
+  const filteredDecision = filterDecision(filtered.structured);
+  await writeFile(filterPath, `${JSON.stringify(filteredDecision ?? { shortlist: [], discarded: [] }, null, 2)}
+`);
+  const selectCandidates = (paths) => [...new Set(paths.filter((path) => candidatePaths.includes(path)))].slice(0, shortlistLimit);
+  const fallbackShortlist = candidatePaths.slice(0, shortlistLimit);
+  const filteredShortlist = selectCandidates(filteredDecision?.shortlist ?? []);
+  let shortlist = filteredShortlist.length > 0 ? filteredShortlist : fallbackShortlist;
+  let judgePath = null;
+  let decisionPath = filterPath;
+  if (ctx.inputs.use_judge) {
+    judgePath = join(root, "judge.json");
+    const judgeCandidates = await Promise.all(shortlist.map(async (path) => ({ path, body: await readFile(path, "utf8") })));
+    const judgePrompt = renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit, judgeCandidates);
+    const judged = await ctx.task("judge", {
+      prompt: judgePrompt.prompt,
+      context: "fresh",
+      reads: judgePrompt.reads,
+      schema: judgeSchema
+    });
+    const judgedDecision = judgeDecision(judged.structured);
+    await writeFile(judgePath, `${JSON.stringify(judgedDecision ?? { shortlist: [], rationale: "Judge stage produced no valid structured decision." }, null, 2)}
+`);
+    const judgedShortlist = selectCandidates(judgedDecision?.shortlist ?? []);
+    shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
+    decisionPath = judgePath;
+  }
+  const finalPath = join(root, "shortlist.md");
+  const finalShortlist = await ctx.task("final-shortlist", {
+    prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath),
+    context: "fresh",
+    reads: [decisionPath, ...shortlist],
+    output: finalPath,
+    outputMode: "file-only"
+  });
+  return { result: finalShortlist.text, shortlist, candidate_artifact_paths: candidatePaths, filter_path: filterPath, judge_path: judgePath, final_path: finalPath, artifact_dir: root, manifest_path: manifestPath };
+}
+
+// dist/builtin/workflows/builtin/generate-and-filter.ts
+var generate_and_filter_default = workflow({
+  name: "generate-and-filter",
+  description: "Generate more independent candidates than needed, deduplicate and filter them by rubric, optionally judge them, and return a parent-consumable shortlist.",
+  heartbeatIntervalMinutes: 15,
+  inputs: {
+    prompt: Type2.String({ description: "Prompt for candidate generation and selection." }),
+    num_candidates: Type2.Integer({ minimum: 2, maximum: 20, default: 8, description: "Number of independent candidates to generate." }),
+    shortlist_size: Type2.Integer({ minimum: 1, maximum: 10, default: 3, description: "Maximum number of candidates in the final shortlist." }),
+    use_judge: Type2.Boolean({ default: true, description: "Whether an independent judge reviews the filtered shortlist." }),
+    max_concurrency: Type2.Integer({ minimum: 1, maximum: 12, default: 4, description: "Maximum simultaneous generator stages." })
+  },
+  outputs: {
+    result: Type2.String({ description: "Compact reference to the final shortlist report artifact; read `final_path` for the full report." }),
+    shortlist: Type2.Array(Type2.String(), { description: "Ranked paths to selected candidate artifacts." }),
+    candidate_artifact_paths: Type2.Array(Type2.String(), { description: "Paths to every generated candidate artifact." }),
+    filter_path: Type2.String({ description: "Path to the dedupe and filter decision." }),
+    judge_path: Type2.Union([Type2.String(), Type2.Null()], { description: "Path to the optional judge decision, or null when disabled." }),
+    final_path: Type2.String({ description: "Path to the final shortlist report." }),
+    artifact_dir: Type2.String({ description: "Directory containing run artifacts." }),
+    manifest_path: Type2.String({ description: "Path to the candidate artifact manifest." })
+  },
+  run: async (ctx) => await runGenerateAndFilter(withSteeringPropagationContext(ctx))
+});
+
+export { generate_and_filter_default };