@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/config.test.ts

@@ -1,8 +1,8 @@
 import { afterEach, describe, expect, it } from "vitest";
 import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "fs";
-import { join } from "path";
+import { dirname, join } from "path";
 import { tmpdir } from "os";
-import { deepMerge, loadConfig, validateConfig } from "./config.js";
+import { deepMerge, getDefaultConfig, loadConfig, readRawConfig, removeConfigValue, resolvePreset, validateConfig, writeConfigValue } from "./config.js";
 
 const tempDirs: string[] = [];
 
@@ -46,63 +46,91 @@ describe("deepMerge", () => {
 });
 
 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 empty orchestrator model string", () => {
+    expect(() =>
+      validateConfig({
+        agents: {
+          orchestrators: {
+            implement: { model: "", thinking: "high" },
+          },
+        },
+      }),
+    ).toThrow("config.agents.orchestrators.implement.model must be a non-empty string");
   });
 
-  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 for invalid preset names", () => {
+    expect(() =>
+      validateConfig({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  "bad name": { agents: {} },
+                },
+              },
+            },
+          },
+        },
+      }),
+    ).toThrow("config.agents.subagents.presetGroups.planners.presets.bad name has invalid name");
   });
 
-  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 for invalid variant names", () => {
+    expect(() =>
+      validateConfig({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  regular: {
+                    agents: {
+                      "bad name": { enabled: true, model: "provider/model", thinking: "high" },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }),
+    ).toThrow("config.agents.subagents.presetGroups.planners.presets.regular.agents.bad name has invalid name");
+  });
+
+  it("throws when commands.afterEdit is not an object", () => {
+    expect(() => validateConfig({ commands: { afterEdit: [] } as any })).toThrow(
+      "config.commands.afterEdit must be an object",
     );
   });
 
   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",
+    expect(() => validateConfig({ commands: { afterEdit: { cmd: { run: "", globs: ["*.ts"] } } } })).toThrow(
+      "config.commands.afterEdit.cmd.run must be a non-empty string",
     );
   });
 
   it("throws when commands.afterImplement entry has no run", () => {
-    expect(() => validateConfig({ commands: { afterImplement: [{}] } })).toThrow(
-      "config.commands.afterImplement[0] must have a 'run' field",
+    expect(() => validateConfig({ commands: { afterImplement: { cmd: { run: "" } } } })).toThrow(
+      "config.commands.afterImplement.cmd.run must be a non-empty string",
     );
   });
 
-  it("throws for negative timeout values", () => {
-    expect(() => validateConfig({ timeouts: { afterEdit: -1 } })).toThrow(
-      "config.timeouts.afterEdit must be a non-negative number",
+  it("throws for invalid duration values", () => {
+    expect(() => validateConfig({ performance: { commands: { afterEdit: -1 } } })).toThrow(
+      "config.performance.commands.afterEdit must be a valid duration",
     );
   });
 
-  it("accepts valid config", () => {
+  it("accepts valid partial config", () => {
     expect(() =>
       validateConfig({
-        mainModel: {
-          implement: { model: "provider/model-1" },
-          debug: { model: "provider/model-2" },
-          brainstorm: { model: "provider/model-3" },
-          review: { model: "provider/model-4" },
-        },
-        planners: {
-          good: { enabled: true, model: "provider/model-4" },
-          disabled: { enabled: false },
-        },
-        brainstormReviewers: {
-          good: { enabled: true, model: "provider/model-5" },
-        },
+        general: { autoCommit: false },
         commands: {
-          afterEdit: [{ run: "npm test", glob: ["*.ts"] }],
-          afterImplement: [{ run: "npm run build" }],
+          afterEdit: { fmt: { run: "npm run fmt", globs: ["**/*.ts"] } },
+          afterImplement: { test: { run: "npm test" } },
         },
-        timeouts: { afterEdit: 0, afterImplement: 1 },
+        performance: { commands: { afterEdit: "30s" } },
       }),
     ).not.toThrow();
   });
@@ -118,34 +146,52 @@ describe("loadConfig", () => {
     writeFileSync(
       configPath,
       JSON.stringify({
-        mainModel: {
-          implement: { model: "custom/implement", thinking: "low" },
-        },
-        planners: {
-          opus: { enabled: false },
+        agents: {
+          orchestrators: {
+            implement: { model: "custom/implement", thinking: "low" },
+          },
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  regular: {
+                    agents: {
+                      opus: { enabled: false, model: "anthropic/claude-opus-latest", thinking: "high" },
+                    },
+                  },
+                },
+              },
+            },
+          },
         },
         commands: {
-          afterImplement: [{ run: "npm run lint" }],
+          afterImplement: { lint: { run: "npm run lint" } },
         },
-        timeouts: {
-          afterEdit: 1234,
+        performance: {
+          commands: {
+            afterEdit: 1234,
+          },
+        },
+        general: {
+          autoCommit: false,
         },
-        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);
+    expect(config.agents.orchestrators.implement.model).toBe("custom/implement");
+    expect(config.agents.orchestrators.plan.model).toBe("anthropic/claude-opus-latest");
+    expect(config.agents.orchestrators.debug.model).toBe("openai/gpt-latest");
+    const planners = resolvePreset(config, "planners");
+    expect(planners.opus.enabled).toBe(false);
+    expect(planners.opus.model).toBe("anthropic/claude-opus-latest");
+    expect(config.commands.afterEdit).toEqual({});
+    expect(config.commands.afterImplement).toEqual({ lint: { run: "npm run lint" } });
+    expect(config.performance.commands.afterEdit).toBe(1234);
+    expect(config.performance.commands.afterImplement).toBe(300000);
+    expect(config.general.autoCommit).toBe(false);
   });
 
   it("creates default config when config.json does not exist", () => {
@@ -154,10 +200,9 @@ describe("loadConfig", () => {
 
     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");
+    expect(existsSync(configPath)).toBe(false);
+    expect(config.agents.orchestrators.implement.model).toBe("anthropic/claude-opus-latest");
+    expect(config.agents.orchestrators.plan.model).toBe("anthropic/claude-opus-latest");
   });
 
   it("throws parse errors with config file path", () => {
@@ -177,9 +222,110 @@ describe("loadConfig", () => {
     const configPath = join(ppDir, "config.json");
 
     mkdirSync(ppDir, { recursive: true });
-    writeFileSync(configPath, JSON.stringify({ timeouts: { afterEdit: -1 } }), "utf-8");
+    writeFileSync(configPath, JSON.stringify({ performance: { commands: { afterEdit: -1 } } }), "utf-8");
+
+    expect(() => loadConfig(cwd, "/nonexistent/global/config.json")).toThrow("config.performance.commands.afterEdit must be a valid duration");
+  });
+
+  it("allows project default preset that exists in global presets", () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const projectConfigPath = join(ppDir, "config.json");
+    const globalConfigPath = join(cwd, "global-config.json");
+
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(
+      globalConfigPath,
+      JSON.stringify({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  deep: {
+                    enabled: true,
+                    agents: {
+                      custom: { enabled: true, model: "provider/model-deep", thinking: "high" },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }),
+      "utf-8",
+    );
+    writeFileSync(
+      projectConfigPath,
+      JSON.stringify({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                default: "deep",
+              },
+            },
+          },
+        },
+      }),
+      "utf-8",
+    );
+
+    const config = loadConfig(cwd, globalConfigPath);
 
-    expect(() => loadConfig(cwd, "/nonexistent/global/config.json")).toThrow("config.timeouts.afterEdit must be a non-negative number");
+    expect(config.agents.subagents.presetGroups.planners.default).toBe("deep");
+    expect(resolvePreset(config, "planners")).toEqual(config.agents.subagents.presetGroups.planners.presets.deep.agents);
+  });
+
+  it("throws when merged default preset points to missing preset", () => {
+    const cwd = makeTempDir();
+    const ppDir = join(cwd, ".pp");
+    const projectConfigPath = join(ppDir, "config.json");
+    const globalConfigPath = join(cwd, "global-config.json");
+
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(
+      globalConfigPath,
+      JSON.stringify({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  regular: {
+                    enabled: true,
+                    agents: {
+                      custom: { enabled: true, model: "provider/model-regular", thinking: "high" },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }),
+      "utf-8",
+    );
+    writeFileSync(
+      projectConfigPath,
+      JSON.stringify({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                default: "missing",
+              },
+            },
+          },
+        },
+      }),
+      "utf-8",
+    );
+
+    expect(() => loadConfig(cwd, globalConfigPath)).toThrow(
+      'config.agents.subagents.presetGroups.planners.default "missing" does not exist',
+    );
   });
 });
 
@@ -204,19 +350,94 @@ describe("config regressions", () => {
     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",
-    );
+  it("rejects empty simple subagent model and accepts valid simple subagent config", () => {
+    expect(() =>
+      validateConfig({
+        agents: {
+          subagents: {
+            simple: {
+              explore: { model: "", thinking: "low" },
+            },
+          },
+        },
+      }),
+    ).toThrow("config.agents.subagents.simple.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" },
+          subagents: {
+            simple: {
+              explore: { model: "google/gemini-flash-latest", thinking: "low" },
+              librarian: { model: "google/gemini-flash-latest", thinking: "medium" },
+              task: { model: "anthropic/claude-opus-latest", thinking: "medium" },
+            },
+          },
         },
       }),
     ).not.toThrow();
   });
 });
