pi-long-task 0.3.9 → 0.3.11

package/src/input_router.ts

@@ -1,3 +1,5 @@
+import { inferCoverageGoalText } from "./coverage_goal.ts";
+
 const LONG_TASK_RE = /\b(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
 const DIRECT_LONG_TASK_REQUEST_RE =
   /\b(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
@@ -6,20 +8,69 @@ const WANT_LONG_TASK_RE =
 const NEGATED_LONG_TASK_RE =
   /\b(?:do\s+not|don't|dont|never)\s+(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
 const INFORMATION_QUESTION_RE = /^\s*(?:how|what|why|when|where|who)\b/i;
-const EXPLICIT_TOOL_RE = /\bpi_long_task\b/i;
+const EXPLICIT_TOOL_RE = /\b(?:pi_long_task|pi_goal_task)\b/i;
+const GOAL_LOOP_RE =
+  /\b(?:goal[-\s]?oriented\s+(?:loop|long[-\s]?task|task)|goal\s+(?:loop|task)|iterative\s+long[-\s]?task|repeat\s+until\s+complete|iterate\s+until\s+complete)\b/i;
+const DIRECT_GOAL_TASK_REQUEST_RE =
+  /\b(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?(?:goal[-\s]?oriented\s+(?:loop|long[-\s]?task|task)|goal\s+(?:loop|task)|iterative\s+long[-\s]?task)\b/i;
 
 const COMMIT_FALSE_RE =
   /\b(?:without|no|disable|disabled|off)\s+commits?\b|\bcommits?\s*(?:false|off|disabled)\b|\bcommit\s*:\s*(?:false|off|no)\b|\b(?:do\s+not|don't|dont)\s+commit\b/i;
 const COMMIT_TRUE_RE =
   /\bwith\s+commits?\b|\bcommits?\s*(?:true|on|enabled)\b|\bcommit\s*:\s*(?:true|on|yes)\b|\bcommit(?:ting)?\s+as\s+(?:you|we)\s+go\b|\b(?:make|create|include|allow|enable)\s+commits?\b/i;
+const GOAL_RE = /\b(?:with\s+(?:the\s+)?goal|goal)\s*(?::|=|\b(?:to|of|for|that)\b)\s*([\s\S]+)$/i;
+const TRAILING_COMMIT_MODIFIER_RE =
+  /(?:\s+(?:with|without|no|enable|enabled|disable|disabled)\s+commits?|\s+commits?\s*(?:true|false|on|off|enabled|disabled)|\s+commit\s*:\s*(?:true|false|on|off|yes|no))\s*$/i;
+const TRAILING_ITERATION_MODIFIER_RE =
+  /(?:[.;,\s]+(?:(?:use|set)?\s*(?:min(?:imum)?|max(?:imum)?)\s+(?:iterations?|loops?|passes?|cycles?)\s*(?::|=|of|to)?\s*\d+|at\s+least\s+\d+\s*(?:iterations?|loops?|passes?|cycles?)|(?:i\s+want\s+it\s+to\s+)?run\s+(?:for|in)\s*\d+\s*(?:iterations?|loops?|passes?|cycles?)))[.!?]*\s*$/i;
+
+export interface ParsedLongTaskRequestOptions {
+  commit: boolean;
+  goal?: string;
+}
+
+export interface ParsedGoalTaskRequestOptions extends ParsedLongTaskRequestOptions {
+  minIterations?: number;
+  maxIterations?: number;
+}
 
 export function longTaskInputTransform(text: string): string | undefined {
+  const goalLoopPrompt = goalTaskInputTransform(text);
+  if (goalLoopPrompt) {
+    return goalLoopPrompt;
+  }
+
   if (!isNaturalLanguageLongTaskRequest(text)) {
     return undefined;
   }
 
-  const commit = inferCommitSetting(text) ?? false;
-  return buildLongTaskToolPrompt(text, commit);
+  return buildLongTaskToolPrompt(text, parseLongTaskRequestOptions(text));
+}
+
+export function goalTaskInputTransform(text: string): string | undefined {
+  if (!isNaturalLanguageGoalTaskRequest(text)) {
+    return undefined;
+  }
+
+  return buildGoalTaskToolPrompt(text, parseGoalTaskRequestOptions(text));
+}
+
+export function parseLongTaskRequestOptions(text: string): ParsedLongTaskRequestOptions {
+  return {
+    commit: inferCommitSetting(text) ?? false,
+    goal: inferGoalSetting(text),
+  };
+}
+
+export function parseGoalTaskRequestOptions(text: string): ParsedGoalTaskRequestOptions {
+  const maxIterations = inferMaxIterations(text);
+  const minIterations = inferMinIterations(text) ?? inferExactIterationCount(text) ?? maxIterations;
+  return {
+    commit: inferCommitSetting(text) ?? true,
+    goal: inferGoalSetting(text) ?? inferGoalLoopText(text),
+    minIterations,
+    maxIterations,
+  };
 }
 
 export function isNaturalLanguageLongTaskRequest(text: string): boolean {
@@ -33,6 +84,22 @@ export function isNaturalLanguageLongTaskRequest(text: string): boolean {
   return DIRECT_LONG_TASK_REQUEST_RE.test(trimmed) || WANT_LONG_TASK_RE.test(trimmed);
 }
 
+export function isNaturalLanguageGoalTaskRequest(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.startsWith("/") || EXPLICIT_TOOL_RE.test(trimmed)) {
+    return false;
+  }
+  if (INFORMATION_QUESTION_RE.test(trimmed) || NEGATED_LONG_TASK_RE.test(trimmed)) {
+    return false;
+  }
+  return (
+    GOAL_LOOP_RE.test(trimmed) &&
+    (DIRECT_GOAL_TASK_REQUEST_RE.test(trimmed) ||
+      DIRECT_LONG_TASK_REQUEST_RE.test(trimmed) ||
+      WANT_LONG_TASK_RE.test(trimmed))
+  );
+}
+
 export function inferCommitSetting(text: string): boolean | undefined {
   if (COMMIT_FALSE_RE.test(text)) {
     return false;
@@ -43,11 +110,91 @@ export function inferCommitSetting(text: string): boolean | undefined {
   return undefined;
 }
 
-function buildLongTaskToolPrompt(originalText: string, commit: boolean): string {
+export function inferGoalSetting(text: string): string | undefined {
+  const match = GOAL_RE.exec(text);
+  if (!match?.[1]) {
+    return inferCoverageGoalText(text);
+  }
+  return normalizeGoalText(match[1]);
+}
+
+function normalizeGoalText(text: string): string | undefined {
+  let goal = text.trim();
+  while (TRAILING_COMMIT_MODIFIER_RE.test(goal) || TRAILING_ITERATION_MODIFIER_RE.test(goal)) {
+    goal = goal.replace(TRAILING_COMMIT_MODIFIER_RE, "").replace(TRAILING_ITERATION_MODIFIER_RE, "").trim();
+  }
+  goal = goal.replace(/^["'“”‘’]+|["'“”‘’.,;:!?]+$/g, "").trim();
+  return goal || undefined;
+}
+
+function inferMaxIterations(text: string): number | undefined {
+  const match = /\bmax(?:imum)?\s+(?:iterations?|loops?|passes?|cycles?)\s*(?::|=|of|to)?\s*(\d+)\b/i.exec(text);
+  return positiveIntegerMatch(match?.[1]);
+}
+
+function inferMinIterations(text: string): number | undefined {
+  const explicitMin = /\bmin(?:imum)?\s+(?:iterations?|loops?|passes?|cycles?)\s*(?::|=|of|to)?\s*(\d+)\b/i.exec(text);
+  if (explicitMin?.[1]) {
+    return positiveIntegerMatch(explicitMin[1]);
+  }
+  const atLeast = /\bat\s+least\s+(\d+)\s*(?:iterations?|loops?|passes?|cycles?)\b/i.exec(text);
+  return positiveIntegerMatch(atLeast?.[1]);
+}
+
+function inferExactIterationCount(text: string): number | undefined {
+  const match =
+    /\b(?:run|iterate|loop|cycle|spin)(?:\s+\w+){0,6}?\s+(?:for|in)?\s*(\d+)\s*(?:iterations?|loops?|passes?|cycles?)\b/i.exec(
+      text,
+    );
+  return positiveIntegerMatch(match?.[1]);
+}
+
+function positiveIntegerMatch(value: string | undefined): number | undefined {
+  const parsed = value ? Number.parseInt(value, 10) : undefined;
+  return parsed && Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+
+function inferGoalLoopText(text: string): string | undefined {
+  let goal = text.trim();
+  goal = goal.replace(
+    /^\s*(?:please\s+)?(?:run|start|do|handle|execute|launch|kick\s+off|use)\s+(?:a\s+|the\s+)?/i,
+    "",
+  );
+  goal = goal.replace(GOAL_LOOP_RE, "").trim();
+  goal = goal.replace(/^\s*(?:with\s+)?(?:goal|to|for|that)\b\s*/i, "");
+  return normalizeGoalText(goal);
+}
+
+function buildLongTaskToolPrompt(originalText: string, options: ParsedLongTaskRequestOptions): string {
+  const goalLine = options.goal ? [`Set goal to ${JSON.stringify(options.goal)}.`] : [];
   return [
     "Use the pi_long_task tool for this request.",
-    `Set commit to ${commit ? "true" : "false"}.`,
-    "Set inputText to the user's original request below. Do not perform the work directly outside pi_long_task.",
+    `Set commit to ${options.commit ? "true" : "false"}.`,
+    ...goalLine,
+    "Do not rely on inputText for parsed options; commit and goal are parsed separately. Use the original request as inputText only when the tool call includes inputText.",
+    "Do not perform the work directly outside pi_long_task.",
+    "",
+    "Original request:",
+    "```text",
+    originalText.trim(),
+    "```",
+  ].join("\n");
+}
+
+function buildGoalTaskToolPrompt(originalText: string, options: ParsedGoalTaskRequestOptions): string {
+  const goalLine = options.goal
+    ? `Set goal to ${JSON.stringify(options.goal)}.`
+    : "Set goal from the original request.";
+  const minIterationsLine = options.minIterations ? [`Set minIterations to ${options.minIterations}.`] : [];
+  const maxIterationsLine = options.maxIterations ? [`Set maxIterations to ${options.maxIterations}.`] : [];
+  return [
+    "Use the pi_goal_task tool for this request.",
+    goalLine,
+    `Set commit to ${options.commit ? "true" : "false"}.`,
+    ...minIterationsLine,
+    ...maxIterationsLine,
+    "The goal loop will generate TODO markdown, execute it as a long task, review completion, and repeat until complete or stopped by limits.",
+    "Do not perform the work directly outside pi_goal_task.",
     "",
     "Original request:",
     "```text",

package/src/render.ts

@@ -1,6 +1,7 @@
 import type { AgentToolResult, Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
 import { Text, type Component } from "@earendil-works/pi-tui";
 
+import type { GoalLoopState, GoalLoopStatus } from "./goal_loop.ts";
 import type { TaskProgressModel } from "./task_progress.ts";
 import type { CoordinatorCommitSummary, CoordinatorRemainingTask, CoordinatorStatus } from "./types.ts";
 
@@ -18,6 +19,7 @@ export interface CoordinatorResultForRendering {
   remainingTasks?: CoordinatorRemainingTask[];
   taskProgress?: TaskProgressModel;
   workerCostTotal?: number;
+  goal?: string;
   error?: string;
 }
 
@@ -80,11 +82,16 @@ export function formatCoordinatorResultMessage(result: CoordinatorResultForRende
   return lines.join("\n");
 }
 
-export function renderLongTaskToolCall(args: { inputText?: string; commit?: boolean }, theme: Theme): Text {
+export function renderLongTaskToolCall(
+  args: { inputText?: string; commit?: boolean; goal?: string },
+  theme: Theme,
+): Text {
   const commit = args.commit ? theme.fg("warning", "commit:on") : theme.fg("dim", "commit:off");
   const input = oneLine(args.inputText ?? "");
+  const goal = oneLine(args.goal ?? "");
+  const goalPreview = goal ? ` ${theme.fg("muted", `goal:${quote(truncatePlain(goal, 48))}`)}` : "";
   const preview = input ? ` ${theme.fg("muted", quote(truncatePlain(input, 96)))}` : "";
-  return new Text(`${theme.fg("toolTitle", theme.bold("pi_long_task"))} ${commit}${preview}`, 0, 0);
+  return new Text(`${theme.fg("toolTitle", theme.bold("pi_long_task"))} ${commit}${goalPreview}${preview}`, 0, 0);
 }
 
 export function renderLongTaskToolResult(
@@ -105,6 +112,218 @@ export function renderLongTaskToolResult(
   return new Text(renderLongTaskSummary(finalDetails, options.expanded, theme), 0, 0);
 }
 
+export interface GoalLoopResultForRendering {
+  state: GoalLoopState;
+  resultPath: string;
+  workerCostTotal: number;
+  reviewerCostTotal: number;
+  totalCost: number;
+}
+
+export interface GoalTaskToolRenderDetails {
+  goalRunId: string;
+  goal: string;
+  status: GoalLoopStatus;
+  currentIteration: number;
+  totalIterations: number;
+  minIterations: number;
+  maxIterations: number;
+  resultPath: string;
+  statePath?: string;
+  tracePath?: string;
+  workerCostTotal?: number;
+  reviewerCostTotal?: number;
+  totalCost?: number;
+  completionReason?: string;
+  latestReviewerDecision?: string;
+  remainingWork?: string[];
+  error?: string;
+}
+
+export function formatGoalLoopResultMessage(result: GoalLoopResultForRendering): string {
+  const state = result.state;
+  const lines = [
+    `Pi Goal Task: ${state.status}`,
+    `Goal: ${state.goal}`,
+    `Iterations: ${state.iterations.length}/${state.limits.maxIterations}`,
+    `Minimum iterations: ${state.limits.minIterations}`,
+    `Result file: ${result.resultPath}`,
+    `State file: ${state.goalRunDir}/GOAL_STATE.json`,
+  ];
+  if (state.completion?.reason) {
+    lines.push(`Outcome: ${state.completion.reason}`);
+  }
+  if (result.totalCost > 0) {
+    lines.push(`Worker/reviewer spend: ${formatCost(result.totalCost)}`);
+  }
+  const latestReview = [...state.iterations].reverse().find((iteration) => iteration.reviewerResult)?.reviewerResult;
+  if (latestReview) {
+    lines.push(`Latest review: ${latestReview.decision} — ${latestReview.summary}`);
+    if (latestReview.remainingWork.length > 0) {
+      lines.push("Remaining work:", ...latestReview.remainingWork.map((item) => `- ${item}`));
+    }
+  }
+  return lines.join("\n");
+}
+
+export function goalTaskDetailsFromResult(result: GoalLoopResultForRendering): GoalTaskToolRenderDetails {
+  const latestReview = [...result.state.iterations]
+    .reverse()
+    .find((iteration) => iteration.reviewerResult)?.reviewerResult;
+  return {
+    goalRunId: result.state.goalRunId,
+    goal: result.state.goal,
+    status: result.state.status,
+    currentIteration: result.state.currentIteration,
+    totalIterations: result.state.iterations.length,
+    minIterations: result.state.limits.minIterations,
+    maxIterations: result.state.limits.maxIterations,
+    resultPath: result.resultPath,
+    statePath: `${result.state.goalRunDir}/GOAL_STATE.json`,
+    tracePath: `${result.state.goalRunDir}/GOAL_TRACE.jsonl`,
+    workerCostTotal: result.workerCostTotal,
+    reviewerCostTotal: result.reviewerCostTotal,
+    totalCost: result.totalCost,
+    completionReason: result.state.completion?.reason,
+    latestReviewerDecision: latestReview?.decision,
+    remainingWork: latestReview?.remainingWork,
+  };
+}
+
+export function renderGoalTaskToolCall(
+  args: {
+    goal?: string;
+    commit?: boolean;
+    minIterations?: number;
+    maxIterations?: number;
+    timeoutMs?: number;
+    reviewerTimeoutMs?: number;
+  },
+  theme: Theme,
+): Text {
+  const commit = (args.commit ?? true) ? theme.fg("warning", "commit:on") : theme.fg("dim", "commit:off");
+  const goal = oneLine(args.goal ?? "");
+  const limits = [
+    args.minIterations ? `min:${args.minIterations}` : undefined,
+    args.maxIterations ? `max:${args.maxIterations}` : undefined,
+    args.timeoutMs ? `timeout:${args.timeoutMs}ms` : undefined,
+    args.reviewerTimeoutMs ? `review:${args.reviewerTimeoutMs}ms` : undefined,
+  ]
+    .filter(Boolean)
+    .join(" ");
+  const limitPreview = limits ? ` ${theme.fg("muted", limits)}` : "";
+  const goalPreview = goal ? ` ${theme.fg("muted", quote(truncatePlain(goal, 80)))}` : "";
+  return new Text(`${theme.fg("toolTitle", theme.bold("pi_goal_task"))} ${commit}${limitPreview}${goalPreview}`, 0, 0);
+}
+
+export function renderGoalTaskToolResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): Component {
+  const details = recordOrUndefined(result.details);
+  if (options.isPartial) {
+    return new Text(renderGoalTaskProgress(details, contentText(result), theme), 0, 0);
+  }
+
+  const finalDetails = goalTaskDetails(details);
+  if (!finalDetails) {
+    return new Text(contentText(result), 0, 0);
+  }
+
+  return new Text(renderGoalTaskSummary(finalDetails, options.expanded, theme), 0, 0);
+}
+
+function renderGoalTaskProgress(details: Record<string, unknown> | undefined, fallback: string, theme: Theme): string {
+  const message = stringValue(details?.message) || firstLine(fallback) || "Pi Goal Task is running...";
+  const phase = stringValue(details?.phase);
+  const iteration = numberValue(details?.iteration) ?? numberValue(details?.currentIteration);
+  const minIterations = numberValue(details?.minIterations);
+  const maxIterations = numberValue(details?.maxIterations);
+  const status = stringValue(details?.status) || "running";
+  const cost = numberValue(details?.totalCost);
+  const meta = [
+    iteration ? `iteration ${iteration}${maxIterations ? `/${maxIterations}` : ""}` : undefined,
+    minIterations && iteration && iteration < minIterations ? `min:${minIterations}` : undefined,
+    status,
+    cost && cost > 0 ? formatCost(cost) : undefined,
+  ]
+    .filter(Boolean)
+    .join(` ${theme.fg("dim", "·")} `);
+  const icon = phase === "complete" ? (status === "done" ? "✓" : "!") : "+";
+  const color = phase === "complete" ? statusColor(status) : "warning";
+  return `${theme.fg(color, icon)} ${theme.fg(color, "Pi Goal Task")}${meta ? ` ${theme.fg("dim", "·")} ${theme.fg("muted", meta)}` : ""}\n  ${theme.fg("dim", message)}`;
+}
+
+function renderGoalTaskSummary(details: GoalTaskToolRenderDetails, expanded: boolean, theme: Theme): string {
+  const statusStyle = statusColor(details.status);
+  const icon =
+    details.status === "done" ? "✓" : details.status === "failed" ? "✗" : details.status === "cancelled" ? "×" : "!";
+  const summary = [
+    `${theme.fg(statusStyle, icon)} ${theme.fg("toolTitle", theme.bold("Pi Goal Task"))} ${theme.fg(statusStyle, details.status)}`,
+    theme.fg("muted", `${details.totalIterations}/${details.maxIterations} iterations`),
+    details.totalIterations < details.minIterations ? theme.fg("muted", `min:${details.minIterations}`) : undefined,
+    details.latestReviewerDecision ? theme.fg("muted", `review:${details.latestReviewerDecision}`) : undefined,
+    details.totalCost ? theme.fg("muted", `spend ${formatCost(details.totalCost)}`) : undefined,
+  ].filter(Boolean);
+
+  if (!expanded) {
+    return summary.join(" — ");
+  }
+
+  const lines = [summary.join(" — "), theme.fg("muted", details.goal)];
+  if (details.completionReason) {
+    lines.push(theme.fg("dim", `Outcome: ${details.completionReason}`));
+  }
+  lines.push(theme.fg("dim", `Result: ${details.resultPath}`));
+  if (details.statePath) {
+    lines.push(theme.fg("dim", `State: ${details.statePath}`));
+  }
+  if (details.tracePath) {
+    lines.push(theme.fg("dim", `Trace: ${details.tracePath}`));
+  }
+  const remaining = details.remainingWork ?? [];
+  if (remaining.length > 0) {
+    lines.push(theme.fg("muted", "Remaining work:"), ...remaining.map((item) => theme.fg("dim", `- ${item}`)));
+  }
+  if (details.error) {
+    lines.push(theme.fg("error", `Error: ${details.error}`));
+  }
+  return lines.join("\n");
+}
+
+function goalTaskDetails(details: Record<string, unknown> | undefined): GoalTaskToolRenderDetails | undefined {
+  if (!details) {
+    return undefined;
+  }
+  const goalRunId = stringValue(details.goalRunId);
+  const goal = stringValue(details.goal);
+  const status = goalLoopStatus(details.status);
+  const resultPath = stringValue(details.resultPath);
+  if (!goalRunId || !goal || !status || !resultPath) {
+    return undefined;
+  }
+  return {
+    goalRunId,
+    goal,
+    status,
+    currentIteration: numberValue(details.currentIteration) ?? 0,
+    totalIterations: numberValue(details.totalIterations) ?? 0,
+    minIterations: numberValue(details.minIterations) ?? 0,
+    maxIterations: numberValue(details.maxIterations) ?? 0,
+    resultPath,
+    statePath: stringValue(details.statePath),
+    tracePath: stringValue(details.tracePath),
+    workerCostTotal: numberValue(details.workerCostTotal),
+    reviewerCostTotal: numberValue(details.reviewerCostTotal),
+    totalCost: numberValue(details.totalCost),
+    completionReason: stringValue(details.completionReason),
+    latestReviewerDecision: stringValue(details.latestReviewerDecision),
+    remainingWork: stringArray(details.remainingWork),
+    error: stringValue(details.error),
+  };
+}
+
 function renderLongTaskProgress(details: Record<string, unknown> | undefined, fallback: string, theme: Theme): string {
   const message = stringValue(details?.message) || firstLine(fallback) || "Pi Long Task is running...";
   const phase = stringValue(details?.phase);
@@ -422,11 +641,11 @@ function remainingTaskSummaries(value: unknown): CoordinatorRemainingTask[] {
   });
 }
 
-function statusColor(status: CoordinatorStatus): "success" | "warning" | "error" {
+function statusColor(status: CoordinatorStatus | GoalLoopStatus | string): "success" | "warning" | "error" {
   if (status === "done") {
     return "success";
   }
-  if (status === "failed") {
+  if (status === "failed" || status === "cancelled") {
     return "error";
   }
   return "warning";
@@ -436,6 +655,17 @@ function isCoordinatorStatus(value: string): value is CoordinatorStatus {
   return value === "done" || value === "partial" || value === "blocked" || value === "failed";
 }
 
+function goalLoopStatus(value: unknown): GoalLoopStatus | undefined {
+  return value === "running" ||
+    value === "done" ||
+    value === "partial" ||
+    value === "blocked" ||
+    value === "failed" ||
+    value === "cancelled"
+    ? value
+    : undefined;
+}
+
 function contentText(result: AgentToolResult<unknown>): string {
   const content = Array.isArray(result.content) ? result.content : [];
   return content
@@ -475,6 +705,10 @@ function nonNegativeNumberValue(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
 }
 
+function stringArray(value: unknown): string[] {
+  return Array.isArray(value) ? value.filter((item): item is string => typeof item === "string") : [];
+}
+
 function formatCost(value: number): string {
   if (value === 0) {
     return "$0";

package/src/todo_generator.ts

@@ -1,3 +1,9 @@
+import {
+  coverageGoalAction,
+  coverageGoalVerification,
+  coverageGoalVerifyBullet,
+  parseCoverageGoal,
+} from "./coverage_goal.ts";
 import { parseTasks, TodoParseError } from "./todo_parser.ts";
 
 const TODO_HEADING_RE = /^##\s+TODO\s+(\d+)\s+[—-]\s+(.+?)\s*$/gm;
@@ -20,21 +26,21 @@ interface ExistingTask {
   body: string;
 }
 
-export function todoMarkdownFromString(rawInput: string): string | undefined {
+export function todoMarkdownFromString(rawInput: string, goal?: string): string | undefined {
   const input = rawInput.trim();
   if (!input) {
     return undefined;
   }
 
   if (hasTodoHeadings(input)) {
-    const markdown = normalizeExistingTodoMarkdown(input);
+    const markdown = applyGoalInstructionsToTodoMarkdown(normalizeExistingTodoMarkdown(input), goal);
     validateTodoMarkdown(markdown);
     return markdown;
   }
 
   const listItems = simpleListItems(input);
   if (listItems.length >= 2) {
-    const markdown = generatedTodoMarkdown(listItems);
+    const markdown = applyGoalInstructionsToTodoMarkdown(generatedTodoMarkdown(listItems), goal);
     validateTodoMarkdown(markdown);
     return markdown;
   }
@@ -116,12 +122,134 @@ export function validateTodoMarkdown(markdown: string): void {
   });
 }
 
-export function buildTodoCreationPrompt(rawInput: string): string {
-  return `Convert the following raw project request into Pi Long Task-compatible TODO markdown.\n\nRequirements:\n- Output only markdown, with no commentary and no code fence.\n- Start with exactly: # Pi Long Task TODO\n- Include a ## Progress section with one unchecked line per task: - [ ] TODO N — Title\n- Include a --- separator before task sections.\n- Create sequential sections named ## TODO N — Title.\n- Each task section must include **Goal:**, **Status:** with unchecked checkbox items, **Verify:** with concrete verification guidance, and **Done when:**.\n- Preserve any global instructions or constraints that apply to all tasks above ## Progress.\n- Keep tasks focused and independently assignable to worker sessions.\n\nRaw input:\n\n${rawInput.trim()}\n`;
+export function applyGoalInstructionsToTodoMarkdown(markdown: string, goal?: string): string {
+  const trimmedGoal = oneLine(goal ?? "");
+  if (!trimmedGoal) {
+    return markdown;
+  }
+
+  let next = insertGlobalGoalInstructions(markdown, trimmedGoal);
+  const coverageGoal = parseCoverageGoal(trimmedGoal);
+  if (coverageGoal) {
+    next = appendCoverageVerificationToTasks(next, coverageGoalVerifyBullet(coverageGoal));
+  }
+  validateTodoMarkdown(next);
+  return next;
+}
+
+function insertGlobalGoalInstructions(markdown: string, goal: string): string {
+  const coverageGoal = parseCoverageGoal(goal);
+  const additions = [`- Long task goal: ${goal}`];
+  if (coverageGoal) {
+    additions.push(`- Coverage goal: ${coverageGoalAction(coverageGoal)}`);
+    additions.push(`- Coverage verification: ${coverageGoalVerification(coverageGoal)}`);
+  }
+
+  const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+  const progressIndex = lines.findIndex((line) => /^##\s+Progress\s*$/i.test(line.trim()));
+  if (progressIndex < 0) {
+    return markdown;
+  }
+
+  const existingGlobalText = lines.slice(0, progressIndex).join("\n");
+  const missing = additions.filter((line) => !existingGlobalText.includes(line));
+  if (missing.length === 0) {
+    return markdown;
+  }
+
+  const before = trimTrailingBlankLines(lines.slice(0, progressIndex));
+  const after = trimLeadingBlankLines(lines.slice(progressIndex));
+  const hasGlobalHeading = /^Global instructions:\s*$/im.test(existingGlobalText);
+  const block = hasGlobalHeading ? missing : ["Global instructions:", ...missing];
+  return ensureTrailingNewline([...before, "", ...block, "", ...after].join("\n"));
+}
+
+function appendCoverageVerificationToTasks(markdown: string, verificationBullet: string): string {
+  const tasks = parseTasks(markdown);
+  const lines = markdown.replace(/\r\n?/g, "\n").split("\n");
+  for (const task of [...tasks].reverse()) {
+    if (task.section.includes(verificationBullet)) {
+      continue;
+    }
+
+    const startIndex = task.startLine - 1;
+    const endIndex = task.endLine;
+    const verifyIndex = findVerifyLineIndex(lines, startIndex, endIndex);
+    if (verifyIndex >= 0) {
+      lines.splice(verifyIndex + 1, 0, verificationBullet);
+      continue;
+    }
+
+    const doneIndex = findDoneWhenLineIndex(lines, startIndex, endIndex);
+    const insertIndex = doneIndex >= 0 ? doneIndex : endIndex;
+    lines.splice(insertIndex, 0, "**Verify:**", verificationBullet, "");
+  }
+
+  return ensureTrailingNewline(lines.join("\n"));
+}
+
+function findVerifyLineIndex(lines: readonly string[], startIndex: number, endIndex: number): number {
+  for (let idx = startIndex; idx < endIndex; idx += 1) {
+    if (/^\*\*Verify:\*\*/i.test(lines[idx].trim())) {
+      return idx;
+    }
+  }
+  return -1;
+}
+
+function findDoneWhenLineIndex(lines: readonly string[], startIndex: number, endIndex: number): number {
+  for (let idx = startIndex; idx < endIndex; idx += 1) {
+    if (/^\*\*Done when:\*\*/i.test(lines[idx].trim())) {
+      return idx;
+    }
+  }
+  return -1;
+}
+
+function trimTrailingBlankLines(lines: string[]): string[] {
+  while (lines.at(-1)?.trim() === "") {
+    lines.pop();
+  }
+  return lines;
 }
 
-export function buildTodoRepairPrompt(rawInput: string, invalidOutput: string, validationError: string): string {
-  return `Your previous response was not valid Pi Long Task TODO markdown. Correct it now.\n\nValidation/extraction error:\n${validationError.trim() || "Unknown validation error."}\n\nRequirements:\n- Output only corrected markdown, with no commentary and no code fence.\n- Start with exactly: # Pi Long Task TODO\n- Include a ## Progress section with one unchecked line per task: - [ ] TODO N — Title\n- Include a --- separator before task sections.\n- Create sequential sections named ## TODO N — Title.\n- Each task section must include **Goal:**, **Status:** with unchecked checkbox items, **Verify:** with concrete verification guidance, and **Done when:**.\n- Preserve any global instructions or constraints that apply to all tasks above ## Progress.\n- Keep tasks focused and independently assignable to worker sessions.\n\nOriginal raw input:\n\n${rawInput.trim()}\n\nPrevious invalid output:\n\n${invalidOutput.trim()}\n`;
+function trimLeadingBlankLines(lines: string[]): string[] {
+  while (lines[0]?.trim() === "") {
+    lines.shift();
+  }
+  return lines;
+}
+
+function oneLine(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+export function buildTodoCreationPrompt(rawInput: string, goal?: string): string {
+  const goalBlock = todoGoalPromptBlock(goal);
+  return `Convert the following raw project request into Pi Long Task-compatible TODO markdown.\n\nRequirements:\n- Output only markdown, with no commentary and no code fence.\n- Start with exactly: # Pi Long Task TODO\n- Include a ## Progress section with one unchecked line per task: - [ ] TODO N — Title\n- Include a --- separator before task sections.\n- Create sequential sections named ## TODO N — Title.\n- Each task section must include **Goal:**, **Status:** with unchecked checkbox items, **Verify:** with concrete verification guidance, and **Done when:**.\n- Preserve any global instructions or constraints that apply to all tasks above ## Progress.\n- Keep tasks focused and independently assignable to worker sessions.\n${goalBlock}\nRaw input:\n\n${rawInput.trim()}\n`;
+}
+
+export function buildTodoRepairPrompt(
+  rawInput: string,
+  invalidOutput: string,
+  validationError: string,
+  goal?: string,
+): string {
+  const goalBlock = todoGoalPromptBlock(goal);
+  return `Your previous response was not valid Pi Long Task TODO markdown. Correct it now.\n\nValidation/extraction error:\n${validationError.trim() || "Unknown validation error."}\n\nRequirements:\n- Output only corrected markdown, with no commentary and no code fence.\n- Start with exactly: # Pi Long Task TODO\n- Include a ## Progress section with one unchecked line per task: - [ ] TODO N — Title\n- Include a --- separator before task sections.\n- Create sequential sections named ## TODO N — Title.\n- Each task section must include **Goal:**, **Status:** with unchecked checkbox items, **Verify:** with concrete verification guidance, and **Done when:**.\n- Preserve any global instructions or constraints that apply to all tasks above ## Progress.\n- Keep tasks focused and independently assignable to worker sessions.\n${goalBlock}\nOriginal raw input:\n\n${rawInput.trim()}\n\nPrevious invalid output:\n\n${invalidOutput.trim()}\n`;
+}
+
+function todoGoalPromptBlock(goal: string | undefined): string {
+  const trimmed = goal?.trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  const coverageGoal = parseCoverageGoal(trimmed);
+  const coverageBlock = coverageGoal
+    ? `\nCoverage goal requirements:\n- Include global instructions that tell workers to ${coverageGoalAction(coverageGoal)}\n- Include verification guidance that tells workers to ${coverageGoalVerification(coverageGoal)}\n- Do not hardcode a fixed coverage threshold; use the requested threshold (${coverageGoal.thresholdText}%).\n`
+    : "";
+  return `\nOverall goal:\n\n${trimmed}\n${coverageBlock}`;
 }
 
 export function extractAndValidateTodoMarkdown(assistantText: string): string {