@fradser/pi-agent-teams 0.10.0 → 1.0.0

package/src/work-context.ts

@@ -1,88 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { writeFileSync } from "node:fs";
-import {
-  buildSessionContext,
-  SessionManager,
-  type ExtensionContext,
-  type SessionContext,
-  type SessionMessageEntry,
-} from "@earendil-works/pi-coding-agent";
-
-type AgentMessage = SessionContext["messages"][number];
-type ContextReader = Pick<ExtensionContext["sessionManager"], "getBranch" | "getLeafId">;
-type AssistantMessage = Extract<AgentMessage, { role: "assistant" }>;
-type ToolResultMessage = Extract<AgentMessage, { role: "toolResult" }>;
-type ToolCall = Extract<AssistantMessage["content"][number], { type: "toolCall" }>;
-
-function withoutRuntimeState(message: AgentMessage): AgentMessage {
-  if (message.role === "custom") {
-    const { details: _details, ...history } = message;
-    return history;
-  }
-  if (message.role === "toolResult") {
-    const { details: _details, addedToolNames: _tools, ...history } = message;
-    return history;
-  }
-  return message;
-}
-
-function completedExchanges(messages: AgentMessage[]): { calls: Set<ToolCall>; results: Set<ToolResultMessage> } {
-  const pending = new Map<string, ToolCall>();
-  const calls = new Set<ToolCall>();
-  const results = new Set<ToolResultMessage>();
-  for (const message of messages) {
-    if (message.role === "user" || message.role === "assistant") pending.clear();
-    if (message.role === "assistant") {
-      for (const block of message.content) {
-        if (block.type === "toolCall" && !pending.has(block.id)) pending.set(block.id, block);
-      }
-    } else if (message.role === "toolResult") {
-      const call = pending.get(message.toolCallId);
-      if (!call || call.name !== message.toolName) continue;
-      calls.add(call);
-      results.add(message);
-      pending.delete(call.id);
-    }
-  }
-  return { calls, results };
-}
-
-/** Snapshot the active Pi context without moving the parent's branch or replaying pending tools. */
-export function snapshotWorkContext(sessionManager: ContextReader | undefined): AgentMessage[] {
-  if (!sessionManager || typeof sessionManager.getBranch !== "function" || typeof sessionManager.getLeafId !== "function") {
-    throw new Error("Fork context unavailable: leader session manager is unavailable.");
-  }
-  const messages = buildSessionContext(sessionManager.getBranch(), sessionManager.getLeafId()).messages;
-  const completed = completedExchanges(messages);
-  const history: AgentMessage[] = [];
-  for (const message of messages) {
-    if (message.role === "toolResult" && !completed.results.has(message)) continue;
-    if (message.role !== "assistant") {
-      history.push(withoutRuntimeState(message));
-      continue;
-    }
-    const content = message.content.filter((block) => block.type !== "toolCall" || completed.calls.has(block));
-    if (content.length === 0 && message.content.length > 0) continue;
-    const hasTools = content.some((block) => block.type === "toolCall");
-    const stopReason = message.stopReason === "toolUse" && !hasTools ? "stop" : message.stopReason;
-    history.push({ ...message, content, stopReason });
-  }
-  return structuredClone(history);
-}
-
-/** Materialize already-rebuilt context; appendMessage cannot represent Pi summary roles. */
-export function writeWorkContext(cwd: string, directory: string, messages: AgentMessage[]): string {
-  const session = SessionManager.create(cwd, directory);
-  const file = session.getSessionFile()!;
-  let parentId: string | null = null;
-  const entries = messages.map((message): SessionMessageEntry => {
-    const entry: SessionMessageEntry = {
-      type: "message", id: randomUUID(), parentId, timestamp: new Date().toISOString(), message,
-    };
-    parentId = entry.id;
-    return entry;
-  });
-  const content = [session.getHeader(), ...entries].map((entry) => JSON.stringify(entry)).join("\n");
-  writeFileSync(file, `${content}\n`, { mode: 0o600, flag: "wx" });
-  return file;
-}

package/src/worker-tools.ts

@@ -1,4 +0,0 @@
-/** Pi built-ins available to a bare worker; extension aliases are not inherited. */
-export const WORKER_BUILTIN_TOOLS: readonly string[] = [
-  "read", "bash", "edit", "write", "grep", "find", "ls", "powershell",
-];

package/src/worktree.ts