+
+describe("config write helpers", () => {
+  it("getDefaultConfig returns deep clones", () => {
+    const first = getDefaultConfig();
+    const second = getDefaultConfig();
+
+    first.agents.orchestrators.implement.model = "custom/model";
+    first.commands.afterEdit["cmd-1"] = { run: "echo test", globs: ["*.ts"] };
+
+    expect(second.agents.orchestrators.implement.model).toBe("anthropic/claude-opus-latest");
+    expect(second.commands.afterEdit).toEqual({});
+  });
+
+  it("readRawConfig returns empty object when file does not exist", () => {
+    const filePath = join(makeTempDir(), ".pp", "config.json");
+    expect(readRawConfig(filePath)).toEqual({});
+  });
+
+  it("writeConfigValue creates parent dirs and writes nested key", () => {
+    const filePath = join(makeTempDir(), ".pp", "config.json");
+    writeConfigValue(filePath, ["agents", "subagents", "presetGroups", "planners", "presets", "regular", "agents", "custom"], {
+      enabled: true,
+      model: "x/y",
+      thinking: "high",
+    });
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    expect(raw.agents.subagents.presetGroups.planners.presets.regular.agents.custom).toEqual({
+      enabled: true,
+      model: "x/y",
+      thinking: "high",
+    });
+  });
+
+  it("removeConfigValue removes nested key, prunes empty parents, and keeps file", () => {
+    const filePath = join(makeTempDir(), ".pp", "config.json");
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(
+      filePath,
+      JSON.stringify({
+        agents: {
+          subagents: {
+            presetGroups: {
+              planners: {
+                presets: {
+                  regular: {
+                    agents: {
+                      a: { enabled: true },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      }),
+      "utf-8",
+    );
+    removeConfigValue(filePath, ["agents", "subagents", "presetGroups", "planners", "presets", "regular", "agents", "a"]);
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    expect(raw).toEqual({});
+    expect(existsSync(filePath)).toBe(true);
+  });
+});