@pi-archimedes/subagent 2.2.0 → 2.3.0

package/src/agent-store.ts

@@ -0,0 +1,309 @@
+/**
+ * Agent store — file I/O for the Agent Manager.
+ * Handles save logic: .md serialization, agents.local.json update, and rollback.
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { AgentConfig } from "./agents.js";
+import { discoverAgentsAll } from "./agents.js";
+import { serializeAgent, validateAgentName } from "./frontmatter-io.js";
+import {
+  writeLocalModel,
+  deleteLocalModel,
+  writeLocalThinking,
+  deleteLocalThinking,
+  deleteLocalAgent,
+  readLocalConfig,
+  setLocalConfig,
+  type LocalConfig,
+} from "./local-config.js";
+
+// ── Types shared between store and panel ───────────────────────────────────
+
+interface ModelInfo {
+  id: string;
+  provider: string;
+  fullId: string;
+}
+
+interface ToolInfo {
+  name: string;
+  description: string;
+}
+
+export interface ManagerState {
+  screen: "list" | "detail" | "edit" | "name-input" | "confirm-delete";
+  agents: AgentConfig[];
+  globalAgents: AgentConfig[];
+  userAgents: AgentConfig[];
+  projectAgents: AgentConfig[];
+  globalDir: string | null;
+  userDir: string;
+  projectDir: string | null;
+
+  // List state
+  listCursor: number;
+  listScroll: number;
+  filterQuery: string;
+  filterMode: boolean;
+
+  // Detail state
+  detailAgent: AgentConfig | null;
+  detailScroll: number;
+
+  // Edit state
+  editAgent: AgentConfig | null;
+  editFieldIndex: number;
+  editInField: boolean;
+  editDirty: boolean;
+  editFieldCursor: number;
+  editPromptMode: boolean;
+  editPromptCursor: number;
+  editPromptScroll: number;
+  editDiscardPrompt: boolean;
+  editError: string | null;
+  editOriginal: AgentConfig | null;
+  editReturnScreen: "list" | "detail" | "name-input";
+
+  // Name input state
+  nameInputBuffer: string;
+  nameInputCursor: number;
+  nameInputScope: "global" | "user" | "project";
+  nameInputMode: "new" | "clone";
+  nameInputSource: AgentConfig | null;
+  nameInputError: string | null;
+
+  // Model picker state
+  models: ModelInfo[];
+  modelPickerOpen: boolean;
+  modelSearchQuery: string;
+  modelCursor: number;
+  filteredModels: ModelInfo[];
+
+  // Tool picker state
+  tools: ToolInfo[];
+  toolPickerOpen: boolean;
+  toolCursor: number;
+  toolSelected: Set<string>;
+  toolSearch: string;
+  filteredTools: ToolInfo[];
+
+  // Confirm delete state
+  deleteTarget: AgentConfig | null;
+  deleteFromScreen: "list" | "detail";
+
+  // New agent tracking
+  isNew: boolean;
+
+  // Render width (stored so input handlers can compute correct scroll bounds)
+  lastWidth: number;
+  lastContentWidth: number;
+}
+
+// ── Save logic ──────────────────────────────────────────────────────────────
+
+export function saveAgent(state: ManagerState, requestRender: () => void): void {
+  if (!state.editAgent) return;
+
+  const agent = state.editAgent;
+
+  // Validate name
+  const nameError = validateAgentName(agent.name);
+  if (nameError) {
+    state.editError = nameError;
+    requestRender();
+    return;
+  }
+
+  // Check duplicate name within same scope
+  const duplicate = state.agents.find(
+    (a) => a.source === agent.source && a.name === agent.name && a.filePath !== agent.filePath,
+  );
+  if (duplicate) {
+    state.editError = `Agent "${agent.name}" already exists in ${agent.source} scope`;
+    requestRender();
+    return;
+  }
+
+  // Determine target directory
+  const dir = agent.source === "global" ? state.globalDir
+    : agent.source === "user" ? state.userDir
+    : state.projectDir;
+  if (!dir) {
+    state.editError = "Target directory not available";
+    requestRender();
+    return;
+  }
+
+  const oldPath = agent.filePath;
+  const newName = agent.name.endsWith(".md") ? agent.name : `${agent.name}.md`;
+  const newPath = path.join(dir, newName);
+
+  // Capture model and thinking before entering the try block so they are
+  // available in the catch block for .md rollback if a later step
+  // (JSON write, etc.) fails.
+  const model = agent.model;
+  const thinking = agent.thinking;
+
+  // Track whether the .md write succeeded so the catch block knows whether
+  // to restore or clean up the on-disk file.
+  const isRename = oldPath && oldPath !== newPath;
+  let originalContent: string | undefined;
+  if (!isRename && fs.existsSync(newPath)) {
+    // Read existing .md content so we can restore it verbatim if a later
+    // step (JSON write, re-discovery, etc.) fails.
+    originalContent = fs.readFileSync(newPath, "utf-8");
+  }
+  let mdWritten = false;
+  // Track whether the old .md file was already removed during a rename so
+  // the catch block knows whether newPath is the sole surviving copy.
+  let oldPathDeleted = false;
+  // Track whether the JSON config write succeeded so the catch block can
+  // roll it back if a later step (re-discovery, etc.) fails.
+  let jsonWritten = false;
+  // Snapshot of the JSON config captured before the write so the catch
+  // block can restore it. Declared here (not inside try) so it is
+  // accessible in the catch block.
+  let jsonConfigBefore: LocalConfig = {};
+
+  try {
+    // Ensure directory exists
+    fs.mkdirSync(dir, { recursive: true });
+
+    // Build a shallow copy without the model/thinking for .md serialization
+    // (both fields are stored in agents.local.json) so the live edit object
+    // is NOT mutated during serialization. If the .md write fails below, the
+    // live object stays intact for a retry.
+    const mdAgent = { ...agent };
+    delete mdAgent.model;
+    delete mdAgent.thinking;
+
+    // Serialize and write the .md file FIRST. If this fails, no JSON state
+    // is persisted and the live edit object is untouched.
+    const content = serializeAgent(mdAgent);
+    fs.writeFileSync(newPath, content, "utf-8");
+    mdWritten = true;
+
+    // Only after the .md write succeeds, perform JSON store mutations.
+    // Capture a backup of the current JSON config so we can roll it back
+    // if a later step (re-discovery, etc.) fails after this write succeeds.
+    jsonConfigBefore = readLocalConfig();
+    // Write/remove the NEW name entries first, then clean up the OLD name.
+    if (model !== undefined) {
+      writeLocalModel(agent.name, model);
+    } else {
+      deleteLocalModel(agent.name);
+    }
+    if (thinking !== undefined) {
+      writeLocalThinking(agent.name, thinking);
+    } else {
+      deleteLocalThinking(agent.name);
+    }
+    jsonWritten = true;
+
+    // Handle rename: delete old JSON entry keyed by original name (after
+    // the new entries are safely written) — deleteLocalAgent covers all
+    // fields (model and thinking). Wrapped in try-catch so a failure here
+    // does not leave the .md written but the live object un-stripped.
+    const originalName = state.editOriginal?.name;
+    if (originalName && originalName !== agent.name) {
+      try {
+        deleteLocalAgent(originalName);
+      } catch {
+        // Best-effort: stale entry is harmless and will be cleaned up on
+        // a subsequent save/rename
+      }
+    }
+
+    // Handle rename: delete old .md file if name changed
+    if (oldPath && oldPath !== newPath) {
+      try {
+        fs.unlinkSync(oldPath);
+        oldPathDeleted = true;
+      } catch {
+        // Old file may not exist (e.g., new agent)
+      }
+    }
+
+    // Update filePath
+    agent.filePath = newPath;
+
+    // Refresh agents list
+    const cwd = process.cwd();
+    const discovery = discoverAgentsAll(cwd);
+    state.globalAgents = discovery.global;
+    state.userAgents = discovery.user;
+    state.projectAgents = discovery.project;
+    state.globalDir = discovery.globalDir;
+    state.agents = [...discovery.global, ...discovery.user, ...discovery.project];
+
+    // Find the saved agent and switch to detail
+    const savedAgent = state.agents.find((a) => a.name === agent.name && a.source === agent.source);
+    if (savedAgent) {
+      state.detailAgent = savedAgent;
+      state.detailScroll = 0;
+      state.screen = "detail";
+    }
+
+    state.editDirty = false;
+    state.editError = null;
+    requestRender();
+
+    // Only strip model/thinking from the live edit object AFTER all
+    // operations (including re-discovery) have succeeded. This ensures
+    // that if any step fails, the catch block can restore them to .md
+    // and the live object retains them for a safe retry.
+    delete agent.model;
+    delete agent.thinking;
+  } catch (err) {
+    // Restore prior .md state if the write succeeded but a later step
+    // (JSON write, re-discovery, etc.) failed:
+    //   - rename (old file not yet unlinked): check whether the old file
+    //     still exists. If so, delete newPath so only the original remains.
+    //     If the old file is gone (deleted externally or by a prior attempt),
+    //     newPath may be the sole copy — keep it with a model/thinking
+    //     fallback, or delete it when there is no model/thinking to fall
+    //     back on.
+    //   - existing file: write the original content back verbatim.
+    //   - new file with model/thinking: keep a frontmatter fallback so the
+    //     overrides survive for the next retry.
+    // If the old .md was already unlinked during rename (oldPathDeleted),
+    // newPath is the sole surviving copy — leave it in place.
+    // If the .md write itself failed (mdWritten is false) there is nothing
+    // to restore on disk.
+    if (mdWritten) {
+      if (isRename && !oldPathDeleted) {
+        if (oldPath && fs.existsSync(oldPath)) {
+          // Old file still exists — safe to delete newPath and restore prior state
+          try { fs.unlinkSync(newPath); } catch { /* best-effort */ }
+        } else if (model !== undefined || thinking !== undefined) {
+          // Old file is gone — keep newPath with model/thinking as fallback
+          const fallback: AgentConfig = { ...agent };
+          if (model !== undefined) fallback.model = model;
+          if (thinking !== undefined) fallback.thinking = thinking;
+          try { fs.writeFileSync(newPath, serializeAgent(fallback), "utf-8"); } catch { /* best-effort */ }
+        } else {
+          // Old file is gone and no model/thinking — delete newPath (no prior state to restore)
+          try { fs.unlinkSync(newPath); } catch { /* best-effort */ }
+        }
+      } else if (originalContent !== undefined) {
+        try { fs.writeFileSync(newPath, originalContent, "utf-8"); } catch { /* best-effort */ }
+      } else if (model !== undefined || thinking !== undefined) {
+        const fallback: AgentConfig = { ...agent };
+        if (model !== undefined) fallback.model = model;
+        if (thinking !== undefined) fallback.thinking = thinking;
+        try { fs.writeFileSync(newPath, serializeAgent(fallback), "utf-8"); } catch { /* best-effort */ }
+      } else {
+        // New file without model/thinking — delete it (no prior state to restore)
+        try { fs.unlinkSync(newPath); } catch { /* best-effort */ }
+      }
+    }
+    // Roll back JSON if it was written but a later step failed
+    if (jsonWritten) {
+      try { setLocalConfig(jsonConfigBefore); } catch { /* best-effort */ }
+    }
+    state.editError = err instanceof Error ? err.message : "Failed to save agent";
+    requestRender();
+  }
+}

