@ilya-lesikov/pi-pi 0.5.0 → 0.7.0

package/extensions/orchestrator/repo-utils.test.ts

@@ -0,0 +1,151 @@
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  findRootRepo,
+  getBaseBranchForRepo,
+  groupFilesByRepo,
+  isPathInRepo,
+  normalizeRepoPath,
+  resolveRepoForFile,
+  type RepoInfo,
+} from "./repo-utils.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-repo-utils-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("isPathInRepo", () => {
+  it("rejects boundary prefix paths", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    const siblingPath = join(base, "repo-sibling", "src", "file.ts");
+    mkdirSync(join(repoPath, "src"), { recursive: true });
+    mkdirSync(join(base, "repo-sibling", "src"), { recursive: true });
+    writeFileSync(join(repoPath, "src", "index.ts"), "export {};\n", "utf-8");
+    writeFileSync(siblingPath, "export {};\n", "utf-8");
+
+    expect(isPathInRepo(siblingPath, repoPath)).toBe(false);
+  });
+});
+
+describe("resolveRepoForFile", () => {
+  it("resolves files under symlinked path to canonical repo", () => {
+    const base = makeTempDir();
+    const realRepo = join(base, "real-repo");
+    const linkRepo = join(base, "linked-repo");
+    mkdirSync(join(realRepo, "src"), { recursive: true });
+    writeFileSync(join(realRepo, "src", "app.ts"), "export const app = true;\n", "utf-8");
+    symlinkSync(realRepo, linkRepo, "dir");
+
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(realRepo), isRoot: false }];
+    const fileViaLink = join(linkRepo, "src", "app.ts");
+
+    expect(resolveRepoForFile(repos, fileViaLink)?.path).toBe(normalizeRepoPath(realRepo));
+  });
+
+  it("picks longest matching repo path", () => {
+    const base = makeTempDir();
+    const parentRepo = join(base, "repo");
+    const nestedRepo = join(parentRepo, "nested");
+    const nestedFile = join(nestedRepo, "src", "main.ts");
+    mkdirSync(join(parentRepo, "src"), { recursive: true });
+    mkdirSync(join(nestedRepo, "src"), { recursive: true });
+    writeFileSync(join(parentRepo, "src", "root.ts"), "export const root = true;\n", "utf-8");
+    writeFileSync(nestedFile, "export const nested = true;\n", "utf-8");
+
+    const repos: RepoInfo[] = [
+      { path: normalizeRepoPath(parentRepo), isRoot: true },
+      { path: normalizeRepoPath(nestedRepo), isRoot: false },
+    ];
+
+    expect(resolveRepoForFile(repos, nestedFile)?.path).toBe(normalizeRepoPath(nestedRepo));
+  });
+});
+
+describe("groupFilesByRepo", () => {
+  it("groups files by matching repository paths", () => {
+    const base = makeTempDir();
+    const rootRepo = join(base, "root");
+    const extraRepo = join(base, "extra");
+    mkdirSync(join(rootRepo, "src"), { recursive: true });
+    mkdirSync(join(extraRepo, "lib"), { recursive: true });
+    const rootFile = join(rootRepo, "src", "a.ts");
+    const extraFile = join(extraRepo, "lib", "b.ts");
+    writeFileSync(rootFile, "export const a = 1;\n", "utf-8");
+    writeFileSync(extraFile, "export const b = 2;\n", "utf-8");
+
+    const repos: RepoInfo[] = [
+      { path: normalizeRepoPath(rootRepo), isRoot: true },
+      { path: normalizeRepoPath(extraRepo), isRoot: false },
+    ];
+
+    const grouped = groupFilesByRepo(repos, [rootFile, extraFile]);
+
+    expect(grouped.get(normalizeRepoPath(rootRepo))).toEqual([rootFile]);
+    expect(grouped.get(normalizeRepoPath(extraRepo))).toEqual([extraFile]);
+  });
+
+  it("puts unmatched files under empty-key bucket", () => {
+    const base = makeTempDir();
+    const repo = join(base, "repo");
+    const outside = join(base, "outside.ts");
+    mkdirSync(join(repo, "src"), { recursive: true });
+    writeFileSync(join(repo, "src", "a.ts"), "export const a = 1;\n", "utf-8");
+    writeFileSync(outside, "export const outside = 1;\n", "utf-8");
+
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repo), isRoot: true }];
+
+    const grouped = groupFilesByRepo(repos, [outside]);
+
+    expect(grouped.get("")).toEqual([outside]);
+  });
+});
+
+describe("findRootRepo", () => {
+  it("finds root repository entry", () => {
+    const repos: RepoInfo[] = [
+      { path: "/tmp/a", isRoot: false },
+      { path: "/tmp/b", isRoot: true },
+    ];
+
+    expect(findRootRepo(repos)).toEqual({ path: "/tmp/b", isRoot: true });
+  });
+
+  it("returns undefined when no root repo exists", () => {
+    const repos: RepoInfo[] = [{ path: "/tmp/a", isRoot: false }];
+
+    expect(findRootRepo(repos)).toBeUndefined();
+  });
+});
+
+describe("getBaseBranchForRepo", () => {
+  it("returns base branch for matching repository path", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    mkdirSync(repoPath, { recursive: true });
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repoPath), isRoot: true, baseBranch: "origin/main" }];
+
+    expect(getBaseBranchForRepo(repos, repoPath)).toBe("origin/main");
+  });
+
+  it("returns undefined for unknown repository path", () => {
+    const base = makeTempDir();
+    const repoPath = join(base, "repo");
+    mkdirSync(repoPath, { recursive: true });
+    const repos: RepoInfo[] = [{ path: normalizeRepoPath(repoPath), isRoot: true, baseBranch: "origin/main" }];
+
+    expect(getBaseBranchForRepo(repos, join(base, "missing"))).toBeUndefined();
+  });
+});

