pi-long-task 0.1.0 → 0.1.2

package/README.md

@@ -24,7 +24,7 @@ A finished run gives you:
 
 ## Install
 
-After this package is published to npm, install it with:
+Install it from npm with:
 
 ```bash
 pi install npm:pi-long-task

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Pi extension for breaking down and running long coding tasks safely.",
   "keywords": [

package/src/coordinator.ts

@@ -49,6 +49,19 @@ export type CoordinatorProgressPhase =
   | "task_failed"
   | "complete";
 
+export type CoordinatorProgressItemStatus = "empty" | "in_progress" | "done";
+
+export interface CoordinatorProgressTask {
+  taskId: string;
+  title: string;
+  status: CoordinatorProgressItemStatus;
+}
+
+export interface CoordinatorProgressSubtask {
+  text: string;
+  status: CoordinatorProgressItemStatus;
+}
+
 export interface CoordinatorProgressUpdate {
   message: string;
   phase: CoordinatorProgressPhase;
@@ -66,6 +79,8 @@ export interface CoordinatorProgressUpdate {
   workerEventType?: string;
   isError?: boolean;
   totalTasks?: number;
+  currentTask?: CoordinatorProgressTask;
+  subtasks?: CoordinatorProgressSubtask[];
 }
 
 export type CoordinatorProgressHandler = (update: CoordinatorProgressUpdate) => void;
@@ -189,6 +204,7 @@ export async function runCoordinator(options: RunCoordinatorOptions): Promise<Co
           taskId: nextTask.taskId,
           title: nextTask.title,
           attempt,
+          ...currentTaskProgress(nextTask, "in_progress"),
         },
       );
       const preExistingDirtyPaths = options.commit
@@ -441,9 +457,40 @@ function emitProgress(
   });
 }
 
+function currentTaskProgress(
+  task: Pick<Task, "taskId" | "title" | "statusItems">,
+  status: CoordinatorProgressItemStatus,
+): Pick<CoordinatorProgressUpdate, "currentTask" | "subtasks"> {
+  return {
+    currentTask: {
+      taskId: task.taskId,
+      title: task.title,
+      status,
+    },
+    subtasks: subtaskProgress(task, status),
+  };
+}
+
+function subtaskProgress(
+  task: Pick<Task, "statusItems">,
+  taskStatus: CoordinatorProgressItemStatus,
+): CoordinatorProgressSubtask[] {
+  let markedInProgress = false;
+  return task.statusItems.map((item) => {
+    if (item.done || taskStatus === "done") {
+      return { text: item.text, status: "done" };
+    }
+    if (taskStatus === "in_progress" && !markedInProgress) {
+      markedInProgress = true;
+      return { text: item.text, status: "in_progress" };
+    }
+    return { text: item.text, status: "empty" };
+  });
+}
+
 function emitWorkerEventProgress(
   runtime: RuntimeOptions,
-  task: Pick<Task, "taskId" | "title">,
+  task: Pick<Task, "taskId" | "title" | "statusItems">,
   attempt: number,
   event: { type: string; toolName?: string; isError?: boolean },
 ): void {
@@ -460,6 +507,7 @@ function emitWorkerEventProgress(
     toolName: event.toolName,
     workerEventType: event.type,
     isError: event.isError,
+    ...currentTaskProgress(task, "in_progress"),
   };
   if (event.isError) {
     update.status = "failed";
@@ -469,7 +517,7 @@ function emitWorkerEventProgress(
 
 function emitTaskOutcomeProgress(
   runtime: RuntimeOptions,
-  task: Pick<Task, "taskId" | "title">,
+  task: Pick<Task, "taskId" | "title" | "statusItems">,
   outcome: SessionOutcome,
   commitHash: string | undefined,
   commitError: string | undefined,
@@ -494,6 +542,7 @@ function emitTaskOutcomeProgress(
     title: task.title,
     attempt: outcome.attempt,
     status: outcome.reportedStatus,
+    ...currentTaskProgress(task, outcome.done ? "done" : "in_progress"),
   };
   if (commitHash) {
     update.commitHash = commitHash;

package/src/git.ts

@@ -3,10 +3,16 @@ import { realpathSync } from "node:fs";
 import { promisify } from "node:util";
 import path from "node:path";
 
-import { taskLabel, type SessionOutcome } from "./worker_session.ts";
+import type { SessionOutcome } from "./worker_session.ts";
 
 const execFileAsync = promisify(execFile);
 
+const GENERATED_TODO_COMMIT_PREFIX_RE = /^(?:Complete|Progress)\s+TODO\s+\d+(?:\s+[—-]\s*)?/i;
+const TODO_LABEL_PREFIX_RE = /^TODO\s+\d+(?:\s+[—-]\s*)?/i;
+const CONVENTIONAL_SUBJECT_RE = /^([a-z][a-z0-9-]*)(\([^)]*\))?(!)?:\s+(.+)$/;
+const DEFAULT_COMMIT_SUBJECT = "Update project files";
+const RECENT_COMMIT_SUBJECT_LIMIT = 20;
+
 export interface GitRunResult {
   stdout: string;
   stderr: string;
@@ -104,8 +110,7 @@ export async function commitAfterSession(options: CommitAfterSessionOptions): Pr
     return { error: "not inside a git repository" };
   }
 
-  const messagePrefix = options.outcome.done ? "Complete" : "Progress";
-  const commitMessage = `${messagePrefix} ${taskLabel(options.outcome.task)}`;
+  const commitMessage = await commitMessageForOutcome(root, options.outcome);
 
   try {
     const add = await runGit(root, ["add", "-A"]);
@@ -154,6 +159,95 @@ export async function commitAfterSession(options: CommitAfterSessionOptions): Pr
   }
 }
 
+async function commitMessageForOutcome(
+  root: string,
+  outcome: Pick<SessionOutcome, "task" | "reportedStatus" | "done" | "error" | "timedOut" | "aborted">,
+): Promise<string> {
+  const subject = normalizedTaskSubject(outcome.task.title);
+  const recentSubjects = await recentCommitSubjects(root);
+  return formatSubjectLikeRecentCommits(subject, recentSubjects);
+}
+
+async function recentCommitSubjects(root: string): Promise<string[]> {
+  const result = await runGit(root, ["log", `-${RECENT_COMMIT_SUBJECT_LIMIT}`, "--format=%s"]);
+  if (result.code !== 0) {
+    return [];
+  }
+
+  return result.stdout
+    .split(/\r?\n/g)
+    .map((subject) => subject.trim())
+    .filter(Boolean)
+    .filter((subject) => !GENERATED_TODO_COMMIT_PREFIX_RE.test(subject))
+    .filter((subject) => !/^Merge\b/.test(subject) && !/^Revert\b/.test(subject));
+}
+
+function formatSubjectLikeRecentCommits(subject: string, recentSubjects: readonly string[]): string {
+  const sample = recentSubjects[0];
+  if (!sample) {
+    return ensureSafeCommitSubject(subject);
+  }
+
+  const conventional = CONVENTIONAL_SUBJECT_RE.exec(sample);
+  if (conventional) {
+    const prefix = `${conventional[1]}${conventional[2] ?? ""}${conventional[3] ?? ""}: `;
+    return ensureSafeCommitSubject(`${prefix}${formatSubjectBody(subject, conventional[4])}`);
+  }
+
+  return ensureSafeCommitSubject(formatSubjectBody(subject, sample));
+}
+
+function formatSubjectBody(subject: string, sampleBody: string): string {
+  let formatted = normalizedTaskSubject(subject);
+  const sampleFirstLetter = sampleBody.match(/[A-Za-z]/)?.[0];
+  if (sampleFirstLetter && sampleFirstLetter === sampleFirstLetter.toLowerCase()) {
+    formatted = lowercaseFirstLetter(formatted);
+  } else if (sampleFirstLetter && sampleFirstLetter === sampleFirstLetter.toUpperCase()) {
+    formatted = uppercaseFirstLetter(formatted);
+  }
+
+  formatted = formatted.replace(/[.!?]+$/g, "");
+  if (/\.$/.test(sampleBody.trim())) {
+    formatted = `${formatted}.`;
+  }
+  return formatted;
+}
+
+function normalizedTaskSubject(title: string): string {
+  const normalized = stripGeneratedTodoPrefix(title)
+    .replace(/\s+/g, " ")
+    .replace(/[.!?]+$/g, "")
+    .trim();
+  return normalized || DEFAULT_COMMIT_SUBJECT;
+}
+
+function ensureSafeCommitSubject(subject: string): string {
+  const normalized = stripGeneratedTodoPrefix(subject).replace(/\s+/g, " ").trim();
+  return normalized || DEFAULT_COMMIT_SUBJECT;
+}
+
+function stripGeneratedTodoPrefix(subject: string): string {
+  let cleaned = subject.trim();
+  let previous = "";
+  while (cleaned && cleaned !== previous) {
+    previous = cleaned;
+    cleaned = cleaned
+      .replace(GENERATED_TODO_COMMIT_PREFIX_RE, "")
+      .replace(TODO_LABEL_PREFIX_RE, "")
+      .replace(/^[:\s—-]+/g, "")
+      .trim();
+  }
+  return cleaned;
+}
+
+function lowercaseFirstLetter(value: string): string {
+  return value.replace(/[A-Za-z]/, (letter) => letter.toLowerCase());
+}
+
+function uppercaseFirstLetter(value: string): string {
+  return value.replace(/[A-Za-z]/, (letter) => letter.toUpperCase());
+}
+
 async function stagedArtifactPaths(root: string, runDir?: string): Promise<Set<string>> {
   const artifacts = new Set<string>();
   const runDirRel = runDir ? relToRoot(runDir, root) : "";

package/src/render.ts

@@ -22,6 +22,19 @@ export interface CoordinatorToolRenderDetails extends CoordinatorResultForRender
   runId?: string;
 }
 
+type ProgressItemStatus = "empty" | "in_progress" | "done";
+
+interface ProgressTaskRenderDetails {
+  taskId: string;
+  title: string;
+  status: ProgressItemStatus;
+}
+
+interface ProgressSubtaskRenderDetails {
+  text: string;
+  status: ProgressItemStatus;
+}
+
 export function formatCoordinatorResultMessage(result: CoordinatorResultForRendering): string {
   const resultPath = result.resultPath ?? result.taskResultPath ?? "unknown";
   const remaining = result.remainingTasks ?? [];
@@ -90,7 +103,26 @@ function renderLongTaskProgress(details: Record<string, unknown> | undefined, fa
   const phase = stringValue(details?.phase);
   const toolName = stringValue(details?.toolName);
   const prefix = phase === "worker_tool" && toolName ? `worker ${toolName}` : phase || "progress";
-  return `${theme.fg("accent", "●")} ${theme.fg("muted", prefix)} ${message}`;
+  const currentTask = progressTaskDetails(details?.currentTask);
+  if (!currentTask) {
+    return `${theme.fg("accent", "●")} ${theme.fg("muted", prefix)} ${message}`;
+  }
+
+  const taskLabel = `TODO ${currentTask.taskId} — ${currentTask.title}`;
+  const lines = [
+    `${progressBubble(currentTask.status, theme)} ${theme.fg("muted", prefix)} ${theme.fg(progressTextColor(currentTask.status), taskLabel)}`,
+  ];
+  if (message && !message.includes(taskLabel)) {
+    lines.push(`  ${theme.fg("dim", message)}`);
+  }
+
+  for (const subtask of progressSubtaskDetails(details?.subtasks)) {
+    lines.push(
+      `  ${progressBubble(subtask.status, theme)} ${theme.fg(progressTextColor(subtask.status), subtask.text)}`,
+    );
+  }
+
+  return lines.join("\n");
 }
 
 function renderLongTaskSummary(details: CoordinatorToolRenderDetails, expanded: boolean, theme: Theme): string {
@@ -141,6 +173,50 @@ function renderLongTaskSummary(details: CoordinatorToolRenderDetails, expanded:
   return lines.join("\n");
 }
 
+function progressTaskDetails(value: unknown): ProgressTaskRenderDetails | undefined {
+  const record = recordOrUndefined(value);
+  const taskId = stringValue(record?.taskId);
+  const title = stringValue(record?.title);
+  const status = progressItemStatus(record?.status);
+  if (!taskId || !title || !status) {
+    return undefined;
+  }
+  return { taskId, title, status };
+}
+
+function progressSubtaskDetails(value: unknown): ProgressSubtaskRenderDetails[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const record = recordOrUndefined(item);
+    const text = stringValue(record?.text);
+    const status = progressItemStatus(record?.status);
+    if (!text || !status) {
+      return [];
+    }
+    return [{ text, status }];
+  });
+}
+
+function progressItemStatus(value: unknown): ProgressItemStatus | undefined {
+  return value === "empty" || value === "in_progress" || value === "done" ? value : undefined;
+}
+
+function progressBubble(status: ProgressItemStatus, theme: Theme): string {
+  return status === "empty" ? theme.fg("dim", "○") : theme.fg(progressTextColor(status), "●");
+}
+
+function progressTextColor(status: ProgressItemStatus): "success" | "warning" | "dim" {
+  if (status === "done") {
+    return "success";
+  }
+  if (status === "in_progress") {
+    return "warning";
+  }
+  return "dim";
+}
+
 function longTaskDetails(details: Record<string, unknown> | undefined): CoordinatorToolRenderDetails | undefined {
   if (!details) {
     return undefined;

package/src/todo_parser.ts

@@ -1,3 +1,8 @@
+export interface TaskStatusItem {
+  text: string;
+  done: boolean;
+}
+
 export interface Task {
   taskId: string;
   title: string;
@@ -7,6 +12,7 @@ export interface Task {
   done: boolean;
   progressDone?: boolean;
   statusCheckboxes: boolean[];
+  statusItems: TaskStatusItem[];
 }
 
 export class TodoParseError extends Error {
@@ -78,10 +84,10 @@ function findProgressDone(lines: string[], taskId: string): boolean | undefined
   return undefined;
 }
 
-function findStatusCheckboxes(lines: string[], startIdx: number, endIdx: number): boolean[] {
+function findStatusItems(lines: string[], startIdx: number, endIdx: number): TaskStatusItem[] {
   let inStatus = false;
   let seenCheckbox = false;
-  const checkboxes: boolean[] = [];
+  const items: TaskStatusItem[] = [];
 
   for (let idx = startIdx; idx < endIdx; idx += 1) {
     const stripped = lines[idx].trim();
@@ -97,7 +103,10 @@ function findStatusCheckboxes(lines: string[], startIdx: number, endIdx: number)
     const checkbox = CHECKBOX_RE.exec(stripLineBreaks(lines[idx]));
     if (checkbox) {
       seenCheckbox = true;
-      checkboxes.push(checkbox[2].toLowerCase() === "x");
+      items.push({
+        text: checkbox[3].replace(/^\]\s*/, "").trim(),
+        done: checkbox[2].toLowerCase() === "x",
+      });
       continue;
     }
 
@@ -110,7 +119,7 @@ function findStatusCheckboxes(lines: string[], startIdx: number, endIdx: number)
     }
   }
 
-  return checkboxes;
+  return items;
 }
 
 function markStatusBlockDone(lines: string[], startIdx: number, endIdx: number): void {
@@ -161,7 +170,8 @@ export function parseTasks(markdown: string): Task[] {
     const endIdx = pos + 1 < headings.length ? headings[pos + 1].startIdx : lines.length;
     const section = `${lines.slice(heading.startIdx, endIdx).join("").trimEnd()}\n`;
     const progressDone = findProgressDone(lines, heading.taskId);
-    const statusCheckboxes = findStatusCheckboxes(lines, heading.startIdx, endIdx);
+    const statusItems = findStatusItems(lines, heading.startIdx, endIdx);
+    const statusCheckboxes = statusItems.map((item) => item.done);
     const done = progressDone ?? (statusCheckboxes.length > 0 ? statusCheckboxes.every(Boolean) : false);
 
     const task: Task = {
@@ -172,6 +182,7 @@ export function parseTasks(markdown: string): Task[] {
       endLine: endIdx,
       done,
       statusCheckboxes,
+      statusItems,
     };
     if (progressDone !== undefined) {
       task.progressDone = progressDone;