package/src/compact.test.ts

@@ -126,13 +126,15 @@ describe("buildActivityLine", () => {
     expect(result).toContain("bash");
   });
 
-  it("shows '↳ Starting...' when running with no info", () => {
+  it("shows '▸ Starting...' when running with no info", () => {
     const { theme } = makeMockTheme();
     const result = buildActivityLine(
       activityData({ status: "running" }),
       theme,
     );
-    expect(result).toContain("↳ Starting...");
+    // Glyph and label are rendered as separate themed fragments.
+    expect(result).toContain("▸ ");
+    expect(result).toContain("Starting...");
   });
 
   it("shows first line of final output when available", () => {
@@ -326,7 +328,7 @@ describe("renderCompactParallel", () => {
     };
   }
 
-  it("calls setText with one line per result", () => {
+  it("renders a full 3-line block per agent (parity with single view)", () => {
     const { theme } = makeMockTheme();
     const text = new MockText();
     const details = makeDetails();
@@ -337,9 +339,18 @@ describe("renderCompactParallel", () => {
     const output = (text as unknown as { getContent(): string }).getContent();
     expect(output).toContain("agent-a");
     expect(output).toContain("agent-b");
-    // Two results joined by newline
+    // Each agent is a 3-line block (label / model+stats / activity); with two
+    // agents that is 6 lines total — no status-glyph prefix on the label line.
     const lines = output.split("\n");
-    expect(lines.length).toBeGreaterThanOrEqual(2);
+    expect(lines.length).toBe(6);
+    // Status shows only in each agent's activity line, not as a label prefix:
+    // agent-a succeeded → "✓ Done"; agent-b failed with an error string →
+    // "✗ <error>" (the raw error, here "failed").
+    expect(output).toContain("✓ Done");
+    expect(output).toContain("✗ ");
+    // The label lines carry no leading status glyph.
+    expect(lines[0]).not.toContain("✓");
+    expect(lines[3]).not.toContain("✗");
   });
 
   it("returns the text instance", () => {
@@ -409,8 +420,8 @@ describe("buildActivityLine property tests", () => {
           );
           // Strip ANSI tags to get visible text
           const visible = result.replace(/\[muted\]/g, "").replace(/\[\/muted\]/g, "");
-          // The visible text after "↳ " should be <= 80
-          const afterArrow = visible.replace(/^↳ /, "");
+          // The visible text after the running glyph "▸ " should be <= 80
+          const afterArrow = visible.replace(/^▸ /, "");
           expect(afterArrow.length).toBeLessThanOrEqual(80);
         },
       ),
@@ -428,7 +439,7 @@ describe("buildActivityLine property tests", () => {
             theme,
           );
           const visible = result.replace(/\[dim\]/g, "").replace(/\[\/dim\]/g, "");
-          const afterArrow = visible.replace(/^↳ /, "");
+          const afterArrow = visible.replace(/^▸ /, "");
           expect(afterArrow.length).toBeLessThanOrEqual(60);
         },
       ),