package/extensions/orchestrator/repo-utils.ts

@@ -0,0 +1,67 @@
+import { realpathSync, existsSync } from "fs";
+import { resolve, sep } from "path";
+
+export interface RepoInfo {
+  path: string;
+  baseBranch?: string;
+  isRoot: boolean;
+}
+
+export function normalizeRepoPath(p: string): string {
+  const abs = resolve(p);
+  try {
+    return existsSync(abs) ? realpathSync(abs) : abs;
+  } catch {
+    return abs;
+  }
+}
+
+export function isPathInRepo(filePath: string, repoPath: string): boolean {
+  let normFile = resolve(filePath);
+  try {
+    if (existsSync(normFile)) {
+      normFile = realpathSync(normFile);
+    }
+  } catch {}
+  const normalizedRepoPath = normalizeRepoPath(repoPath);
+  const normRepo = normalizedRepoPath.endsWith(sep) ? normalizedRepoPath : normalizedRepoPath + sep;
+  return normFile === normalizedRepoPath || normFile.startsWith(normRepo);
+}
+
+export function resolveRepoForFile(repos: RepoInfo[], filePath: string): RepoInfo | null {
+  const normFile = resolve(filePath);
+  let best: RepoInfo | null = null;
+  let bestLen = 0;
+  for (const repo of repos) {
+    if (isPathInRepo(normFile, repo.path) && repo.path.length > bestLen) {
+      best = repo;
+      bestLen = repo.path.length;
+    }
+  }
+  return best;
+}
+
+export function groupFilesByRepo(repos: RepoInfo[], files: string[]): Map<string, string[]> {
+  const groups = new Map<string, string[]>();
+  for (const file of files) {
+    const repo = resolveRepoForFile(repos, file);
+    const key = repo?.path ?? "";
+    const list = groups.get(key);
+    if (list) list.push(file);
+    else groups.set(key, [file]);
+  }
+  return groups;
+}
+
+export function getBaseBranchForRepo(repos: RepoInfo[], repoPath: string): string | undefined {
+  const norm = normalizeRepoPath(repoPath);
+  return repos.find((r) => r.path === norm)?.baseBranch;
+}
+
+export function getAllRepos(repos: RepoInfo[]): RepoInfo[] {
+  return repos;
+}
+
+export function findRootRepo(repos: RepoInfo[]): RepoInfo | undefined {
+  return repos.find((r) => r.isRoot);
+}

