pi-long-task 0.1.0

package/src/git.ts

@@ -0,0 +1,262 @@
+import { execFile } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { promisify } from "node:util";
+import path from "node:path";
+
+import { taskLabel, type SessionOutcome } from "./worker_session.ts";
+
+const execFileAsync = promisify(execFile);
+
+export interface GitRunResult {
+  stdout: string;
+  stderr: string;
+  code: number;
+}
+
+export interface CommitAfterSessionOptions {
+  cwd: string;
+  resultPath: string;
+  todoPath?: string;
+  runDir?: string;
+  outcome: Pick<SessionOutcome, "task" | "reportedStatus" | "done" | "error" | "timedOut" | "aborted">;
+  preExistingDirtyPaths?: ReadonlySet<string> | readonly string[];
+}
+
+export interface CommitAfterSessionResult {
+  hash?: string;
+  error?: string;
+  skipped?: string;
+}
+
+export async function gitRoot(cwd: string): Promise<string | undefined> {
+  const result = await runGit(cwd, ["rev-parse", "--show-toplevel"]);
+  if (result.code !== 0) {
+    return undefined;
+  }
+  const root = result.stdout.trim();
+  return root ? path.resolve(root) : undefined;
+}
+
+export async function gitDirtyPaths(cwd: string, ...excludePaths: string[]): Promise<Set<string>> {
+  const root = await gitRoot(cwd);
+  if (!root) {
+    return new Set();
+  }
+
+  const excluded = excludePaths.map((item) => relToRoot(item, root)).filter(Boolean);
+  const result = await runGit(root, ["status", "--porcelain", "-z", "--untracked-files=all"]);
+  if (result.code !== 0) {
+    return new Set();
+  }
+
+  const dirty = new Set<string>();
+  const entries = result.stdout.split("\0");
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index];
+    if (!entry) {
+      continue;
+    }
+
+    const status = entry.slice(0, 2);
+    const firstPath = entry.slice(3);
+    const isRenameOrCopy = status.includes("R") || status.includes("C");
+    if (firstPath && !isExcluded(firstPath, excluded)) {
+      dirty.add(firstPath);
+    }
+    if (isRenameOrCopy && index + 1 < entries.length) {
+      const secondPath = entries[index + 1];
+      index += 1;
+      if (secondPath && !isExcluded(secondPath, excluded)) {
+        dirty.add(secondPath);
+      }
+    }
+  }
+  return dirty;
+}
+
+export async function unstagePaths(root: string, paths: Iterable<string>): Promise<void> {
+  const pathList = [...new Set([...paths].filter(Boolean))].sort();
+  if (pathList.length === 0) {
+    return;
+  }
+
+  await runGit(root, ["restore", "--staged", "--", ...pathList]);
+  await runGit(root, ["reset", "--", ...pathList]);
+}
+
+export function shouldCommitOutcome(
+  outcome: Pick<SessionOutcome, "reportedStatus" | "error" | "timedOut" | "aborted">,
+): boolean {
+  if (outcome.error || outcome.timedOut || outcome.aborted) {
+    return false;
+  }
+  const status = outcome.reportedStatus.toLowerCase();
+  return ["done", "complete", "completed", "success", "succeeded", "partial", "blocked"].includes(status);
+}
+
+export async function commitAfterSession(options: CommitAfterSessionOptions): Promise<CommitAfterSessionResult> {
+  if (!shouldCommitOutcome(options.outcome)) {
+    return { skipped: "outcome is not eligible for commit" };
+  }
+
+  const root = await gitRoot(options.cwd);
+  if (!root) {
+    return { error: "not inside a git repository" };
+  }
+
+  const messagePrefix = options.outcome.done ? "Complete" : "Progress";
+  const commitMessage = `${messagePrefix} ${taskLabel(options.outcome.task)}`;
+
+  try {
+    const add = await runGit(root, ["add", "-A"]);
+    if (add.code !== 0) {
+      return { error: gitError(add) };
+    }
+
+    const excludedPaths = new Set<string>();
+    addPathIfPresent(excludedPaths, relToRoot(options.resultPath, root));
+    if (options.todoPath) {
+      addPathIfPresent(excludedPaths, relToRoot(options.todoPath, root));
+    }
+    if (options.runDir) {
+      addPathIfPresent(excludedPaths, relToRoot(options.runDir, root));
+    }
+    for (const item of options.preExistingDirtyPaths ?? []) {
+      addPathIfPresent(excludedPaths, item);
+    }
+
+    for (const item of await stagedArtifactPaths(root, options.runDir)) {
+      excludedPaths.add(item);
+    }
+
+    await unstagePaths(root, excludedPaths);
+
+    const diff = await runGit(root, ["diff", "--cached", "--quiet", "--exit-code"]);
+    if (diff.code === 0) {
+      return { skipped: "no staged diff" };
+    }
+    if (diff.code !== 1) {
+      return { error: gitError(diff) };
+    }
+
+    const commit = await runGit(root, ["commit", "-m", commitMessage]);
+    if (commit.code !== 0) {
+      return { error: gitError(commit) };
+    }
+
+    const rev = await runGit(root, ["rev-parse", "--short", "HEAD"]);
+    if (rev.code !== 0) {
+      return { error: gitError(rev) };
+    }
+    return { hash: rev.stdout.trim() };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+async function stagedArtifactPaths(root: string, runDir?: string): Promise<Set<string>> {
+  const artifacts = new Set<string>();
+  const runDirRel = runDir ? relToRoot(runDir, root) : "";
+  const result = await runGit(root, ["diff", "--cached", "--name-only", "-z"]);
+  if (result.code !== 0) {
+    return artifacts;
+  }
+
+  for (const item of result.stdout.split("\0")) {
+    if (!item) {
+      continue;
+    }
+    if (path.posix.basename(item) === "TASK_RESULT.md") {
+      artifacts.add(item);
+      continue;
+    }
+    if (runDirRel && isPathAtOrUnder(item, runDirRel)) {
+      artifacts.add(item);
+    }
+  }
+  return artifacts;
+}
+
+function relToRoot(pathname: string, root: string): string {
+  const absolute = resolveExistingPath(pathname);
+  const resolvedRoot = resolveExistingPath(root);
+  const relative = path.relative(resolvedRoot, absolute);
+  if (!relative || relative === ".") {
+    return "";
+  }
+  if (relative.startsWith("..") || path.isAbsolute(relative)) {
+    return absolute;
+  }
+  return toGitPath(relative);
+}
+
+function resolveExistingPath(pathname: string): string {
+  const absolute = path.resolve(pathname);
+  try {
+    return realpathSync.native(absolute);
+  } catch {
+    return absolute;
+  }
+}
+
+function addPathIfPresent(paths: Set<string>, pathname: string): void {
+  if (pathname) {
+    paths.add(pathname);
+  }
+}
+
+function isExcluded(pathname: string, excluded: readonly string[]): boolean {
+  return excluded.some((item) => isPathAtOrUnder(pathname, item));
+}
+
+function isPathAtOrUnder(pathname: string, parent: string): boolean {
+  const normalizedPath = trimTrailingSlash(toGitPath(pathname));
+  const normalizedParent = trimTrailingSlash(toGitPath(parent));
+  return normalizedPath === normalizedParent || normalizedPath.startsWith(`${normalizedParent}/`);
+}
+
+function trimTrailingSlash(value: string): string {
+  return value.replace(/\/+$/g, "");
+}
+
+function toGitPath(value: string): string {
+  return value.split(path.sep).join("/");
+}
+
+function gitError(result: GitRunResult): string {
+  return (result.stderr || result.stdout || `git exited with status ${result.code}`).trim();
+}
+
+async function runGit(cwd: string, args: readonly string[]): Promise<GitRunResult> {
+  try {
+    const result = await execFileAsync("git", [...args], {
+      cwd,
+      encoding: "utf8",
+      maxBuffer: 10 * 1024 * 1024,
+    });
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      code: 0,
+    };
+  } catch (error) {
+    if (isExecError(error)) {
+      return {
+        stdout: typeof error.stdout === "string" ? error.stdout : "",
+        stderr: typeof error.stderr === "string" ? error.stderr : "",
+        code: typeof error.code === "number" ? error.code : 1,
+      };
+    }
+    throw error;
+  }
+}
+
+function isExecError(error: unknown): error is { stdout?: unknown; stderr?: unknown; code?: unknown } {
+  return typeof error === "object" && error !== null;
+}
+
+export const git_root = gitRoot;
+export const git_dirty_paths = gitDirtyPaths;
+export const unstage_paths = unstagePaths;
+export const should_commit_outcome = shouldCommitOutcome;
+export const commit_after_session = commitAfterSession;

package/src/index.ts

@@ -0,0 +1,63 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { runCoordinator, type CoordinatorProgressUpdate, type CoordinatorResult } from "./coordinator.ts";
+import { renderLongTaskToolCall, renderLongTaskToolResult } from "./render.ts";
+import { PiLongTaskParams } from "./types.ts";
+
+function toolDetails(result: CoordinatorResult) {
+  return {
+    runId: result.runId,
+    todoPath: result.todoPath,
+    resultPath: result.resultPath,
+    outcomes: result.outcomes,
+    commits: result.commits,
+    status: result.status,
+    totalTasks: result.totalTasks,
+    completedTasks: result.completedTasks,
+    failedTasks: result.failedTasks,
+    blockedTasks: result.blockedTasks,
+    remainingTasks: result.remainingTasks,
+    summary: result.summary,
+  };
+}
+
+export default function registerPiLongTaskExtension(pi: ExtensionAPI) {
+  pi.registerTool({
+    name: "pi_long_task",
+    label: "Pi Long Task",
+    description: "Break down and run long coding tasks from a request or TODO plan.",
+    parameters: PiLongTaskParams,
+    renderCall: renderLongTaskToolCall,
+    renderResult: renderLongTaskToolResult,
+    async execute(_toolCallId, params, signal, onUpdate, ctx) {
+      const publishProgress = (update: CoordinatorProgressUpdate) => {
+        onUpdate?.({
+          content: [
+            {
+              type: "text" as const,
+              text: update.message,
+            },
+          ],
+          details: update,
+        });
+      };
+
+      const result = await runCoordinator({
+        ...params,
+        cwd: ctx?.cwd,
+        abortSignal: signal,
+        onProgress: publishProgress,
+      });
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: result.message,
+          },
+        ],
+        details: toolDetails(result),
+      };
+    },
+  });
+}

