pi-long-task 0.1.1 → 0.1.3

package/README.md

@@ -46,6 +46,18 @@ After installing, start `pi` in your target project and ask it to use the `pi_lo
 
 ## Usage
 
+Use natural language:
+
+```text
+Run a long task without commits to add tests for the parser and fix any failures.
+```
+
+```text
+Run a long task with commits to implement the TODOs in @TODO.md.
+```
+
+You can also call the tool explicitly.
+
 Run without commits:
 
 ```text
@@ -78,6 +90,8 @@ The tool has two inputs:
 - `inputText` is the request or TODO markdown to work on.
 - `commit` controls whether Pi Long Task may create git commits.
 
+For natural-language requests, Pi Long Task routes phrases like "run a long task with commits" to the tool with commits enabled. If you ask for a long task without mentioning commits, commits stay disabled.
+
 No other public options are required.
 
 ## Commits and files

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-long-task",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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/index.ts

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 import { runCoordinator, type CoordinatorProgressUpdate, type CoordinatorResult } from "./coordinator.ts";
+import { longTaskInputTransform } from "./input_router.ts";
 import { renderLongTaskToolCall, renderLongTaskToolResult } from "./render.ts";
 import { PiLongTaskParams } from "./types.ts";
 
@@ -22,10 +23,24 @@ function toolDetails(result: CoordinatorResult) {
 }
 
 export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
+  pi.on("input", (event) => {
+    if (event.source === "extension") {
+      return { action: "continue" as const };
+    }
+
+    const transformed = longTaskInputTransform(event.text);
+    if (!transformed) {
+      return { action: "continue" as const };
+    }
+
+    return { action: "transform" as const, text: transformed };
+  });
+
   pi.registerTool({
     name: "pi_long_task",
     label: "Pi Long Task",
-    description: "Break down and run long coding tasks from a request or TODO plan.",
+    description:
+      "Run long or multi-step coding tasks from a request or TODO plan. Use this when the user asks to run/start/handle a long task; set commit true only when they ask for commits or committing as work progresses.",
     parameters: PiLongTaskParams,
     renderCall: renderLongTaskToolCall,
     renderResult: renderLongTaskToolResult,

package/src/input_router.ts

@@ -0,0 +1,57 @@
+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;
+const WANT_LONG_TASK_RE =
+  /\b(?:please|can\s+you|could\s+you|i\s+want|i\s+need|i'd\s+like|i\s+would\s+like|let's|lets)\b[\s\S]*\b(?:long[-\s]?task|longtask|large[-\s]?task|big[-\s]?task|multi[-\s]?step(?:\s+task)?)\b/i;
+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 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;
+
+export function longTaskInputTransform(text: string): string | undefined {
+  if (!isNaturalLanguageLongTaskRequest(text)) {
+    return undefined;
+  }
+
+  const commit = inferCommitSetting(text) ?? false;
+  return buildLongTaskToolPrompt(text, commit);
+}
+
+export function isNaturalLanguageLongTaskRequest(text: string): boolean {
+  const trimmed = text.trim();
+  if (!trimmed || trimmed.startsWith("/") || EXPLICIT_TOOL_RE.test(trimmed)) {
+    return false;
+  }
+  if (!LONG_TASK_RE.test(trimmed) || INFORMATION_QUESTION_RE.test(trimmed) || NEGATED_LONG_TASK_RE.test(trimmed)) {
+    return false;
+  }
+  return 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;
+  }
+  if (COMMIT_TRUE_RE.test(text)) {
+    return true;
+  }
+  return undefined;
+}
+
+function buildLongTaskToolPrompt(originalText: string, commit: boolean): string {
+  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.",
+    "",
+    "Original request:",
+    "```text",
+    originalText.trim(),
+    "```",
+  ].join("\n");
+}

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;

package/src/types.ts

@@ -5,8 +5,13 @@ import type { SessionOutcome } from "./worker_session.ts";
 
 export const PiLongTaskParams = Type.Object(
   {
-    inputText: Type.String({ description: "TODO file content or long-task instructions to process." }),
-    commit: Type.Boolean({ description: "Whether Pi Long Task may commit completed worker changes." }),
+    inputText: Type.String({
+      description: "TODO file content or the user's long-task instructions to process.",
+    }),
+    commit: Type.Boolean({
+      description:
+        "Whether Pi Long Task may commit completed worker changes. Use true when the user asks for commits or committing as work progresses; otherwise use false.",
+    }),
   },
   { additionalProperties: false },
 );