@pi-archimedes/subagent 2.0.1 → 2.1.0

package/src/local-config.test.ts

@@ -12,6 +12,9 @@ import {
   readLocalConfig,
   writeLocalModel,
   deleteLocalModel,
+  writeLocalThinking,
+  deleteLocalThinking,
+  deleteLocalAgent,
 } from "./local-config.js";
 
 // Redirect getAgentDir() to a temp directory via PI_CODING_AGENT_DIR.
@@ -102,6 +105,99 @@ describe("local-config", () => {
     });
   });
 
+  describe("writeLocalThinking", () => {
+    it("creates file and writes thinking entry", () => {
+      writeLocalThinking("codex", "high");
+      expect(readLocalConfig()).toEqual({ codex: { thinking: "high" } });
+    });
+
+    it("preserves a model on the same entry when writing thinking after model", () => {
+      writeLocalModel("codex", "o1");
+      writeLocalThinking("codex", "high");
+      expect(readLocalConfig()).toEqual({
+        codex: { model: "o1", thinking: "high" },
+      });
+    });
+
+    it("preserves other agent entries when updating one", () => {
+      writeLocalThinking("codex", "high");
+      writeLocalModel("claude", "claude-3.7");
+      expect(readLocalConfig()).toEqual({
+        codex: { thinking: "high" },
+        claude: { model: "claude-3.7" },
+      });
+    });
+  });
+
+  describe("deleteLocalThinking", () => {
+    it("removes only the thinking field, keeping model on the same entry", () => {
+      writeLocalModel("codex", "o1");
+      writeLocalThinking("codex", "high");
+      deleteLocalThinking("codex");
+      expect(readLocalConfig()).toEqual({ codex: { model: "o1" } });
+    });
+
+    it("removes the whole entry when thinking was the only field", () => {
+      writeLocalThinking("codex", "high");
+      deleteLocalThinking("codex");
+      expect(readLocalConfig()).toEqual({});
+    });
+
+    it("is a no-op when agent does not exist", () => {
+      writeLocalModel("codex", "o1");
+      deleteLocalThinking("nonexistent");
+      expect(readLocalConfig()).toEqual({ codex: { model: "o1" } });
+    });
+
+    it("does not create file when deleting absent agent on clean install", () => {
+      // No agents.local.json exists yet. Deleting an absent agent should
+      // be a true no-op — it must NOT materialise an empty file on disk.
+      deleteLocalThinking("nonexistent");
+      expect(existsSync(join(testDir, "agents.local.json"))).toBe(false);
+    });
+  });
+
+  describe("deleteLocalModel field-level semantics", () => {
+    it("leaves thinking intact on the same entry", () => {
+      writeLocalModel("codex", "o1");
+      writeLocalThinking("codex", "high");
+      deleteLocalModel("codex");
+      expect(readLocalConfig()).toEqual({ codex: { thinking: "high" } });
+    });
+  });
+
+  describe("deleteLocalAgent", () => {
+    it("removes the entire entry including all fields", () => {
+      writeLocalModel("codex", "o1");
+      writeLocalThinking("codex", "high");
+      deleteLocalAgent("codex");
+      expect(readLocalConfig()).toEqual({});
+    });
+
+    it("preserves other agent entries", () => {
+      writeLocalModel("codex", "o1");
+      writeLocalThinking("codex", "high");
+      writeLocalModel("claude", "claude-3.7");
+      deleteLocalAgent("codex");
+      expect(readLocalConfig()).toEqual({
+        claude: { model: "claude-3.7" },
+      });
+    });
+
+    it("is a no-op when agent does not exist", () => {
+      writeLocalModel("codex", "o1");
+      deleteLocalAgent("nonexistent");
+      expect(readLocalConfig()).toEqual({ codex: { model: "o1" } });
+    });
+
+    it("does not create file when deleting absent agent on clean install", () => {
+      // No agents.local.json exists yet. Deleting an absent agent should
+      // be a true no-op — it must NOT materialise an empty file on disk.
+      deleteLocalAgent("nonexistent");
+      expect(existsSync(join(testDir, "agents.local.json"))).toBe(false);
+    });
+  });
+
   it("leaves no .tmp file behind after successful write", () => {
     writeLocalModel("codex", "o1");
     const files = readdirSync(testDir);

package/src/local-config.ts

@@ -8,8 +8,11 @@ import {
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
 
+/** Fields that can be overridden per agent in agents.local.json. */
+export type LocalField = "model" | "thinking";
+
 /** Per-agent local overrides stored in agents.local.json */
-export type LocalConfig = Record<string, { model?: string }>;
+export type LocalConfig = Record<string, Partial<Record<LocalField, string>>>;
 
 /** Returns the path to agents.local.json inside the agent directory. */
 export function getLocalConfigPath(): string {
@@ -53,21 +56,62 @@ function writeConfigAtomic(config: LocalConfig): void {
   }
 }
 
-/** Set the local model override for a given agent, preserving existing entries. */
-export function writeLocalModel(agentName: string, model: string): void {
+/** Set the local override for a field on a given agent, preserving existing entries. */
+export function writeLocalField(agentName: string, field: LocalField, value: string): void {
   const config = readLocalConfig();
-  config[agentName] = { ...config[agentName], model };
+  config[agentName] = { ...config[agentName], [field]: value };
   writeConfigAtomic(config);
 }
 
-/** Delete the local model override for a given agent (no-op if absent). */
-export function deleteLocalModel(agentName: string): void {
+/**
+ * Delete the local override for a field on a given agent (no-op if absent).
+ * Removes ONLY the given field — other fields in the same entry are
+ * preserved. If no fields remain, the entry itself is removed.
+ *
+ * Note: deletion is field-level. An entry lacking the given field is left
+ * untouched (a degenerate empty entry `{ codex: {} }` is not removed),
+ * unlike the old entry-level delete. Entries are always written with at
+ * least one field in practice, so this is acceptable.
+ */
+export function deleteLocalField(agentName: string, field: LocalField): void {
+  const config = readLocalConfig();
+  const entry = config[agentName];
+  if (!entry || !(field in entry)) return;
+  delete entry[field];
+  if (Object.keys(entry).length === 0) {
+    delete config[agentName];
+  }
+  writeConfigAtomic(config);
+}
+
+/** Delete the entire local override entry for an agent (no-op if absent). Used on rename. */
+export function deleteLocalAgent(agentName: string): void {
   const config = readLocalConfig();
   if (!(agentName in config)) return;
   delete config[agentName];
   writeConfigAtomic(config);
 }
 
+/** Set the local model override for a given agent, preserving existing entries. */
+export function writeLocalModel(agentName: string, model: string): void {
+  writeLocalField(agentName, "model", model);
+}
+
+/** Delete the local model override for a given agent (no-op if absent). */
+export function deleteLocalModel(agentName: string): void {
+  deleteLocalField(agentName, "model");
+}
+
+/** Set the local thinking-level override for a given agent, preserving existing entries. */
+export function writeLocalThinking(agentName: string, thinking: string): void {
+  writeLocalField(agentName, "thinking", thinking);
+}
+
+/** Delete the local thinking-level override for a given agent (no-op if absent). */
+export function deleteLocalThinking(agentName: string): void {
+  deleteLocalField(agentName, "thinking");
+}
+
 /** Write the full local config atomically (backup+restore safe). */
 export function setLocalConfig(config: LocalConfig): void {
   writeConfigAtomic(config);

package/src/save-agent.test.ts

@@ -4,7 +4,12 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { saveAgent } from "./agent-manager.js";
 import { discoverAgentsAll } from "./agents.js";
-import { writeLocalModel } from "./local-config.js";
+import {
+  writeLocalModel,
+  writeLocalThinking,
+  deleteLocalThinking,
+  deleteLocalAgent,
+} from "./local-config.js";
 
 // Mock writeLocalModel to always throw (simulating a JSON store write
 // failure). deleteLocalModel is a no-op since it's never reached in
@@ -19,6 +24,11 @@ vi.mock("./local-config.js", async (importOriginal) => {
       throw new Error("JSON write failed");
     }),
     deleteLocalModel: vi.fn(),
+    writeLocalThinking: vi.fn(() => {
+      throw new Error("JSON thinking write failed");
+    }),
+    deleteLocalThinking: vi.fn(),
+    deleteLocalAgent: vi.fn(),
   };
 });
 
@@ -481,3 +491,309 @@ describe("saveAgent cleanup of model-less new files", () => {
   });
 });
 
+describe("saveAgent thinking JSON round-trip", () => {
+  beforeEach(() => {
+    mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it("restores thinking to .md when the JSON thinking write fails", () => {
+    // writeLocalModel mocked to succeed for this call only (default throws),
+    // while writeLocalThinking keeps its default throwing implementation,
+    // simulating a failed JSON thinking write.
+    vi.mocked(writeLocalModel).mockImplementationOnce(() => {});
+
+    const state = {
+      editAgent: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+        model: "openai/gpt-4o",
+        thinking: "high",
+      },
+      editOriginal: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+      },
+      agents: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+      editError: null,
+      editDirty: false,
+    };
+
+    saveAgent(state as any, () => {});
+
+    // The .md should contain BOTH fields as rollback fallback.
+    const mdContent = readFileSync(join(testDir, "codex.md"), "utf-8");
+    expect(mdContent).toContain("model: openai/gpt-4o");
+    expect(mdContent).toContain("thinking: high");
+
+    // editError should be set.
+    expect(state.editError).toBeTruthy();
+
+    // The live edit object should retain both values for a safe retry.
+    expect(state.editAgent!.model).toBe("openai/gpt-4o");
+    expect(state.editAgent!.thinking).toBe("high");
+  });
+
+  it("retains thinking for retry when re-discovery fails", () => {
+    // Both JSON writes succeed for this call only, then re-discovery throws.
+    vi.mocked(writeLocalModel).mockImplementationOnce(() => {});
+    vi.mocked(writeLocalThinking).mockImplementationOnce(() => {});
+    vi.mocked(discoverAgentsAll).mockImplementationOnce(() => {
+      throw new Error("discovery failed");
+    });
+
+    const state = {
+      editAgent: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+        model: "openai/gpt-4o",
+        thinking: "high",
+      },
+      editOriginal: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+      },
+      agents: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+      editError: null,
+      editDirty: false,
+    };
+
+    saveAgent(state as any, () => {});
+
+    // The live edit object should still have the thinking — delete only
+    // runs after requestRender() which never executed.
+    expect(state.editAgent!.thinking).toBe("high");
+
+    // editError should contain the discovery failure message.
+    expect(state.editError).toContain("discovery failed");
+
+    // The rolled-back .md should contain the thinking.
+    const mdContent = readFileSync(join(testDir, "codex.md"), "utf-8");
+    expect(mdContent).toContain("thinking: high");
+  });
+
+  it("clearing thinking on save removes only the thinking field from JSON", async () => {
+    // Pre-seed JSON with both fields; the save carries a model but NO
+    // thinking, so only the thinking field should be removed.
+    writeFileSync(
+      join(testDir, "agents.local.json"),
+      JSON.stringify({ codex: { model: "o1", thinking: "high" } }),
+      "utf-8",
+    );
+
+    // Delegate to the real implementations — the no-op mock default for
+    // deleteLocalThinking would leave thinking: "high" behind.
+    const actual = await vi.importActual<typeof import("./local-config.js")>(
+      "./local-config.js",
+    );
+    vi.mocked(writeLocalModel).mockImplementationOnce((name, value) =>
+      actual.writeLocalModel(name, value),
+    );
+    vi.mocked(deleteLocalThinking).mockImplementationOnce((name) =>
+      actual.deleteLocalThinking(name),
+    );
+    vi.mocked(discoverAgentsAll).mockImplementationOnce(() => ({
+      global: [],
+      user: [],
+      project: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+    }));
+
+    const state = {
+      editAgent: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+        model: "o1",
+      },
+      editOriginal: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+      },
+      agents: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+      editError: null,
+      editDirty: false,
+    };
+
+    saveAgent(state as any, () => {});
+
+    // Thinking removed, model preserved.
+    const config = JSON.parse(
+      readFileSync(join(testDir, "agents.local.json"), "utf-8"),
+    );
+    expect(config).toEqual({ codex: { model: "o1" } });
+  });
+
+  it("writes thinking to agents.local.json and strips it from .md on a successful save", async () => {
+    const actual = await vi.importActual<typeof import("./local-config.js")>(
+      "./local-config.js",
+    );
+    vi.mocked(writeLocalModel).mockImplementationOnce((name, value) =>
+      actual.writeLocalModel(name, value),
+    );
+    vi.mocked(writeLocalThinking).mockImplementationOnce((name, value) =>
+      actual.writeLocalThinking(name, value),
+    );
+    vi.mocked(deleteLocalAgent).mockImplementationOnce((name) =>
+      actual.deleteLocalAgent(name),
+    );
+    vi.mocked(discoverAgentsAll).mockImplementationOnce(() => ({
+      global: [],
+      user: [],
+      project: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+    }));
+
+    const state = {
+      editAgent: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+        model: "openai/gpt-4o",
+        thinking: "high",
+      },
+      editOriginal: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "codex.md"),
+      },
+      agents: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+      editError: null,
+      editDirty: false,
+    };
+
+    saveAgent(state as any, () => {});
+
+    // Both fields landed in agents.local.json.
+    const config = JSON.parse(
+      readFileSync(join(testDir, "agents.local.json"), "utf-8"),
+    );
+    expect(config).toEqual({
+      codex: { model: "openai/gpt-4o", thinking: "high" },
+    });
+
+    // The .md has neither field in its frontmatter.
+    const mdContent = readFileSync(join(testDir, "codex.md"), "utf-8");
+    expect(mdContent).not.toContain("model:");
+    expect(mdContent).not.toContain("thinking:");
+
+    // Both fields stripped from the live edit object.
+    expect(state.editAgent!.model).toBeUndefined();
+    expect(state.editAgent!.thinking).toBeUndefined();
+  });
+
+  it("migrates model and thinking JSON entries on rename", async () => {
+    // Pre-seed JSON under the OLD name with both fields.
+    writeFileSync(
+      join(testDir, "agents.local.json"),
+      JSON.stringify({ oldcodex: { model: "old-model", thinking: "high" } }),
+      "utf-8",
+    );
+    writeFileSync(
+      join(testDir, "oldcodex.md"),
+      "original rename content",
+      "utf-8",
+    );
+
+    const actual = await vi.importActual<typeof import("./local-config.js")>(
+      "./local-config.js",
+    );
+    vi.mocked(writeLocalModel).mockImplementationOnce((name, value) =>
+      actual.writeLocalModel(name, value),
+    );
+    vi.mocked(writeLocalThinking).mockImplementationOnce((name, value) =>
+      actual.writeLocalThinking(name, value),
+    );
+    vi.mocked(deleteLocalAgent).mockImplementationOnce((name) =>
+      actual.deleteLocalAgent(name),
+    );
+    vi.mocked(discoverAgentsAll).mockImplementationOnce(() => ({
+      global: [],
+      user: [],
+      project: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+    }));
+
+    const state = {
+      editAgent: {
+        name: "codex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "oldcodex.md"), // oldPath
+        model: "old-model",
+        thinking: "high",
+      },
+      editOriginal: {
+        name: "oldcodex",
+        description: "test agent",
+        systemPrompt: "hello world",
+        source: "user",
+        filePath: join(testDir, "oldcodex.md"),
+      },
+      agents: [],
+      globalDir: null,
+      userDir: testDir,
+      projectDir: null,
+      editError: null,
+      editDirty: false,
+    };
+
+    saveAgent(state as any, () => {});
+
+    // Both fields migrated to the new name; no stale entry under the old name.
+    const config = JSON.parse(
+      readFileSync(join(testDir, "agents.local.json"), "utf-8"),
+    );
+    expect(config).toEqual({ codex: { model: "old-model", thinking: "high" } });
+
+    // The old .md is unlinked and the new one has no model/thinking lines.
+    expect(existsSync(join(testDir, "oldcodex.md"))).toBe(false);
+    const newContent = readFileSync(join(testDir, "codex.md"), "utf-8");
+    expect(newContent).not.toContain("model:");
+    expect(newContent).not.toContain("thinking:");
+  });
+});
+