@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/context.test.ts

@@ -2,9 +2,20 @@ import { afterEach, describe, expect, it, vi } from "vitest";
 import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "fs";
 import { join } from "path";
 import { tmpdir } from "os";
+
+const mockState = vi.hoisted(() => ({
+  agentDir: "",
+}));
+
+vi.mock("@earendil-works/pi-coding-agent", () => ({
+  getAgentDir: () => mockState.agentDir,
+}));
+
 import {
+  getContextDirs,
   getLatestSynthesizedPlan,
   getPhaseArtifacts,
+  loadAllContextFiles,
   loadContextFiles,
   loadBrainstormReviewOutputs,
   loadCodeReviewOutputs,
@@ -125,6 +136,95 @@ describe("loadContextFiles", () => {
     expect(loadContextFiles(cwd, "explore")).toEqual([]);
   });
 
+  it("supports brainstormReviewer agent type", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "brainstorm-reviewer.md"),
+      "---\nagents: brainstormReviewer\n---\nbrainstorm reviewer only\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "brainstormReviewer")).toEqual([{ mode: "context", content: "brainstorm reviewer only" }]);
+    expect(loadContextFiles(cwd, "codeReviewer")).toEqual([]);
+  });
+
+  it("parses phase/vendor/family/tier filters and matches when all filters pass", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "filtered.md"),
+      "---\ninject: system\nagents: ['planner']\nphases: ['plan']\nvendors: ['anthropic']\nfamilies: ['sonnet']\ntiers: ['regular']\n---\nfiltered\n",
+      "utf-8",
+    );
+
+    expect(
+      loadContextFiles(cwd, "planner", "system", "plan", { vendor: "anthropic", family: "sonnet", tier: "regular" }),
+    ).toEqual([{ mode: "system", content: "filtered" }]);
+  });
+
+  it("uses AND between filters and OR inside each filter", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "or-and.md"),
+      "---\nagents: [codeReviewer]\nphases: [implement, review]\nvendors: [openai, anthropic]\nfamilies: [gpt, gpt-mini]\ntiers: [regular, stupid]\n---\nmatched\n",
+      "utf-8",
+    );
+
+    expect(
+      loadContextFiles(cwd, "codeReviewer", "context", "review", { vendor: "openai", family: "gpt-mini", tier: "stupid" }),
+    ).toEqual([{ mode: "context", content: "matched" }]);
+
+    expect(
+      loadContextFiles(cwd, "codeReviewer", "context", "review", { vendor: "google", family: "gpt-mini", tier: "stupid" }),
+    ).toEqual([]);
+    expect(
+      loadContextFiles(cwd, "codeReviewer", "context", "debug", { vendor: "openai", family: "gpt-mini", tier: "stupid" }),
+    ).toEqual([]);
+  });
+
+  it("treats empty filter arrays as match-all", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "empty-filters.md"),
+      "---\nagents: [planner]\nphases: []\nvendors: []\nfamilies: []\ntiers: []\n---\nno restrictions\n",
+      "utf-8",
+    );
+
+    expect(
+      loadContextFiles(cwd, "planner", "context", "plan", { vendor: "unknown", family: "unknown", tier: "unknown" }),
+    ).toEqual([{ mode: "context", content: "no restrictions" }]);
+    expect(loadContextFiles(cwd, "planner", "context")).toEqual([{ mode: "context", content: "no restrictions" }]);
+  });
+
+  it("applies filter restrictions only when phase/model info are provided", () => {
+    const cwd = makeTempDir();
+    const contextDir = join(cwd, ".pp", "context");
+    mkdirSync(contextDir, { recursive: true });
+
+    writeFileSync(
+      join(contextDir, "requires-filters.md"),
+      "---\nagents: [planner]\nphases: [plan]\nvendors: [anthropic]\nfamilies: [sonnet]\ntiers: [regular]\n---\nrestricted\n",
+      "utf-8",
+    );
+
+    expect(loadContextFiles(cwd, "planner", "context")).toEqual([{ mode: "context", content: "restricted" }]);
+    expect(loadContextFiles(cwd, "planner", "context", "plan")).toEqual([{ mode: "context", content: "restricted" }]);
+    expect(
+      loadContextFiles(cwd, "planner", "context", "plan", { vendor: "openai", family: "gpt", tier: "regular" }),
+    ).toEqual([]);
+  });
+
   it("skips non-markdown files", () => {
     const cwd = makeTempDir();
     const contextDir = join(cwd, ".pp", "context");
@@ -146,13 +246,78 @@ describe("loadContextFiles", () => {
     chmodSync(brokenPath, 0o000);
     writeFileSync(join(contextDir, "good.md"), "---\nagents: main\n---\ngood file\n", "utf-8");
 
-    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
     const result = loadContextFiles(cwd, "main");
 
     expect(result).toEqual([{ mode: "context", content: "good file" }]);
-    expect(errorSpy).toHaveBeenCalledTimes(1);
-    expect(String(errorSpy.mock.calls[0][0])).toContain("Failed to read context file");
-    expect(String(errorSpy.mock.calls[0][0])).toContain("broken.md");
+  });
+});
+
+describe("loadAllContextFiles", () => {
+  it("loads files from all provided directories preserving directory order", () => {
+    const root = makeTempDir();
+    const dirA = join(root, "ctx-a");
+    const dirB = join(root, "ctx-b");
+    mkdirSync(dirA, { recursive: true });
+    mkdirSync(dirB, { recursive: true });
+
+    writeFileSync(join(dirA, "a.md"), "---\nagents: main\n---\nfrom a\n", "utf-8");
+    writeFileSync(join(dirB, "b.md"), "---\nagents: main\n---\nfrom b\n", "utf-8");
+
+    expect(loadAllContextFiles([dirA, dirB], "main")).toEqual([
+      { mode: "context", content: "from a" },
+      { mode: "context", content: "from b" },
+    ]);
+  });
+});
+
+describe("getContextDirs", () => {
+  it("returns global, root, and extra repo context dirs in order", () => {
+    const root = makeTempDir();
+    const extra = makeTempDir();
+    const agentDir = makeTempDir();
+    mockState.agentDir = agentDir;
+    mkdirSync(join(root, ".pp", "context"), { recursive: true });
+    mkdirSync(join(extra, ".pp", "context"), { recursive: true });
+    mkdirSync(join(agentDir, "extensions", "pp", "context"), { recursive: true });
+
+    expect(
+      getContextDirs(
+        root,
+        [
+          { path: root, isRoot: true },
+          { path: extra, isRoot: false },
+        ],
+        true,
+      ),
+    ).toEqual([
+      join(agentDir, "extensions", "pp", "context"),
+      join(root, ".pp", "context"),
+      join(extra, ".pp", "context"),
+    ]);
+  });
+
+  it("omits extra repos when ignoreExtraRepoConfigs is true", () => {
+    const root = makeTempDir();
+    const extra = makeTempDir();
+    const agentDir = makeTempDir();
+    mockState.agentDir = agentDir;
+    mkdirSync(join(root, ".pp", "context"), { recursive: true });
+    mkdirSync(join(extra, ".pp", "context"), { recursive: true });
+    mkdirSync(join(agentDir, "extensions", "pp", "context"), { recursive: true });
+
+    expect(
+      getContextDirs(
+        root,
+        [
+          { path: root, isRoot: true },
+          { path: extra, isRoot: false },
+        ],
+        false,
+      ),
+    ).toEqual([
+      join(agentDir, "extensions", "pp", "context"),
+      join(root, ".pp", "context"),
+    ]);
   });
 });
 
