pi-long-task 0.1.3 → 0.3.0

package/src/render.ts

@@ -1,6 +1,7 @@
 import type { AgentToolResult, Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
-import { Text } from "@earendil-works/pi-tui";
+import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 
+import type { TaskProgressModel, TaskProgressStatus, TaskProgressTask } from "./task_progress.ts";
 import type { CoordinatorCommitSummary, CoordinatorRemainingTask, CoordinatorStatus } from "./types.ts";
 
 export interface CoordinatorResultForRendering {
@@ -15,6 +16,8 @@ export interface CoordinatorResultForRendering {
   taskResultPath?: string;
   commits?: CoordinatorCommitSummary[];
   remainingTasks?: CoordinatorRemainingTask[];
+  taskProgress?: TaskProgressModel;
+  workerCostTotal?: number;
   error?: string;
 }
 
@@ -22,7 +25,7 @@ export interface CoordinatorToolRenderDetails extends CoordinatorResultForRender
   runId?: string;
 }
 
-type ProgressItemStatus = "empty" | "in_progress" | "done";
+type ProgressItemStatus = "empty" | "in_progress" | "done" | "failed" | "blocked";
 
 interface ProgressTaskRenderDetails {
   taskId: string;
@@ -35,6 +38,72 @@ interface ProgressSubtaskRenderDetails {
   status: ProgressItemStatus;
 }
 
+const SIDEBAR_MIN_SIDE_BY_SIDE_WIDTH = 84;
+const SIDEBAR_MIN_WIDTH = 26;
+const SIDEBAR_MAX_WIDTH = 40;
+const SIDEBAR_GAP = 2;
+
+class LongTaskSidebarShell implements Component {
+  private readonly mainText: string;
+  private readonly taskProgress: TaskProgressModel;
+  private readonly workerCostTotal: number | undefined;
+  private readonly theme: Theme;
+
+  constructor(mainText: string, taskProgress: TaskProgressModel, theme: Theme, workerCostTotal?: number) {
+    this.mainText = mainText;
+    this.taskProgress = taskProgress;
+    this.workerCostTotal = workerCostTotal;
+    this.theme = theme;
+  }
+
+  render(width: number): string[] {
+    if (width < SIDEBAR_MIN_SIDE_BY_SIDE_WIDTH) {
+      return this.renderStacked(width);
+    }
+
+    const sidebarWidth = clamp(Math.floor(width * 0.32), SIDEBAR_MIN_WIDTH, SIDEBAR_MAX_WIDTH);
+    const mainWidth = width - sidebarWidth - SIDEBAR_GAP;
+    if (mainWidth < 40) {
+      return this.renderStacked(width);
+    }
+
+    const mainLines = renderWrappedLines(this.mainText, mainWidth);
+    const sidebarLines = this.renderSidebar(sidebarWidth);
+    const height = Math.max(mainLines.length, sidebarLines.length);
+    const lines: string[] = [];
+    for (let idx = 0; idx < height; idx += 1) {
+      const main = padLine(mainLines[idx] ?? "", mainWidth);
+      const sidebar = sidebarLines[idx] ?? "";
+      lines.push(truncateToWidth(`${main}${" ".repeat(SIDEBAR_GAP)}${sidebar}`, width));
+    }
+    return lines;
+  }
+
+  invalidate(): void {
+    // Rendering is computed from current state on each pass.
+  }
+
+  private renderStacked(width: number): string[] {
+    const mainLines = renderWrappedLines(this.mainText, width);
+    const sidebarLines = this.renderSidebar(width);
+    return [...mainLines, ...sidebarLines].map((line) => truncateToWidth(line, width));
+  }
+
+  private renderSidebar(width: number): string[] {
+    if (width < 8) {
+      return [];
+    }
+
+    const innerWidth = Math.max(0, width - 2);
+    const rows = sidebarRows(this.taskProgress, this.theme, this.workerCostTotal);
+    return [
+      sidebarBorder("Long Task", width, this.theme),
+      ...rows.map((row) => sidebarRow(row, innerWidth, this.theme)),
+      this.theme.fg("borderMuted", `└${"─".repeat(innerWidth)}┘`),
+    ];
+  }
+}
+
 export function formatCoordinatorResultMessage(result: CoordinatorResultForRendering): string {
   const resultPath = result.resultPath ?? result.taskResultPath ?? "unknown";
   const remaining = result.remainingTasks ?? [];
@@ -47,6 +116,10 @@ export function formatCoordinatorResultMessage(result: CoordinatorResultForRende
     `TODO file: ${result.todoPath}`,
   ];
 
+  if (result.workerCostTotal) {
+    lines.push(`Worker spend: ${formatCost(result.workerCostTotal)}`);
+  }
+
   const commitLines = commits
     .filter((commit) => commit.hash || commit.error)
     .map((commit) => {
@@ -84,10 +157,13 @@ export function renderLongTaskToolResult(
   result: AgentToolResult<unknown>,
   options: ToolRenderResultOptions,
   theme: Theme,
-): Text {
+): Component {
   const details = recordOrUndefined(result.details);
   if (options.isPartial) {
-    return new Text(renderLongTaskProgress(details, contentText(result), theme), 0, 0);
+    const taskProgress = taskProgressModel(details?.taskProgress);
+    const workerCostTotal = numberValue(details?.workerCostTotal);
+    const main = renderLongTaskProgress(details, contentText(result), theme);
+    return taskProgress ? new LongTaskSidebarShell(main, taskProgress, theme, workerCostTotal) : new Text(main, 0, 0);
   }
 
   const finalDetails = longTaskDetails(details);
@@ -95,7 +171,10 @@ export function renderLongTaskToolResult(
     return new Text(contentText(result), 0, 0);
   }
 
-  return new Text(renderLongTaskSummary(finalDetails, options.expanded, theme), 0, 0);
+  const main = renderLongTaskSummary(finalDetails, options.expanded, theme);
+  return finalDetails.taskProgress
+    ? new LongTaskSidebarShell(main, finalDetails.taskProgress, theme, finalDetails.workerCostTotal)
+    : new Text(main, 0, 0);
 }
 
 function renderLongTaskProgress(details: Record<string, unknown> | undefined, fallback: string, theme: Theme): string {
@@ -137,6 +216,7 @@ function renderLongTaskSummary(details: CoordinatorToolRenderDetails, expanded:
     details.blockedTasks ? theme.fg("warning", `${details.blockedTasks} blocked`) : undefined,
     remainingCount ? theme.fg("muted", `${remainingCount} remaining`) : undefined,
     commitCount ? theme.fg("success", `${commitCount} commit${commitCount === 1 ? "" : "s"}`) : undefined,
+    details.workerCostTotal ? theme.fg("muted", `worker ${formatCost(details.workerCostTotal)}`) : undefined,
   ].filter(Boolean);
 
   if (!expanded) {
@@ -173,6 +253,174 @@ function renderLongTaskSummary(details: CoordinatorToolRenderDetails, expanded:
   return lines.join("\n");
 }
 
+function renderWrappedLines(text: string, width: number): string[] {
+  return new Text(text, 0, 0).render(Math.max(1, width)).map((line) => truncateToWidth(line, Math.max(1, width)));
+}
+
+function padLine(line: string, width: number): string {
+  return truncateToWidth(line, width, "…", true);
+}
+
+function sidebarRows(taskProgress: TaskProgressModel, theme: Theme, workerCostTotal?: number): string[] {
+  const summary = normalizedTaskProgressSummary(taskProgress);
+  const rows = [theme.fg("toolTitle", theme.bold("Task sidebar")), theme.fg("dim", "Centered timeline")];
+  if (workerCostTotal) {
+    rows.push(theme.fg("muted", `Worker spend: ${formatCost(workerCostTotal)}`));
+  }
+  if (summary.totalTasks === 0) {
+    rows.push("", theme.fg("muted", "Waiting for TODO plan..."));
+    return rows;
+  }
+
+  rows.push("", progressBarLine(summary.completedTasks, summary.totalTasks, summary.completedPercent, theme));
+  rows.push(progressCountsLine(summary, theme));
+
+  const currentIndex = focusedTaskIndex(taskProgress);
+  if (currentIndex >= 0) {
+    rows.push(theme.fg("warning", `Focus: TODO ${taskProgress.tasks[currentIndex]?.taskId ?? "?"}`));
+  } else {
+    rows.push(theme.fg("success", "No active task"));
+  }
+
+  rows.push("", theme.fg("muted", "Timeline"));
+  for (const [index, task] of taskProgress.tasks.entries()) {
+    if (currentIndex >= 0 && index === currentIndex && index > 0) {
+      rows.push(theme.fg("dim", "──── current ────"));
+    }
+    rows.push(renderSidebarTaskRow(task, theme));
+    if (currentIndex >= 0 && index === currentIndex && index < taskProgress.tasks.length - 1) {
+      rows.push(theme.fg("dim", "──── future ─────"));
+    }
+  }
+
+  return rows;
+}
+
+interface NormalizedTaskProgressSummary {
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  blockedTasks: number;
+  pendingTasks: number;
+  currentTasks: number;
+  completedPercent: number;
+}
+
+function normalizedTaskProgressSummary(taskProgress: TaskProgressModel): NormalizedTaskProgressSummary {
+  const totalTasks = taskProgress.summary?.totalTasks ?? taskProgress.tasks.length;
+  const completedTasks = taskProgress.summary?.completedTasks ?? countTasksByStatus(taskProgress.tasks, "completed");
+  const failedTasks = taskProgress.summary?.failedTasks ?? countTasksByStatus(taskProgress.tasks, "failed");
+  const blockedTasks = taskProgress.summary?.blockedTasks ?? countTasksByStatus(taskProgress.tasks, "blocked");
+  const pendingTasks = taskProgress.summary?.pendingTasks ?? countTasksByStatus(taskProgress.tasks, "pending");
+  const currentTasks = taskProgress.summary?.currentTasks ?? countTasksByStatus(taskProgress.tasks, "current");
+  const completedPercent =
+    taskProgress.summary?.completedPercent ??
+    (totalTasks === 0 ? 100 : Math.round((completedTasks / totalTasks) * 100));
+
+  return {
+    totalTasks,
+    completedTasks,
+    failedTasks,
+    blockedTasks,
+    pendingTasks,
+    currentTasks,
+    completedPercent,
+  };
+}
+
+function countTasksByStatus(tasks: readonly TaskProgressTask[], status: TaskProgressStatus): number {
+  return tasks.filter((task) => task.status === status).length;
+}
+
+function progressBarLine(completedTasks: number, totalTasks: number, percent: number, theme: Theme): string {
+  const width = 10;
+  const filled = clamp(totalTasks === 0 ? width : Math.round((completedTasks / totalTasks) * width), 0, width);
+  const empty = Math.max(0, width - filled);
+  return `${theme.fg("muted", "Progress")} [${theme.fg("success", "#".repeat(filled))}${theme.fg(
+    "dim",
+    "-".repeat(empty),
+  )}] ${completedTasks}/${totalTasks} ${percent}%`;
+}
+
+function progressCountsLine(summary: NormalizedTaskProgressSummary, theme: Theme): string {
+  const parts = [
+    theme.fg("success", `✓ ${summary.completedTasks}`),
+    summary.currentTasks ? theme.fg("warning", `▶ ${summary.currentTasks}`) : undefined,
+    summary.pendingTasks ? theme.fg("dim", `○ ${summary.pendingTasks}`) : undefined,
+    summary.failedTasks ? theme.fg("error", `✗ ${summary.failedTasks}`) : undefined,
+    summary.blockedTasks ? theme.fg("warning", `! ${summary.blockedTasks}`) : undefined,
+  ].filter(Boolean);
+  return parts.join(" · ");
+}
+
+function focusedTaskIndex(taskProgress: TaskProgressModel): number {
+  if (typeof taskProgress.currentIndex === "number" && taskProgress.currentIndex >= 0) {
+    return taskProgress.currentIndex;
+  }
+
+  const currentIndex = taskProgress.tasks.findIndex((task) => task.status === "current" || task.position === "current");
+  if (currentIndex >= 0) {
+    return currentIndex;
+  }
+
+  if (typeof taskProgress.nextIndex === "number" && taskProgress.nextIndex >= 0) {
+    return taskProgress.nextIndex;
+  }
+  return taskProgress.tasks.findIndex((task) => task.status === "pending");
+}
+
+function renderSidebarTaskRow(task: TaskProgressTask, theme: Theme): string {
+  const { icon, color, label } = sidebarTaskStatusDetails(task.status);
+  const attempts =
+    task.attempts > 0 && task.status !== "completed"
+      ? ` · ${task.attempts} attempt${task.attempts === 1 ? "" : "s"}`
+      : "";
+  const text = `${icon} [${label}] TODO ${task.taskId} — ${task.title}${attempts}`;
+  return task.status === "current" ? theme.fg(color, theme.bold(text)) : theme.fg(color, text);
+}
+
+function sidebarTaskStatusDetails(status: TaskProgressStatus): {
+  icon: string;
+  color: "success" | "warning" | "error" | "dim" | "muted";
+  label: string;
+} {
+  switch (status) {
+    case "completed":
+      return { icon: "✓", color: "success", label: "completed" };
+    case "current":
+      return { icon: "▶", color: "warning", label: "current" };
+    case "failed":
+      return { icon: "✗", color: "error", label: "failed" };
+    case "blocked":
+      return { icon: "!", color: "warning", label: "blocked" };
+    case "pending":
+      return { icon: "○", color: "dim", label: "pending" };
+  }
+}
+
+function sidebarBorder(title: string, width: number, theme: Theme): string {
+  const innerWidth = Math.max(0, width - 2);
+  const titleText = truncateToWidth(` ${title} `, innerWidth, "");
+  const remaining = Math.max(0, innerWidth - visibleWidth(titleText));
+  return theme.fg("borderMuted", `┌${titleText}${"─".repeat(remaining)}┐`);
+}
+
+function sidebarRow(row: string, innerWidth: number, theme: Theme): string {
+  return `${theme.fg("borderMuted", "│")}${truncateToWidth(row, innerWidth, "…", true)}${theme.fg("borderMuted", "│")}`;
+}
+
+function taskProgressModel(value: unknown): TaskProgressModel | undefined {
+  const record = recordOrUndefined(value);
+  if (!record || !Array.isArray(record.tasks)) {
+    return undefined;
+  }
+  return value as TaskProgressModel;
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value));
+}
+
 function progressTaskDetails(value: unknown): ProgressTaskRenderDetails | undefined {
   const record = recordOrUndefined(value);
   const taskId = stringValue(record?.taskId);
@@ -200,18 +448,32 @@ function progressSubtaskDetails(value: unknown): ProgressSubtaskRenderDetails[]
 }
 
 function progressItemStatus(value: unknown): ProgressItemStatus | undefined {
-  return value === "empty" || value === "in_progress" || value === "done" ? value : undefined;
+  return value === "empty" || value === "in_progress" || value === "done" || value === "failed" || value === "blocked"
+    ? value
+    : undefined;
 }
 
 function progressBubble(status: ProgressItemStatus, theme: Theme): string {
-  return status === "empty" ? theme.fg("dim", "○") : theme.fg(progressTextColor(status), "●");
+  switch (status) {
+    case "empty":
+      return theme.fg("dim", "○");
+    case "failed":
+      return theme.fg("error", "✗");
+    case "blocked":
+      return theme.fg("warning", "!");
+    default:
+      return theme.fg(progressTextColor(status), "●");
+  }
 }
 
-function progressTextColor(status: ProgressItemStatus): "success" | "warning" | "dim" {
+function progressTextColor(status: ProgressItemStatus): "success" | "warning" | "dim" | "error" {
   if (status === "done") {
     return "success";
   }
-  if (status === "in_progress") {
+  if (status === "failed") {
+    return "error";
+  }
+  if (status === "in_progress" || status === "blocked") {
     return "warning";
   }
   return "dim";
@@ -252,6 +514,8 @@ function longTaskDetails(details: Record<string, unknown> | undefined): Coordina
     runId: stringValue(details.runId),
     commits: commitSummaries(details.commits),
     remainingTasks: remainingTaskSummaries(details.remainingTasks),
+    taskProgress: taskProgressModel(details.taskProgress),
+    workerCostTotal: nonNegativeNumberValue(details.workerCostTotal),
     error: stringValue(details.error),
   };
 }
@@ -341,6 +605,20 @@ function numberValue(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) ? value : undefined;
 }
 
+function nonNegativeNumberValue(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+
+function formatCost(value: number): string {
+  if (value === 0) {
+    return "$0";
+  }
+  if (value < 0.01) {
+    return `$${value.toFixed(4)}`;
+  }
+  return `$${value.toFixed(2)}`;
+}
+
 function recordOrUndefined(value: unknown): Record<string, unknown> | undefined {
   return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
 }

package/src/task_progress.ts

@@ -0,0 +1,187 @@
+import type { Task, TaskStatusItem } from "./todo_parser.ts";
+
+export const TASK_PROGRESS_STATUS_VALUES = ["pending", "current", "completed", "failed", "blocked"] as const;
+export type TaskProgressStatus = (typeof TASK_PROGRESS_STATUS_VALUES)[number];
+
+export const TASK_PROGRESS_POSITION_VALUES = ["past", "current", "future"] as const;
+export type TaskProgressPosition = (typeof TASK_PROGRESS_POSITION_VALUES)[number];
+
+export interface TaskProgressAttempt {
+  taskId: string;
+  attempt?: number;
+  reportedStatus?: string;
+  done?: boolean;
+}
+
+export type TaskProgressTaskStatusItem = TaskStatusItem;
+
+export interface TaskProgressTask {
+  taskId: string;
+  title: string;
+  status: TaskProgressStatus;
+  position: TaskProgressPosition;
+  done: boolean;
+  statusItems: TaskProgressTaskStatusItem[];
+  attempts: number;
+  lastReportedStatus?: string;
+}
+
+export interface TaskProgressSummary {
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  blockedTasks: number;
+  pendingTasks: number;
+  currentTasks: number;
+  attemptedTasks: number;
+  completionRatio: number;
+  completedPercent: number;
+}
+
+export interface TaskProgressModel {
+  tasks: TaskProgressTask[];
+  summary: TaskProgressSummary;
+  currentTaskId?: string;
+  currentIndex?: number;
+  currentTask?: TaskProgressTask;
+  nextTaskId?: string;
+  nextIndex?: number;
+  nextTask?: TaskProgressTask;
+}
+
+export interface BuildTaskProgressModelOptions {
+  tasks: readonly Task[];
+  attempts?: readonly TaskProgressAttempt[];
+  currentTaskId?: string;
+  currentTaskStatus?: TaskProgressStatus;
+}
+
+export function buildTaskProgressModel(options: BuildTaskProgressModelOptions): TaskProgressModel {
+  const attempts = options.attempts ?? [];
+  const attemptStats = attemptsByTask(attempts);
+  const activeIndex = activeTaskIndex(options.tasks, options.currentTaskId);
+
+  const progressTasks = options.tasks.map((task, index) => {
+    const stats = attemptStats.get(task.taskId);
+    const isActive = index === activeIndex;
+    const status = taskProgressStatus(task, stats?.lastAttempt, isActive, options.currentTaskStatus);
+
+    const progressTask: TaskProgressTask = {
+      taskId: task.taskId,
+      title: task.title,
+      status,
+      position: taskProgressPosition(index, activeIndex, status),
+      done: status === "completed",
+      statusItems: task.statusItems.map((item) => ({ ...item })),
+      attempts: stats?.attempts ?? 0,
+    };
+    if (stats?.lastAttempt.reportedStatus) {
+      progressTask.lastReportedStatus = stats.lastAttempt.reportedStatus;
+    }
+    return progressTask;
+  });
+
+  const currentIndex = progressTasks.findIndex((task) => task.position === "current");
+  const nextIndex = progressTasks.findIndex((task) => task.status === "pending");
+  const summary = taskProgressSummary(progressTasks, attempts.length);
+
+  const model: TaskProgressModel = {
+    tasks: progressTasks,
+    summary,
+  };
+  if (currentIndex >= 0) {
+    model.currentIndex = currentIndex;
+    model.currentTask = progressTasks[currentIndex];
+    model.currentTaskId = progressTasks[currentIndex].taskId;
+  }
+  if (nextIndex >= 0) {
+    model.nextIndex = nextIndex;
+    model.nextTask = progressTasks[nextIndex];
+    model.nextTaskId = progressTasks[nextIndex].taskId;
+  }
+  return model;
+}
+
+interface TaskAttemptStats {
+  attempts: number;
+  lastAttempt: TaskProgressAttempt;
+}
+
+function attemptsByTask(attempts: readonly TaskProgressAttempt[]): Map<string, TaskAttemptStats> {
+  const stats = new Map<string, TaskAttemptStats>();
+  for (const attempt of attempts) {
+    const existing = stats.get(attempt.taskId);
+    stats.set(attempt.taskId, {
+      attempts: (existing?.attempts ?? 0) + 1,
+      lastAttempt: attempt,
+    });
+  }
+  return stats;
+}
+
+function activeTaskIndex(tasks: readonly Task[], currentTaskId: string | undefined): number {
+  if (!currentTaskId) {
+    return -1;
+  }
+  return tasks.findIndex((task) => task.taskId === currentTaskId);
+}
+
+function taskProgressStatus(
+  task: Task,
+  lastAttempt: TaskProgressAttempt | undefined,
+  isActive: boolean,
+  currentTaskStatus: TaskProgressStatus | undefined,
+): TaskProgressStatus {
+  if (task.done || lastAttempt?.done || (isActive && currentTaskStatus === "completed")) {
+    return "completed";
+  }
+  if (isActive) {
+    if (currentTaskStatus === "failed" || currentTaskStatus === "blocked") {
+      return currentTaskStatus;
+    }
+    return "current";
+  }
+  if (lastAttempt?.reportedStatus === "blocked") {
+    return "blocked";
+  }
+  if (lastAttempt) {
+    return "failed";
+  }
+  return "pending";
+}
+
+function taskProgressPosition(index: number, activeIndex: number, status: TaskProgressStatus): TaskProgressPosition {
+  if (activeIndex >= 0) {
+    if (index < activeIndex) {
+      return "past";
+    }
+    if (index === activeIndex) {
+      return "current";
+    }
+    return "future";
+  }
+
+  return status === "pending" || status === "current" ? "future" : "past";
+}
+
+function taskProgressSummary(tasks: readonly TaskProgressTask[], attemptedTasks: number): TaskProgressSummary {
+  const totalTasks = tasks.length;
+  const completedTasks = tasks.filter((task) => task.status === "completed").length;
+  const failedTasks = tasks.filter((task) => task.status === "failed").length;
+  const blockedTasks = tasks.filter((task) => task.status === "blocked").length;
+  const pendingTasks = tasks.filter((task) => task.status === "pending").length;
+  const currentTasks = tasks.filter((task) => task.status === "current").length;
+  const completionRatio = totalTasks === 0 ? 1 : completedTasks / totalTasks;
+
+  return {
+    totalTasks,
+    completedTasks,
+    failedTasks,
+    blockedTasks,
+    pendingTasks,
+    currentTasks,
+    attemptedTasks,
+    completionRatio,
+    completedPercent: Math.round(completionRatio * 100),
+  };
+}

package/src/types.ts

@@ -1,6 +1,7 @@
 import type { Static } from "typebox";
 import { Type } from "typebox";
 
+import type { TaskProgressModel } from "./task_progress.ts";
 import type { SessionOutcome } from "./worker_session.ts";
 
 export const PiLongTaskParams = Type.Object(
@@ -60,6 +61,8 @@ export interface PiLongTaskResult {
     commitError?: string;
     commitSkipped?: string;
   }>;
+  taskProgress: TaskProgressModel;
+  workerCostTotal: number;
   commit: boolean;
   error?: string;
 }