@ilya-lesikov/pi-pi 0.1.0

package/extensions/orchestrator/commands.test.ts

@@ -0,0 +1,81 @@
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { execFileSync } from "child_process";
+import { afterEach, describe, expect, it } from "vitest";
+import { autoCommit } from "./commands.js";
+
+const tempDirs: string[] = [];
+
+function makeRepo(): string {
+  const cwd = mkdtempSync(join(tmpdir(), "pi-pi-commands-"));
+  tempDirs.push(cwd);
+
+  execFileSync("git", ["init"], { cwd, stdio: "pipe" });
+  execFileSync("git", ["config", "user.email", "tests@example.com"], { cwd, stdio: "pipe" });
+  execFileSync("git", ["config", "user.name", "Pi Pi Tests"], { cwd, stdio: "pipe" });
+
+  return cwd;
+}
+
+afterEach(() => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("autoCommit", () => {
+  it("falls back to checkpoint when message is empty", () => {
+    const cwd = makeRepo();
+    const file = "a.ts";
+    writeFileSync(join(cwd, file), "export const a = 1;\n", "utf-8");
+
+    const result = autoCommit([file], "  ", cwd);
+
+    expect(result.ok).toBe(true);
+    const head = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+    expect(head).toMatch(/^[a-f0-9]+$/);
+    const subject = execFileSync("git", ["log", "-1", "--pretty=%s"], { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+    expect(subject).toBe("checkpoint");
+  });
+
+  it("uses message as-is for commit", () => {
+    const cwd = makeRepo();
+    const file = "b.ts";
+    writeFileSync(join(cwd, file), "export const b = 1;\n", "utf-8");
+
+    const result = autoCommit([file], "fix: resolve auth token expiry", cwd);
+
+    expect(result.ok).toBe(true);
+    const subject = execFileSync("git", ["log", "-1", "--pretty=%s"], { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+    expect(subject).toBe("fix: resolve auth token expiry");
+  });
+
+  it("truncates long messages to 72 chars", () => {
+    const cwd = makeRepo();
+    const file = "c.ts";
+    writeFileSync(join(cwd, file), "export const c = 1;\n", "utf-8");
+
+    const longMsg = "a".repeat(100);
+    const result = autoCommit([file], longMsg, cwd);
+
+    expect(result.ok).toBe(true);
+    const subject = execFileSync("git", ["log", "-1", "--pretty=%s"], { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+    expect(subject).toBe("a".repeat(72));
+  });
+
+  it("commits files with spaces in names", () => {
+    const cwd = makeRepo();
+    const file = "file with spaces.ts";
+    writeFileSync(join(cwd, file), "export const spaced = true;\n", "utf-8");
+
+    const result = autoCommit([file], "spaced file", cwd);
+
+    expect(result.ok).toBe(true);
+    const head = execFileSync("git", ["rev-parse", "HEAD"], { cwd, encoding: "utf-8", stdio: "pipe" }).trim();
+    expect(head).toMatch(/^[a-f0-9]+$/);
+    const committedFiles = execFileSync("git", ["show", "--name-only", "--pretty="], { cwd, encoding: "utf-8", stdio: "pipe" });
+    expect(committedFiles.split("\n")).toContain(file);
+  });
+});

package/extensions/orchestrator/commands.ts

@@ -0,0 +1,75 @@
+import { execSync, execFileSync } from "child_process";
+import { dirname } from "path";
+import { minimatch } from "minimatch";
+import type { PiPiConfig, AfterEditCommand } from "./config.js";
+
+interface CommandResult {
+  ok: boolean;
+  command: string;
+  output: string;
+}
+
+function shellEscape(arg: string): string {
+  return "'" + arg.replace(/'/g, "'\\''") + "'";
+}
+
+function substituteVars(command: string, file?: string): string {
+  let result = command;
+  if (file) {
+    result = result.replace(/\$\{file\}/g, shellEscape(file));
+    result = result.replace(/\$\{dir\}/g, shellEscape(dirname(file)));
+  }
+  return result;
+}
+
+export function runAfterEdit(file: string, config: PiPiConfig, cwd: string): CommandResult[] {
+  const results: CommandResult[] = [];
+  const timeout = config.timeouts.afterEdit;
+
+  for (const cmd of config.commands.afterEdit) {
+    const matches = !cmd.glob || cmd.glob.length === 0 || cmd.glob.some((g) => minimatch(file, g, { matchBase: true }));
+    if (!matches) continue;
+
+    const command = substituteVars(cmd.run, file);
+    try {
+      const output = execSync(command, { cwd, encoding: "utf-8", timeout, stdio: "pipe" });
+      results.push({ ok: true, command, output: output.trim() });
+    } catch (err: any) {
+      results.push({ ok: false, command, output: err.stderr?.toString() || err.message || "unknown error" });
+    }
+  }
+
+  return results;
+}
+
+export function runAfterImplement(config: PiPiConfig, cwd: string): CommandResult[] {
+  const results: CommandResult[] = [];
+  const timeout = config.timeouts.afterImplement;
+
+  for (const cmd of config.commands.afterImplement) {
+    const command = substituteVars(cmd.run);
+    try {
+      const output = execSync(command, { cwd, encoding: "utf-8", timeout, stdio: "pipe" });
+      results.push({ ok: true, command, output: output.trim() });
+    } catch (err: any) {
+      results.push({ ok: false, command, output: err.stderr?.toString() || err.message || "unknown error" });
+    }
+  }
+
+  return results;
+}
+
+export function autoCommit(files: string[], message: string, cwd: string): { ok: boolean; commitHash?: string; error?: string } {
+  if (files.length === 0) return { ok: true };
+
+  const cleanMessage = message.trim().slice(0, 72) || "checkpoint";
+
+  try {
+    execFileSync("git", ["add", "--", ...files], { cwd, encoding: "utf-8", stdio: "pipe" });
+    const output =     execFileSync("git", ["commit", "-m", cleanMessage], { cwd, encoding: "utf-8", stdio: "pipe" });
+    const hashMatch = output.match(/\[[\w-]+ (?:\([^)]+\) )?([a-f0-9]+)\]/);
+    return { ok: true, commitHash: hashMatch?.[1] };
+  } catch (err: any) {
+    return { ok: false, error: err.stderr?.toString() || err.message };
+  }
+}

package/extensions/orchestrator/config.test.ts

@@ -0,0 +1,221 @@
+import { afterEach, describe, expect, it } from "vitest";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { deepMerge, loadConfig, validateConfig } from "./config.js";
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "pi-pi-config-test-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("deepMerge", () => {
+  it("merges nested objects while replacing arrays and nulls", () => {
+    const target = {
+      nested: { left: 1, keep: true },
+      arr: [1, 2, 3],
+      nullable: "value",
+      emptyObjectTarget: { keep: "yes" },
+    };
+
+    const source = {
+      nested: { right: 2 },
+      arr: [99],
+      nullable: null,
+      emptyObjectTarget: {},
+    };
+
+    const merged = deepMerge(target, source);
+
+    expect(merged).toEqual({
+      nested: { left: 1, keep: true, right: 2 },
+      arr: [99],
+      nullable: null,
+      emptyObjectTarget: { keep: "yes" },
+    });
+  });
+});
+
+describe("validateConfig", () => {
+  it("throws for empty main model string", () => {
+    expect(() => validateConfig({ mainModel: { implement: { model: "" } } })).toThrow(
+      "config.mainModel.implement.model must be non-empty",
+    );
+  });
+
+  it("throws for enabled variant without model", () => {
+    expect(() => validateConfig({ planners: { broken: { enabled: true, model: "" } } })).toThrow(
+      "config.planners.broken is enabled but has no model",
+    );
+  });
+
+  it("throws when commands.afterEdit is not an array", () => {
+    expect(() => validateConfig({ commands: { afterEdit: { run: "npm test" } } })).toThrow(
+      "config.commands.afterEdit must be an array",
+    );
+  });
+
+  it("throws when commands.afterEdit entry has no run", () => {
+    expect(() => validateConfig({ commands: { afterEdit: [{ glob: ["*.ts"] }] } })).toThrow(
+      "config.commands.afterEdit[0] must have a 'run' field",
+    );
+  });
+
+  it("throws when commands.afterImplement entry has no run", () => {
+    expect(() => validateConfig({ commands: { afterImplement: [{}] } })).toThrow(
+      "config.commands.afterImplement[0] must have a 'run' field",
+    );
+  });
+
+  it("throws for negative timeout values", () => {
+    expect(() => validateConfig({ timeouts: { afterEdit: -1 } })).toThrow(
+      "config.timeouts.afterEdit must be a non-negative number",
+    );
+  });
+
+  it("accepts valid config", () => {
+    expect(() =>
+      validateConfig({
+        mainModel: {
+          implement: { model: "provider/model-1" },
+          debug: { model: "provider/model-2" },
+          brainstorm: { model: "provider/model-3" },
+        },
+        planners: {
+          good: { enabled: true, model: "provider/model-4" },
+          disabled: { enabled: false },
+        },
+        brainstormReviewers: {
+          good: { enabled: true, model: "provider/model-5" },
+        },
+        commands: {
+          afterEdit: [{ run: "npm test", glob: ["*.ts"] }],
+          afterImplement: [{ run: "npm run build" }],
+        },
+        timeouts: { afterEdit: 0, afterImplement: 1 },
+      }),
+    ).not.toThrow();
+  });
+});
+
+describe("loadConfig", () => {
+  it("loads existing config.json and deep merges with defaults", () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const configPath = join(ppDir, "config.json");
+
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(
+      configPath,
+      JSON.stringify({
+        mainModel: {
+          implement: { model: "custom/implement", thinking: "low" },
+        },
+        planners: {
+          opus: { enabled: false },
+        },
+        commands: {
+          afterImplement: [{ run: "npm run lint" }],
+        },
+        timeouts: {
+          afterEdit: 1234,
+        },
+        autoCommit: false,
+      }),
+      "utf-8",
+    );
+
+    const config = loadConfig(cwd, "/nonexistent/global/config.json");
+
+    expect(config.mainModel.implement.model).toBe("custom/implement");
+    expect(config.mainModel.debug.model).toBe("openai/gpt-5.4");
+    expect(config.planners.opus.enabled).toBe(false);
+    expect(config.planners.opus.model).toBe("anthropic/claude-opus-4-6");
+    expect(config.commands.afterEdit).toEqual([]);
+    expect(config.commands.afterImplement).toEqual([{ run: "npm run lint" }]);
+    expect(config.timeouts.afterEdit).toBe(1234);
+    expect(config.timeouts.afterImplement).toBe(300000);
+    expect(config.autoCommit).toBe(false);
+  });
+
+  it("creates default config when config.json does not exist", () => {
+    const cwd = makeTempDir();
+    const configPath = join(cwd, ".pp", "config.json");
+
+    const config = loadConfig(cwd, "/nonexistent/global/config.json");
+
+    expect(existsSync(configPath)).toBe(true);
+    const written = JSON.parse(readFileSync(configPath, "utf-8"));
+    expect(written.mainModel.implement.model).toBe("anthropic/claude-opus-4-6");
+    expect(config.mainModel.implement.model).toBe("anthropic/claude-opus-4-6");
+  });
+
+  it("throws parse errors with config file path", () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const configPath = join(ppDir, "config.json");
+
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(configPath, "{broken", "utf-8");
+
+    expect(() => loadConfig(cwd, "/nonexistent/global/config.json")).toThrow(`Failed to parse ${configPath}`);
+  });
+
+  it("propagates validation errors", () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const configPath = join(ppDir, "config.json");
+
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(configPath, JSON.stringify({ timeouts: { afterEdit: -1 } }), "utf-8");
+
+    expect(() => loadConfig(cwd, "/nonexistent/global/config.json")).toThrow("config.timeouts.afterEdit must be a non-negative number");
+  });
+});
+
+describe("config regressions", () => {
+  it("skips dangerous keys during deep merge", () => {
+    deepMerge({}, { __proto__: { polluted: true } } as Record<string, any>);
+    deepMerge({}, { constructor: { pollutedByConstructor: true }, prototype: { pollutedByPrototype: true } });
+
+    const plainObject: Record<string, unknown> = {};
+    expect((plainObject as any).polluted).toBeUndefined();
+    expect((plainObject as any).pollutedByConstructor).toBeUndefined();
+    expect((plainObject as any).pollutedByPrototype).toBeUndefined();
+  });
+
+  it("deep copies arrays during merge", () => {
+    const target = {};
+    const source = { items: [{ a: 1 }] };
+
+    const merged = deepMerge(target, source);
+    source.items[0].a = 999;
+
+    expect(merged.items[0].a).toBe(1);
+  });
+
+  it("rejects empty agents model and accepts valid agents config", () => {
+    expect(() => validateConfig({ agents: { explore: { model: "", thinking: "low" } } })).toThrow(
+      "config.agents.explore.model must be a non-empty string",
+    );
+
+    expect(() =>
+      validateConfig({
+        agents: {
+          explore: { model: "google/gemini-3.1-flash", thinking: "low" },
+          librarian: { model: "google/gemini-3.1-flash", thinking: "medium" },
+          task: { model: "anthropic/claude-opus-4-6", thinking: "medium" },
+        },
+      }),
+    ).not.toThrow();
+  });
+});

package/extensions/orchestrator/config.ts

@@ -0,0 +1,230 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+export interface ModelConfig {
+  model: string;
+  thinking: string;
+  maxTurns?: number;
+}
+
+export interface VariantConfig extends ModelConfig {
+  enabled: boolean;
+}
+
+export interface AfterEditCommand {
+  run: string;
+  glob: string[];
+}
+
+export interface AfterImplementCommand {
+  run: string;
+}
+
+export interface TimeoutConfig {
+  afterEdit: number;
+  afterImplement: number;
+  agentSpawn: number;
+  agentReadyPing: number;
+  agentStale: number;
+  lockStale: number;
+  lockUpdate: number;
+}
+
+export interface PiPiConfig {
+  mainModel: {
+    implement: ModelConfig;
+    debug: ModelConfig;
+    brainstorm: ModelConfig;
+  };
+  planners: Record<string, VariantConfig>;
+  planReviewers: Record<string, VariantConfig>;
+  codeReviewers: Record<string, VariantConfig>;
+  brainstormReviewers: Record<string, VariantConfig>;
+  agents: {
+    explore: ModelConfig;
+    librarian: ModelConfig;
+    task: ModelConfig;
+  };
+  commands: {
+    afterEdit: AfterEditCommand[];
+    afterImplement: AfterImplementCommand[];
+  };
+  timeouts: TimeoutConfig;
+  autoCommit: boolean;
+  diffBaseBranch?: string;
+}
+
+const DEFAULT_CONFIG: PiPiConfig = {
+  mainModel: {
+    implement: { model: "anthropic/claude-opus-4-6", thinking: "high" },
+    debug: { model: "openai/gpt-5.4", thinking: "high" },
+    brainstorm: { model: "anthropic/claude-opus-4-6", thinking: "high" },
+  },
+  planners: {
+    opus: { enabled: true, model: "anthropic/claude-opus-4-6", thinking: "high" },
+    gpt: { enabled: true, model: "openai/gpt-5.4", thinking: "high" },
+    gemini: { enabled: true, model: "google/gemini-3.1-pro", thinking: "high" },
+  },
+  planReviewers: {
+    opus: { enabled: true, model: "anthropic/claude-opus-4-6", thinking: "high" },
+    gpt: { enabled: true, model: "openai/gpt-5.4", thinking: "high" },
+    gemini: { enabled: true, model: "google/gemini-3.1-pro", thinking: "xhigh" },
+  },
+  codeReviewers: {
+    opus: { enabled: true, model: "anthropic/claude-opus-4-6", thinking: "high" },
+    gpt: { enabled: true, model: "openai/gpt-5.4", thinking: "high" },
+    gemini: { enabled: true, model: "google/gemini-3.1-pro", thinking: "xhigh" },
+  },
+  brainstormReviewers: {
+    opus: { enabled: true, model: "anthropic/claude-opus-4-6", thinking: "high" },
+    gpt: { enabled: true, model: "openai/gpt-5.4", thinking: "high" },
+    gemini: { enabled: true, model: "google/gemini-3.1-pro", thinking: "xhigh" },
+  },
+  agents: {
+    explore: { model: "google/gemini-3.1-flash", thinking: "low" },
+    librarian: { model: "google/gemini-3.1-flash", thinking: "medium" },
+    task: { model: "anthropic/claude-opus-4-6", thinking: "medium" },
+  },
+  commands: {
+    afterEdit: [],
+    afterImplement: [],
+  },
+  timeouts: {
+    afterEdit: 30000,
+    afterImplement: 300000,
+    agentSpawn: 30000,
+    agentReadyPing: 5000,
+    agentStale: 300000,
+    lockStale: 60000,
+    lockUpdate: 30000,
+  },
+  autoCommit: true,
+};
+
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+export function deepMerge(target: Record<string, any>, source: Record<string, any>): Record<string, any> {
+  const result = { ...target };
+  for (const key of Object.keys(source)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+    if (
+      source[key] !== null &&
+      typeof source[key] === "object" &&
+      !Array.isArray(source[key]) &&
+      typeof target[key] === "object" &&
+      !Array.isArray(target[key])
+    ) {
+      result[key] = deepMerge(target[key], source[key]);
+    } else if (Array.isArray(source[key])) {
+      result[key] = structuredClone(source[key]);
+    } else {
+      result[key] = source[key];
+    }
+  }
+  return result;
+}
+
+export function validateConfig(config: Record<string, any>): void {
+  if (config.mainModel) {
+    for (const key of ["implement", "debug", "brainstorm"]) {
+      const mc = config.mainModel[key];
+      if (mc && typeof mc.model === "string" && mc.model.length === 0) {
+        throw new Error(`config.mainModel.${key}.model must be non-empty`);
+      }
+    }
+  }
+
+  for (const group of ["planners", "planReviewers", "codeReviewers", "brainstormReviewers"]) {
+    const variants = config[group];
+    if (!variants || typeof variants !== "object") continue;
+    for (const [name, v] of Object.entries(variants)) {
+      const variant = v as Record<string, any>;
+      if (variant.enabled && (!variant.model || typeof variant.model !== "string" || variant.model.length === 0)) {
+        throw new Error(`config.${group}.${name} is enabled but has no model`);
+      }
+    }
+  }
+
+  if (config.commands?.afterEdit) {
+    if (!Array.isArray(config.commands.afterEdit)) {
+      throw new Error("config.commands.afterEdit must be an array");
+    }
+    for (const [i, cmd] of config.commands.afterEdit.entries()) {
+      if (!cmd.run || typeof cmd.run !== "string") {
+        throw new Error(`config.commands.afterEdit[${i}] must have a 'run' field`);
+      }
+    }
+  }
+
+  if (config.commands?.afterImplement) {
+    if (!Array.isArray(config.commands.afterImplement)) {
+      throw new Error("config.commands.afterImplement must be an array");
+    }
+    for (const [i, cmd] of config.commands.afterImplement.entries()) {
+      if (!cmd.run || typeof cmd.run !== "string") {
+        throw new Error(`config.commands.afterImplement[${i}] must have a 'run' field`);
+      }
+    }
+  }
+
+  if (config.timeouts) {
+    for (const [key, val] of Object.entries(config.timeouts)) {
+      if (typeof val !== "number" || val < 0) {
+        throw new Error(`config.timeouts.${key} must be a non-negative number`);
+      }
+    }
+  }
+
+  if (config.agents) {
+    for (const [name, agent] of Object.entries(config.agents)) {
+      const a = agent as Record<string, any>;
+      if (a.model !== undefined && (typeof a.model !== "string" || a.model.length === 0)) {
+        throw new Error(`config.agents.${name}.model must be a non-empty string`);
+      }
+    }
+  }
+}
+
+function loadJsonFile(path: string): Record<string, any> | null {
+  if (!existsSync(path)) return null;
+  const raw = readFileSync(path, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch (err: any) {
+    throw new Error(`Failed to parse ${path}: ${err.message}`);
+  }
+}
+
+export const GLOBAL_CONFIG_PATH = join(getAgentDir(), "extensions", "pp", "config.json");
+export function loadConfig(cwd: string, globalConfigPath = GLOBAL_CONFIG_PATH): PiPiConfig {
+  const ppDir = join(cwd, ".pp");
+  const projectConfigPath = join(ppDir, "config.json");
+
+  if (!existsSync(ppDir)) {
+    mkdirSync(ppDir, { recursive: true });
+  }
+
+  const globalConfig = loadJsonFile(globalConfigPath);
+  const projectConfig = loadJsonFile(projectConfigPath);
+
+  let merged = { ...DEFAULT_CONFIG } as Record<string, any>;
+
+  const getFlantConfig = (globalThis as any)[Symbol.for("pi-pi:flant-config")] as (() => Partial<PiPiConfig> | null) | undefined;
+  const flantConfig = getFlantConfig?.();
+  if (flantConfig) {
+    merged = deepMerge(merged, flantConfig as Record<string, any>);
+  }
+
+  if (globalConfig) {
+    validateConfig(globalConfig);
+    merged = deepMerge(merged, globalConfig);
+  }
+  if (projectConfig) {
+    validateConfig(projectConfig);
+    merged = deepMerge(merged, projectConfig);
+  }
+
+  return merged as unknown as PiPiConfig;
+}