package/src/render.ts

@@ -0,0 +1,270 @@
+import type { AgentToolResult, Theme, ToolRenderResultOptions } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+
+import type { CoordinatorCommitSummary, CoordinatorRemainingTask, CoordinatorStatus } from "./types.ts";
+
+export interface CoordinatorResultForRendering {
+  status: CoordinatorStatus;
+  summary: string;
+  totalTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  blockedTasks: number;
+  todoPath: string;
+  resultPath?: string;
+  taskResultPath?: string;
+  commits?: CoordinatorCommitSummary[];
+  remainingTasks?: CoordinatorRemainingTask[];
+  error?: string;
+}
+
+export interface CoordinatorToolRenderDetails extends CoordinatorResultForRendering {
+  runId?: string;
+}
+
+export function formatCoordinatorResultMessage(result: CoordinatorResultForRendering): string {
+  const resultPath = result.resultPath ?? result.taskResultPath ?? "unknown";
+  const remaining = result.remainingTasks ?? [];
+  const commits = result.commits ?? [];
+  const remainingCount = Math.max(0, result.totalTasks - result.completedTasks);
+  const lines = [
+    `Pi Long Task: ${result.status}`,
+    `Tasks: ${result.completedTasks} completed, ${result.failedTasks} failed, ${result.blockedTasks} blocked, ${remainingCount} remaining (${result.totalTasks} total).`,
+    `Result file: ${resultPath}`,
+    `TODO file: ${result.todoPath}`,
+  ];
+
+  const commitLines = commits
+    .filter((commit) => commit.hash || commit.error)
+    .map((commit) => {
+      if (commit.hash) {
+        return `- TODO ${commit.taskId}: ${commit.hash}`;
+      }
+      return `- TODO ${commit.taskId}: commit error: ${commit.error ?? "unknown"}`;
+    });
+  if (commitLines.length > 0) {
+    lines.push("Commits:", ...commitLines);
+  }
+
+  if (remaining.length > 0) {
+    lines.push(
+      "Remaining tasks:",
+      ...remaining.map((task) => `- TODO ${task.taskId} — ${task.title} (${task.status})`),
+    );
+  }
+
+  if (result.error) {
+    lines.push(`Error: ${result.error}`);
+  }
+
+  return lines.join("\n");
+}
+
+export function renderLongTaskToolCall(args: { inputText?: string; commit?: boolean }, theme: Theme): Text {
+  const commit = args.commit ? theme.fg("warning", "commit:on") : theme.fg("dim", "commit:off");
+  const input = oneLine(args.inputText ?? "");
+  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);
+}
+
+export function renderLongTaskToolResult(
+  result: AgentToolResult<unknown>,
+  options: ToolRenderResultOptions,
+  theme: Theme,
+): Text {
+  const details = recordOrUndefined(result.details);
+  if (options.isPartial) {
+    return new Text(renderLongTaskProgress(details, contentText(result), theme), 0, 0);
+  }
+
+  const finalDetails = longTaskDetails(details);
+  if (!finalDetails) {
+    return new Text(contentText(result), 0, 0);
+  }
+
+  return new Text(renderLongTaskSummary(finalDetails, options.expanded, theme), 0, 0);
+}
+
+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);
+  const toolName = stringValue(details?.toolName);
+  const prefix = phase === "worker_tool" && toolName ? `worker ${toolName}` : phase || "progress";
+  return `${theme.fg("accent", "●")} ${theme.fg("muted", prefix)} ${message}`;
+}
+
+function renderLongTaskSummary(details: CoordinatorToolRenderDetails, expanded: boolean, theme: Theme): string {
+  const remainingCount = Math.max(0, details.totalTasks - details.completedTasks);
+  const statusStyle = statusColor(details.status);
+  const icon = details.status === "done" ? "✓" : details.status === "failed" ? "✗" : "!";
+  const commitCount = (details.commits ?? []).filter((commit) => commit.hash).length;
+  const summary = [
+    `${theme.fg(statusStyle, icon)} ${theme.fg("toolTitle", theme.bold("Pi Long Task"))} ${theme.fg(statusStyle, details.status)}`,
+    theme.fg("muted", `${details.completedTasks}/${details.totalTasks} tasks`),
+    details.failedTasks ? theme.fg("error", `${details.failedTasks} failed`) : undefined,
+    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,
+  ].filter(Boolean);
+
+  if (!expanded) {
+    return summary.join(" — ");
+  }
+
+  const lines = [summary.join(" — "), theme.fg("muted", details.summary)];
+  lines.push(theme.fg("dim", `Result: ${details.resultPath ?? details.taskResultPath ?? "unknown"}`));
+  lines.push(theme.fg("dim", `TODO: ${details.todoPath}`));
+
+  const commits = details.commits ?? [];
+  if (commits.length > 0) {
+    lines.push(theme.fg("muted", "Commits:"));
+    for (const commit of commits) {
+      const text = commit.hash
+        ? `- TODO ${commit.taskId}: ${commit.hash}`
+        : `- TODO ${commit.taskId}: commit error: ${commit.error ?? "unknown"}`;
+      lines.push(theme.fg(commit.hash ? "success" : "error", text));
+    }
+  }
+
+  const remaining = details.remainingTasks ?? [];
+  if (remaining.length > 0) {
+    lines.push(theme.fg("muted", "Remaining:"));
+    for (const task of remaining) {
+      lines.push(theme.fg("dim", `- TODO ${task.taskId} — ${task.title} (${task.status})`));
+    }
+  }
+
+  if (details.error) {
+    lines.push(theme.fg("error", `Error: ${details.error}`));
+  }
+
+  return lines.join("\n");
+}
+
+function longTaskDetails(details: Record<string, unknown> | undefined): CoordinatorToolRenderDetails | undefined {
+  if (!details) {
+    return undefined;
+  }
+
+  const status = stringValue(details.status);
+  const totalTasks = numberValue(details.totalTasks);
+  const completedTasks = numberValue(details.completedTasks);
+  const failedTasks = numberValue(details.failedTasks);
+  const blockedTasks = numberValue(details.blockedTasks);
+  const todoPath = stringValue(details.todoPath);
+  const summary = stringValue(details.summary);
+  if (
+    !isCoordinatorStatus(status) ||
+    totalTasks === undefined ||
+    completedTasks === undefined ||
+    !todoPath ||
+    !summary
+  ) {
+    return undefined;
+  }
+
+  return {
+    status,
+    summary,
+    totalTasks,
+    completedTasks,
+    failedTasks: failedTasks ?? 0,
+    blockedTasks: blockedTasks ?? 0,
+    todoPath,
+    resultPath: stringValue(details.resultPath),
+    taskResultPath: stringValue(details.taskResultPath),
+    runId: stringValue(details.runId),
+    commits: commitSummaries(details.commits),
+    remainingTasks: remainingTaskSummaries(details.remainingTasks),
+    error: stringValue(details.error),
+  };
+}
+
+function commitSummaries(value: unknown): CoordinatorCommitSummary[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const record = recordOrUndefined(item);
+    const taskId = stringValue(record?.taskId);
+    if (!taskId) {
+      return [];
+    }
+    return [
+      {
+        taskId,
+        hash: stringValue(record?.hash),
+        error: stringValue(record?.error),
+      },
+    ];
+  });
+}
+
+function remainingTaskSummaries(value: unknown): CoordinatorRemainingTask[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.flatMap((item) => {
+    const record = recordOrUndefined(item);
+    const taskId = stringValue(record?.taskId);
+    const title = stringValue(record?.title);
+    const status = stringValue(record?.status);
+    if (!taskId || !title || !status) {
+      return [];
+    }
+    return [{ taskId, title, status }];
+  });
+}
+
+function statusColor(status: CoordinatorStatus): "success" | "warning" | "error" {
+  if (status === "done") {
+    return "success";
+  }
+  if (status === "failed") {
+    return "error";
+  }
+  return "warning";
+}
+
+function isCoordinatorStatus(value: string): value is CoordinatorStatus {
+  return value === "done" || value === "partial" || value === "blocked" || value === "failed";
+}
+
+function contentText(result: AgentToolResult<unknown>): string {
+  const content = Array.isArray(result.content) ? result.content : [];
+  return content
+    .map((item) => {
+      const record = recordOrUndefined(item);
+      return record?.type === "text" ? stringValue(record.text) : "";
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function firstLine(value: string): string {
+  return value.split(/\r?\n/, 1)[0]?.trim() ?? "";
+}
+
+function quote(value: string): string {
+  return `"${value.replaceAll('"', '\\"')}"`;
+}
+
+function oneLine(value: string): string {
+  return value.replace(/\s+/g, " ").trim();
+}
+
+function truncatePlain(value: string, maxLength: number): string {
+  return value.length <= maxLength ? value : `${value.slice(0, Math.max(0, maxLength - 1))}…`;
+}
+
+function stringValue(value: unknown): string {
+  return typeof value === "string" ? value : "";
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
+function recordOrUndefined(value: unknown): Record<string, unknown> | undefined {
+  return typeof value === "object" && value !== null ? (value as Record<string, unknown>) : undefined;
+}

package/src/result_writer.ts

@@ -0,0 +1,96 @@
+export const DONE_STATUSES = new Set(["done", "complete", "completed", "success", "succeeded"]);
+export const PARTIAL_STATUSES = new Set(["partial", "incomplete", "blocked", "failed", "failure", "unknown"]);
+
+const TASK_RESULT_MARKER_RE = /TASK_RESULT\s*:/gi;
+const STATUS_LINE_RE = /^\s*status\s*:\s*([A-Za-z_-]+)\s*$/im;
+const FENCED_BLOCK_RE = /```[^\r\n`]*\r?\n([\s\S]*?)\r?\n```/g;
+
+export interface TaskResultBlock {
+  marker: "TASK_RESULT";
+  body: string;
+  fenced: boolean;
+}
+
+export function isDoneStatus(status: string): boolean {
+  return DONE_STATUSES.has(status.trim().toLowerCase());
+}
+
+export function isPartialStatus(status: string): boolean {
+  return PARTIAL_STATUSES.has(status.trim().toLowerCase());
+}
+
+export function hasTaskResult(assistantText: string): boolean {
+  return /TASK_RESULT\s*:/i.test(assistantText || "");
+}
+
+export function hasTaskResultStatus(assistantText: string): boolean {
+  const block = extractTaskResultBlock(assistantText);
+  return Boolean(block && STATUS_LINE_RE.test(block.body));
+}
+
+export function parseReportedStatus(assistantText: string): string {
+  const block = extractTaskResultBlock(assistantText);
+  const searchText = block ? block.body : assistantText || "";
+  const match = STATUS_LINE_RE.exec(searchText);
+  if (!match) {
+    return "unknown";
+  }
+
+  return match[1].trim().toLowerCase();
+}
+
+export function extractResultSummary(assistantText: string, limit = 8000): string {
+  let text = (assistantText || "").trim();
+  const block = extractTaskResultBlock(text);
+  if (block) {
+    text = `TASK_RESULT:\n${block.body.trim()}`;
+  }
+
+  if (text.length > limit) {
+    return `${text.slice(0, limit)}\n\n[truncated by Pi Long Task]\n`;
+  }
+  return text;
+}
+
+export const summarizeAssistantResult = extractResultSummary;
+
+export function extractTaskResultBlock(assistantText: string): TaskResultBlock | undefined {
+  const text = assistantText || "";
+  const fencedBlocks = fencedCodeBlocks(text);
+  for (let idx = fencedBlocks.length - 1; idx >= 0; idx -= 1) {
+    const body = taskResultBodyFromText(fencedBlocks[idx]);
+    if (body !== undefined) {
+      return { marker: "TASK_RESULT", body, fenced: true };
+    }
+  }
+
+  const body = taskResultBodyFromText(text);
+  if (body === undefined) {
+    return undefined;
+  }
+  return { marker: "TASK_RESULT", body: stripTrailingFence(body), fenced: false };
+}
+
+function taskResultBodyFromText(text: string): string | undefined {
+  TASK_RESULT_MARKER_RE.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  let lastMatch: RegExpExecArray | undefined;
+  while ((match = TASK_RESULT_MARKER_RE.exec(text)) !== null) {
+    lastMatch = match;
+  }
+
+  if (!lastMatch) {
+    return undefined;
+  }
+
+  return text.slice(lastMatch.index + lastMatch[0].length).trim();
+}
+
+function fencedCodeBlocks(text: string): string[] {
+  FENCED_BLOCK_RE.lastIndex = 0;
+  return [...text.matchAll(FENCED_BLOCK_RE)].map((match) => match[1]);
+}
+
+function stripTrailingFence(text: string): string {
+  return text.replace(/\r?\n```\s*$/g, "").trim();
+}