@@ -277,17 +442,19 @@ describe("context regressions", () => {
     ]);
   });
 
-  it("loads all plan review outputs regardless of pass", () => {
+  it("filters plan review outputs by pass", () => {
     const taskDir = makeTempDir();
     const planReviewsDir = join(taskDir, "plan-reviews");
     mkdirSync(planReviewsDir, { recursive: true });
 
-    writeFileSync(join(planReviewsDir, "001_alpha.md"), "a", "utf-8");
-    writeFileSync(join(planReviewsDir, "002_beta.md"), "b", "utf-8");
+    writeFileSync(join(planReviewsDir, "001_alpha_round-1.md"), "a", "utf-8");
+    writeFileSync(join(planReviewsDir, "002_beta_round-2.md"), "b", "utf-8");
 
-    expect(loadPlanReviewOutputs(taskDir).map((r) => r.name)).toEqual([
-      "001_alpha.md",
-      "002_beta.md",
+    expect(loadPlanReviewOutputs(taskDir, 1).map((r) => r.name)).toEqual([
+      "001_alpha_round-1.md",
+    ]);
+    expect(loadPlanReviewOutputs(taskDir, 2).map((r) => r.name)).toEqual([
+      "002_beta_round-2.md",
     ]);
   });
 });

package/extensions/orchestrator/context.ts

@@ -1,10 +1,18 @@
 import { readFileSync, existsSync, readdirSync } from "fs";
 import { join } from "path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { RepoInfo } from "./repo-utils.js";
 import type { Phase } from "./state.js";
+import { getLogger } from "./log.js";
 
-type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer";
+type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer" | "brainstormReviewer";
 type AgentGroup = "all" | "subagents";
 type InjectMode = "system" | "context";
+type PhaseFilter = "brainstorm" | "debug" | "plan" | "implement" | "review";
+type VendorFilter = "anthropic" | "openai" | "google" | "unknown";
+type FamilyFilter = "opus" | "sonnet" | "haiku" | "gpt" | "gpt-mini" | "gemini-pro" | "gemini-flash" | "unknown";
+type TierFilter = "stupid" | "regular" | "smart" | "xsmart" | "unknown";
+type ModelInfo = { vendor: string; family: string; tier: string };
 
 interface ContextFile {
   mode: InjectMode;
@@ -15,17 +23,33 @@ interface Frontmatter {
   inject: InjectMode;
   agents: AgentType[];
   agentGroups: AgentGroup[];
+  phases: PhaseFilter[];
+  vendors: VendorFilter[];
+  families: FamilyFilter[];
+  tiers: TierFilter[];
 }
 
 const VALID_INJECT_MODES: readonly string[] = ["system", "context"];
-const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer"];
+const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer", "brainstormReviewer"];
 const VALID_AGENT_GROUPS: readonly string[] = ["all", "subagents"];
+const VALID_PHASES: readonly string[] = ["brainstorm", "debug", "plan", "implement", "review"];
+const VALID_VENDORS: readonly string[] = ["anthropic", "openai", "google", "unknown"];
+const VALID_FAMILIES: readonly string[] = ["opus", "sonnet", "haiku", "gpt", "gpt-mini", "gemini-pro", "gemini-flash", "unknown"];
+const VALID_TIERS: readonly string[] = ["stupid", "regular", "smart", "xsmart", "unknown"];
 
 function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string } {
   const match = raw.match(/^---[^\S\n]*\n([\s\S]*?)\n---[^\S\n]*\n([\s\S]*)$/);
   if (!match) {
     return {
-      frontmatter: { inject: "context", agents: ["main"], agentGroups: [] },
+      frontmatter: {
+        inject: "context",
+        agents: ["main"],
+        agentGroups: [],
+        phases: [],
+        vendors: [],
+        families: [],
+        tiers: [],
+      },
       body: raw,
     };
   }
@@ -36,6 +60,10 @@ function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string
   let inject: InjectMode = "context";
   let agents: AgentType[] = [];
   let agentGroups: AgentGroup[] = [];
+  let phases: PhaseFilter[] = [];
+  let vendors: VendorFilter[] = [];
+  let families: FamilyFilter[] = [];
+  let tiers: TierFilter[] = [];
 
   for (const line of yamlBlock.split("\n")) {
     const trimmed = line.trim();
@@ -56,6 +84,14 @@ function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string
       agents = parseArray(val).filter((v): v is AgentType => VALID_AGENTS.includes(v));
     } else if (key === "agentGroups") {
       agentGroups = parseArray(val).filter((v): v is AgentGroup => VALID_AGENT_GROUPS.includes(v));
+    } else if (key === "phases") {
+      phases = parseArray(val).filter((v): v is PhaseFilter => VALID_PHASES.includes(v));
+    } else if (key === "vendors") {
+      vendors = parseArray(val).filter((v): v is VendorFilter => VALID_VENDORS.includes(v));
+    } else if (key === "families") {
+      families = parseArray(val).filter((v): v is FamilyFilter => VALID_FAMILIES.includes(v));
+    } else if (key === "tiers") {
+      tiers = parseArray(val).filter((v): v is TierFilter => VALID_TIERS.includes(v));
     }
   }
 
@@ -63,7 +99,10 @@ function parseFrontmatter(raw: string): { frontmatter: Frontmatter; body: string
     agents = ["main"];
   }
 
-  return { frontmatter: { inject, agents, agentGroups }, body };
+  return {
+    frontmatter: { inject, agents, agentGroups, phases, vendors, families, tiers },
+    body,
+  };
 }
 
 function stripQuotes(val: string): string {
@@ -99,8 +138,39 @@ function matchesAgent(fm: Frontmatter, agentType: AgentType): boolean {
   return fm.agents.includes(agentType);
 }
 
-export function loadContextFiles(cwd: string, agentType: AgentType, injectMode?: InjectMode): ContextFile[] {
-  const contextDir = join(cwd, ".pp", "context");
+function matchesFilters(
+  fm: Frontmatter,
+  agentType: AgentType,
+  phase?: string,
+  modelInfo?: ModelInfo,
+): boolean {
+  if (!matchesAgent(fm, agentType)) return false;
+  if (fm.phases.length > 0 && phase && !fm.phases.includes(phase as PhaseFilter)) return false;
+  if (modelInfo) {
+    if (fm.vendors.length > 0 && !fm.vendors.includes(modelInfo.vendor as VendorFilter)) return false;
+    if (fm.families.length > 0 && !fm.families.includes(modelInfo.family as FamilyFilter)) return false;
+    if (fm.tiers.length > 0 && !fm.tiers.includes(modelInfo.tier as TierFilter)) return false;
+  }
+  return true;
+}
+
+export function loadContextFiles(
+  cwd: string,
+  agentType: AgentType,
+  injectMode?: InjectMode,
+  phase?: string,
+  modelInfo?: ModelInfo,
+): ContextFile[] {
+  return loadContextFilesFromDir(join(cwd, ".pp", "context"), agentType, injectMode, phase, modelInfo);
+}
+
+export function loadContextFilesFromDir(
+  contextDir: string,
+  agentType: AgentType,
+  injectMode?: InjectMode,
+  phase?: string,
+  modelInfo?: ModelInfo,
+): ContextFile[] {
   if (!existsSync(contextDir)) return [];
 
   const results: ContextFile[] = [];
@@ -111,12 +181,12 @@ export function loadContextFiles(cwd: string, agentType: AgentType, injectMode?:
     try {
       raw = readFileSync(filePath, "utf-8");
     } catch (err: any) {
-      console.error(`[pi-pi] Failed to read context file ${filePath}: ${err.message}`);
+      getLogger().warn({ s: "context", filePath, err: err.message }, "failed to read context file");
       continue;
     }
     const { frontmatter, body } = parseFrontmatter(raw);
 
-    if (!matchesAgent(frontmatter, agentType)) continue;
+    if (!matchesFilters(frontmatter, agentType, phase, modelInfo)) continue;
     if (injectMode && frontmatter.inject !== injectMode) continue;
 
     results.push({ mode: frontmatter.inject, content: body.trim() });
@@ -125,10 +195,41 @@ export function loadContextFiles(cwd: string, agentType: AgentType, injectMode?:
   return results;
 }
 
-export function loadAgentsMd(cwd: string): string | null {
-  const agentsPath = join(cwd, "AGENTS.md");
-  if (!existsSync(agentsPath)) return null;
-  return readFileSync(agentsPath, "utf-8");
+export function loadAllContextFiles(
+  contextDirs: string[],
+  agentType: AgentType,
+  injectMode?: InjectMode,
+  phase?: string,
+  modelInfo?: ModelInfo,
+): ContextFile[] {
+  const results: ContextFile[] = [];
+  for (const contextDir of contextDirs) {
+    results.push(...loadContextFilesFromDir(contextDir, agentType, injectMode, phase, modelInfo));
+  }
+  getLogger().debug({ s: "context", agentType, injectMode, phase, dirs: contextDirs.length, files: results.length }, "loaded context files");
+  return results;
+}
+
+export function getContextDirs(rootCwd: string, repos: RepoInfo[], loadExtraRepoConfigs: boolean): string[] {
+  const dirs: string[] = [];
+  const seen = new Set<string>();
+  const add = (dir: string) => {
+    if (!existsSync(dir) || seen.has(dir)) return;
+    seen.add(dir);
+    dirs.push(dir);
+  };
+
+  add(join(getAgentDir(), "extensions", "pp", "context"));
+  add(join(rootCwd, ".pp", "context"));
+
+  if (loadExtraRepoConfigs) {
+    for (const repo of repos) {
+      if (repo.isRoot) continue;
+      add(join(repo.path, ".pp", "context"));
+    }
+  }
+
+  return dirs;
 }
 
 export function getPhaseArtifacts(taskDir: string, phase: Phase): { name: string; content: string }[] {
@@ -196,11 +297,11 @@ export function loadCodeReviewOutputs(taskDir: string, pass: number): { name: st
     .map((name) => ({ name, content: readFileSync(join(dir, name), "utf-8") }));
 }
 
-export function loadPlanReviewOutputs(taskDir: string): { name: string; content: string }[] {
+export function loadPlanReviewOutputs(taskDir: string, pass: number): { name: string; content: string }[] {
   const dir = join(taskDir, "plan-reviews");
   if (!existsSync(dir)) return [];
   return readdirSync(dir)
-    .filter((f) => f.endsWith(".md"))
+    .filter((f) => f.includes(`round-${pass}`) && f.endsWith(".md"))
     .sort()
     .map((name) => ({ name, content: readFileSync(join(dir, name), "utf-8") }));
 }

package/extensions/orchestrator/custom-footer.ts

@@ -63,8 +63,9 @@ function renderStatsLine(width: number, theme: Theme): string {
   const cacheRate = tracker?.getCacheHitRate() ?? 0;
   const totalCost = tracker?.getTotalCost() ?? 0;
 
+  const cacheSupported = tracker?.isCacheSupported() ?? false;
   const leftParts: string[] = [`↑${formatTokens(inputTokens)}`, `↓${formatTokens(outputTokens)}`];
-  if (cacheRate > 0) leftParts.push(`⚡${Math.round(cacheRate * 100)}%`);
+  if (cacheSupported) leftParts.push(`⚡${Math.round(cacheRate * 100)}%`);
   if (totalCost > 0) leftParts.push(`$${totalCost.toFixed(2)}`);
   leftParts.push(toContextUsagePart(ctx, theme));
   let left = leftParts.join(" ");