package/extensions/orchestrator/spawn-cleanup.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, vi } from "vitest";
+import { handleSpawnResult } from "./spawn-cleanup.js";
+import type { Orchestrator } from "./orchestrator.js";
+
+function makeOrchestrator(): Orchestrator {
+  return {
+    pendingSubagentSpawns: 3,
+    failedPlannerVariants: [],
+    failedReviewerVariants: [],
+  } as unknown as Orchestrator;
+}
+
+describe("handleSpawnResult", () => {
+  it("resets pending and records failed planner variants on success", async () => {
+    const orch = makeOrchestrator();
+    const onSettled = vi.fn();
+    handleSpawnResult(orch, Promise.resolve({ spawned: 2, agentIds: ["a"], failedVariants: ["bad"] }), {
+      kind: "planner",
+      logScope: "planner",
+      logMessage: "x",
+      onSettled,
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.pendingSubagentSpawns).toBe(0);
+    expect(orch.failedPlannerVariants).toEqual(["bad"]);
+    expect(onSettled).toHaveBeenCalledOnce();
+  });
+
+  it("resets pending and still runs onSettled on rejection (fail-safe)", async () => {
+    const orch = makeOrchestrator();
+    const onSettled = vi.fn();
+    handleSpawnResult(orch, Promise.reject(new Error("boom")), {
+      kind: "reviewer",
+      logScope: "review",
+      logMessage: "x",
+      onSettled,
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.pendingSubagentSpawns).toBe(0);
+    expect(onSettled).toHaveBeenCalledOnce();
+  });
+
+  it("targets failedReviewerVariants for the reviewer kind", async () => {
+    const orch = makeOrchestrator();
+    handleSpawnResult(orch, Promise.resolve({ spawned: 0, agentIds: [], failedVariants: ["r"] }), {
+      kind: "reviewer",
+      logScope: "review",
+      logMessage: "x",
+    });
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(orch.failedReviewerVariants).toEqual(["r"]);
+    expect(orch.pendingSubagentSpawns).toBe(0);
+  });
+});

package/extensions/orchestrator/spawn-cleanup.ts

@@ -0,0 +1,35 @@
+import type { Orchestrator } from "./orchestrator.js";
+import { getLogger } from "./log.js";
+
+type SpawnResult = { spawned: number; agentIds?: string[]; failedVariants: string[] };
+
+type SpawnCleanupOptions = {
+  kind: "planner" | "reviewer";
+  logScope: string;
+  logMessage: string;
+  logExtra?: Record<string, unknown>;
+  onSettled?: (result?: SpawnResult) => void;
+};
+
+// Centralizes the cleanup that runs after a planner/reviewer spawn promise
+// settles. The spawn functions block until every spawned agent completes, so
+// resetting pendingSubagentSpawns to 0 is the fail-safe for the spawned===0
+// case and the .catch path where no subagents:completed event fires.
+export function handleSpawnResult(
+  orchestrator: Orchestrator,
+  promise: Promise<SpawnResult>,
+  opts: SpawnCleanupOptions,
+): void {
+  const field = opts.kind === "planner" ? "failedPlannerVariants" : "failedReviewerVariants";
+  promise
+    .then((result) => {
+      orchestrator[field] = result.failedVariants;
+      orchestrator.pendingSubagentSpawns = 0;
+      opts.onSettled?.(result);
+    })
+    .catch((err: any) => {
+      orchestrator.pendingSubagentSpawns = 0;
+      opts.onSettled?.();
+      getLogger().error({ s: opts.logScope, ...opts.logExtra, err: err.message }, opts.logMessage);
+    });
+}

package/extensions/orchestrator/state.test.ts

@@ -1,9 +1,21 @@
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
-import { join } from "path";
+import { join, resolve } from "path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import lockfile from "proper-lockfile";
-import { createTask, getActiveTask, listTasks, loadTask, saveTask, taskAge, taskName, validateFromPath, type TaskState } from "./state.js";
+import {
+  createTask,
+  getActiveTask,
+  getEffectiveMode,
+  getFirstPhase,
+  listTasks,
+  loadTask,
+  saveTask,
+  taskAge,
+  taskName,
+  validateFromPath,
+  type TaskState,
+} from "./state.js";
 
 const tempDirs: string[] = [];
 
@@ -30,6 +42,7 @@ describe("createTask", () => {
     expect(taskDir).toContain(join(cwd, ".pp", "state", "implement"));
     expect(state.phase).toBe("brainstorm");
     expect(state.from).toBeNull();
+    expect(state.repos).toEqual([{ path: resolve(cwd), isRoot: true }]);
     expect(state.description).toBe("Build New Feature");
     expect(new Date(state.startedAt).toString()).not.toBe("Invalid Date");
 
@@ -56,6 +69,21 @@ describe("createTask", () => {
     expect(state.reviewCycle).toBeNull();
     expect(state.reviewPass).toBe(0);
   });
+
+  it("uses quick as initial phase for quick tasks", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "quick", "Quick fix");
+    const state = loadTask(taskDir);
+    expect(state.phase).toBe("quick");
+    expect(state.step).toBe("llm_work");
+  });
+
+  it("stores task mode when provided", () => {
+    const cwd = makeCwd();
+    const taskDir = createTask(cwd, "implement", "Build New Feature", "autonomous");
+    const state = loadTask(taskDir);
+    expect(state.mode).toBe("autonomous");
+  });
 });
 
 describe("loadTask", () => {
@@ -81,12 +109,16 @@ describe("saveTask", () => {
     const taskDir = createTask(cwd, "implement", "Initial");
     const state: TaskState = {
       phase: "implement",
+      initialPhase: "implement",
       step: "user_gate",
       reviewCycle: { kind: "auto", step: "await_reviewers", pass: 2 },
       reviewPass: 1,
+      repos: [],
       from: "implement/some-task",
       description: "Updated",
       startedAt: "2026-04-20T00:00:00.000Z",
+      plannerFailureAutoRetried: false,
+      reviewerFailureAutoRetried: false,
     };
 
     saveTask(taskDir, state);
@@ -125,12 +157,10 @@ describe("listTasks", () => {
     const corrupt = createTask(cwd, "implement", "Broken task");
     writeFileSync(join(corrupt, "state.json"), "{ nope", "utf-8");
 
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
     const tasks = listTasks(cwd, "implement");
 
     expect(tasks).toHaveLength(1);
     expect(tasks[0].state.description).toBe("Healthy task");
-    expect(errorSpy).toHaveBeenCalled();
   });
 });
 
@@ -202,9 +232,7 @@ describe("taskName", () => {
     const taskDir = join(cwd, ".pp", "state", "implement", "123456789012_my-fallback-name");
     mkdirSync(taskDir, { recursive: true });
 
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
     expect(taskName(taskDir)).toBe("my fallback name");
-    expect(errorSpy).toHaveBeenCalled();
   });
 });
 