@@ -1,164 +0,0 @@
-/**
- * Teammate worktree isolation — run each spawned worker in a fresh git
- * worktree so parallel workers never collide on the same working tree.
- *
- * Layout: `<repoRoot>/.pi/worktrees/teammate-<taskId>/`, branch
- * `teammate/<taskId>`. On completion the worker's diff is captured against
- * the base commit, then the worktree directory is removed while the branch
- * stays so captured work remains retrievable.
- */
-
-import { execFileSync, spawnSync } from "node:child_process";
-import * as path from "node:path";
-
-export interface WorktreeSetup {
-  repoRoot: string;
-  /** Absolute path of the worktree. */
-  path: string;
-  /** Working directory for the worker (worktree root). */
-  cwd: string;
-  branch: string;
-  baseCommit: string;
-}
-
-export interface WorktreeDiff {
-  /** Full patch of the worker's changes vs the base commit ("" when clean). */
-  patch: string;
-  /** `git diff --stat` summary ("" when clean). */
-  diffStat: string;
-}
-
-export type WorktreeDiffResult = { ok: true; diff: WorktreeDiff } | { ok: false; error: string };
-
-function runGit(cwd: string, args: string[]): { status: number | null; stdout: string; stderr: string } {
-  const result = spawnSync("git", ["-C", cwd, ...args], { encoding: "utf-8" });
-  return {
-    status: result.status,
-    stdout: result.stdout ?? "",
-    stderr: result.stderr ?? "",
-  };
-}
-
-function safeTaskSegment(taskId: string): string {
-  return taskId.replace(/[^\w.-]/g, "_");
-}
-
-/**
- * Create a worktree for a task, branched from the repo's current HEAD.
- * Returns an error string when the cwd is not a git repository or the
- * worktree could not be created.
- */
-export function createWorktree(
-  cwd: string,
-  taskId: string,
-): WorktreeSetup | { error: string } {
-  const toplevel = runGit(cwd, ["rev-parse", "--show-toplevel"]);
-  if (toplevel.status !== 0) {
-    return { error: "worktree isolation requires a git repository" };
-  }
-  const repoRoot = toplevel.stdout.trim();
-  const baseCommit = runGit(repoRoot, ["rev-parse", "HEAD"]);
-  if (baseCommit.status !== 0 || !baseCommit.stdout.trim()) {
-    return { error: "worktree isolation requires at least one commit" };
-  }
-
-  const safeId = safeTaskSegment(taskId);
-  const worktreePath = path.join(repoRoot, ".pi", "worktrees", `teammate-${safeId}`);
-  const branch = `teammate/${safeId}`;
-
-  const add = runGit(repoRoot, ["worktree", "add", worktreePath, "-b", branch, "HEAD"]);
-  if (add.status !== 0) {
-    return { error: `failed to create worktree: ${add.stderr.trim() || add.stdout.trim()}` };
-  }
-
-  return {
-    repoRoot,
-    path: worktreePath,
-    cwd: worktreePath,
-    branch,
-    baseCommit: baseCommit.stdout.trim(),
-  };
-}
-
-/**
- * Capture the worker's changes in the worktree as a patch against the base
- * commit. The worktree is left untouched; call cleanupWorktree afterwards.
- */
-export function captureWorktreeDiff(setup: WorktreeSetup): WorktreeDiffResult {
-  try {
-    execFileSync("git", ["-C", setup.path, "add", "-A"], { stdio: "ignore" });
-    const stat = runGit(setup.path, ["diff", "--cached", "--stat", setup.baseCommit]);
-    const patch = runGit(setup.path, ["diff", "--cached", setup.baseCommit]);
-    if (stat.status !== 0 || patch.status !== 0) {
-      return { ok: false, error: patch.stderr.trim() || stat.stderr.trim() || "git diff failed" };
-    }
-    return {
-      ok: true,
-      diff: {
-        patch: patch.stdout ?? "",
-        diffStat: stat.stdout?.trim() ?? "",
-      },
-    };
-  } catch (error) {
-    return { ok: false, error: error instanceof Error ? error.message : String(error) };
-  }
-}
-
-/**
- * Commit any remaining worktree changes onto the branch. Staging alone dies
- * with the worktree directory; only a commit makes the kept branch carry the
- * captured work. A clean tree succeeds without a commit.
- */
-function commitRemainingWork(setup: WorktreeSetup): { ok: boolean; error?: string } {
-  const add = runGit(setup.path, ["add", "-A"]);
-  if (add.status !== 0) return { ok: false, error: add.stderr.trim() || "git add failed" };
-  const result = spawnSync("git", ["-C", setup.path, "commit", "-m", "agent-teams: capture teammate work"], { encoding: "utf-8" });
-  if (result.status === 0) return { ok: true };
-  const output = `${result.stderr ?? ""}${result.stdout ?? ""}`;
-  if (/nothing to commit/i.test(output)) return { ok: true };
-  return { ok: false, error: output.trim() || "git commit failed" };
-}
-
-/**
- * Remove the worktree directory but keep the branch: remaining changes are
- * committed first so the captured diff stays retrievable with
- * `git diff <baseCommit>..<branch>` after cleanup. Pass `{ deleteBranch: true }`
- * for teardowns where no work was captured (a failed spawn). When the commit
- * fails in keep-branch mode the directory is PRESERVED and returned in the
- * error — removing it would destroy the only copy of the work. Errors are
- * returned rather than thrown so task completion is never blocked by cleanup
- * failure.
- */
-export function cleanupWorktree(
-  setup: WorktreeSetup,
-  options?: { deleteBranch?: boolean },
-): { ok: boolean; error?: string } {
-  const errors: string[] = [];
-  if (!options?.deleteBranch) {
-    const commit = commitRemainingWork(setup);
-    if (!commit.ok) {
-      return {
-        ok: false,
-        error: `commit: ${commit.error}; worktree left in place at ${setup.path} so the work is not lost`,
-      };
-    }
-  }
-  const remove = runGit(setup.repoRoot, ["worktree", "remove", "--force", setup.path]);
-  if (remove.status !== 0) errors.push(`worktree remove: ${remove.stderr.trim()}`);
-  if (options?.deleteBranch) {
-    const branch = runGit(setup.repoRoot, ["branch", "-D", setup.branch]);
-    if (branch.status !== 0) errors.push(`branch delete: ${branch.stderr.trim()}`);
-  }
-  try {
-    runGit(setup.repoRoot, ["worktree", "prune"]);
-  } catch {
-    // Prune is best effort.
-  }
-  return errors.length > 0 ? { ok: false, error: errors.join("; ") } : { ok: true };
-}
-
-/** Best-effort cleanup used when a spawn fails before the worker starts:
- *  nothing was captured, so the empty branch goes too. */
-export function discardWorktree(setup: WorktreeSetup): void {
-  cleanupWorktree(setup, { deleteBranch: true });
-}