@@ -341,3 +369,45 @@ describe("getActiveTask", () => {
     expect(checkSpy).toHaveBeenCalledWith(join(taskDir, "state.json"), expect.objectContaining({ stale: 1234 }));
   });
 });
+
+describe("getFirstPhase", () => {
+  it("returns expected first phase for each task type", () => {
+    expect(getFirstPhase("implement")).toBe("brainstorm");
+    expect(getFirstPhase("brainstorm")).toBe("brainstorm");
+    expect(getFirstPhase("debug")).toBe("debug");
+    expect(getFirstPhase("review")).toBe("review");
+    expect(getFirstPhase("quick")).toBe("quick");
+  });
+});
+
+describe("getEffectiveMode", () => {
+  function baseState(): TaskState {
+    return {
+      phase: "brainstorm",
+      step: "llm_work",
+      reviewCycle: null,
+      reviewPass: 0,
+      from: null,
+      description: "x",
+      startedAt: new Date().toISOString(),
+    };
+  }
+
+  it("returns effectiveMode when it is set", () => {
+    const state: TaskState = { ...baseState(), mode: "guided", effectiveMode: "autonomous" };
+
+    expect(getEffectiveMode(state)).toBe("autonomous");
+  });
+
+  it("falls back to mode when effectiveMode is undefined", () => {
+    const state: TaskState = { ...baseState(), mode: "guided" };
+
+    expect(getEffectiveMode(state)).toBe("guided");
+  });
+
+  it("returns undefined when both effectiveMode and mode are undefined", () => {
+    const state: TaskState = { ...baseState() };
+
+    expect(getEffectiveMode(state)).toBeUndefined();
+  });
+});