@pi-unipi/subagents 2.4.0 → 2.4.1

package/src/__tests__/badge-generation.test.ts

@@ -1,315 +0,0 @@
-/**
- * Test: Badge Generation Flow
- *
- * Tests the full badge name generation flow to identify and verify
- * fixes for "Generating session name..." getting stuck.
- *
- * BUG 1 — Tool mismatch:
- * Background agent was told to "Call the set_session_name tool" but the tool
- * doesn't exist in the agent's session (only builtin tools available).
- * FIX: Changed prompt to output title directly, parse in onComplete callback.
- *
- * BUG 2 — Wrong event bus:
- * Cross-module events emitted via pi.events.emit() but listeners used pi.on()
- * (extension lifecycle events) — completely different event bus.
- * FIX: Changed all cross-module listeners to pi.events.on().
- */
-
-import { describe, it } from "node:test";
-import assert from "node:assert/strict";
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-
-const ROOT = join(import.meta.dirname, "../../../..");
-
-// ─── Helpers ────────────────────────────────────────────────────────
-
-function readSource(relativePath: string): string {
-  const fullPath = join(ROOT, relativePath);
-  if (!existsSync(fullPath)) throw new Error(`File not found: ${fullPath}`);
-  return readFileSync(fullPath, "utf-8");
-}
-
-// ─── Test: Tool availability in spawned agent ──────────────────────
-
-describe("Badge generation — tool availability", () => {
-  it("agent-runner uses only builtin tools, NOT extension-registered tools", () => {
-    const src = readSource("packages/subagents/src/agent-runner.ts");
-
-    const builtinMatch = src.match(
-      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
-    );
-    assert.ok(builtinMatch, "BUILTIN_TOOL_NAMES should be defined");
-
-    const builtinTools: string[] = eval(builtinMatch[1]);
-    assert.deepStrictEqual(builtinTools, [
-      "read", "bash", "edit", "write", "grep", "find", "ls",
-    ]);
-  });
-
-  it("set_session_name is NOT in the agent's tool list", () => {
-    const src = readSource("packages/subagents/src/agent-runner.ts");
-    const builtinMatch = src.match(
-      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
-    );
-    const tools: string[] = eval(builtinMatch![1]);
-    assert.ok(!tools.includes("set_session_name"));
-  });
-});
-
-// ─── Test: Prompt no longer references non-existent tool ───────────
-
-describe("Badge generation — prompt fix", () => {
-  it("prompt includes conversation context inline", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(
-      src.includes("Conversation:"),
-      "Prompt should include conversation context inline",
-    );
-
-    assert.ok(
-      src.includes("Reply with ONLY the title"),
-      "Prompt should ask agent to reply with only the title",
-    );
-
-    assert.ok(
-      !src.includes("Call the set_session_name tool"),
-      "Prompt should NOT tell agent to call set_session_name",
-    );
-  });
-});
-
-// ─── Test: onComplete extracts name from result ────────────────────
-
-describe("Badge generation — onComplete callback", () => {
-  it("onComplete extracts name from agent result and calls pi.setSessionName", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(
-      src.includes('record.description === "Generate session name"'),
-      "Should detect badge generation agents by description",
-    );
-
-    assert.ok(
-      src.includes("pi.setSessionName(name)"),
-      "Should call pi.setSessionName with extracted name",
-    );
-  });
-});
-
-// ─── Test: Agent configuration ────────────────────────────────────
-
-describe("Badge generation — agent configuration", () => {
-  it("badge generation uses 'name-gen' agent type (not 'explore')", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(
-      src.includes('manager.spawn(pi, sessionCtx, "name-gen", prompt'),
-      "Badge generation should spawn a 'name-gen' agent",
-    );
-
-    assert.ok(
-      !src.includes('manager.spawn(pi, sessionCtx, "explore"'),
-      "Should NOT use 'explore' — that type can be overridden by user custom agents",
-    );
-  });
-
-  it("'name-gen' type is defined in BUILTIN_CONFIGS with empty tools", () => {
-    const src = readSource("packages/subagents/src/types.ts");
-
-    assert.ok(
-      src.includes('"name-gen"'),
-      "types.ts should define name-gen agent config",
-    );
-
-    assert.ok(
-      src.includes('builtinToolNames: []'),
-      "name-gen should have empty tool list",
-    );
-  });
-
-  it("background agent is isolated (no extensions, no skills, minimal system prompt)", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(
-      src.includes("isolated: true"),
-      "Should spawn with isolated: true to avoid loading extensions/skills",
-    );
-  });
-
-  it("background agent maxTurns is 1 (single response)", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(
-      src.includes("maxTurns: 1"),
-      "Badge generation agent should have maxTurns: 1",
-    );
-  });
-});
-
-// ─── Test: Cross-module event bus — the critical fix ───────────────
-
-describe("Badge generation — event bus (CRITICAL FIX)", () => {
-  it("emitEvent uses pi.events.emit (not pi.on)", () => {
-    const src = readSource("packages/core/utils.ts");
-
-    assert.ok(
-      src.includes("pi.events.emit(eventName, payload)"),
-      "emitEvent should use pi.events.emit()",
-    );
-  });
-
-  it("subagents listens via pi.events.on (NOT pi.on)", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    // Must use pi.events.on for cross-module events
-    assert.ok(
-      src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
-      "Subagents should listen via pi.events.on",
-    );
-
-    // Should NOT use pi.on for custom events
-    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.BADGE_GENERATE_REQUEST/g);
-    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
-  });
-
-  it("utility BADGE_GENERATE_REQUEST listener is removed (input handler already shows overlay)", () => {
-    const src = readSource("packages/utility/src/index.ts");
-
-    // Should NOT have a separate BADGE_GENERATE_REQUEST listener
-    // The input handler already shows the overlay and emits the event
-    assert.ok(
-      !src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
-      "Utility should NOT have a separate BADGE_GENERATE_REQUEST listener",
-    );
-  });
-
-  it("workflow listens for MODULE_READY via pi.events.on (NOT pi.on)", () => {
-    const src = readSource("packages/workflow/index.ts");
-
-    assert.ok(
-      src.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
-      "Workflow should listen via pi.events.on",
-    );
-
-    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.MODULE_READY/g);
-    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
-  });
-
-  it("pi.on() is ONLY used for known lifecycle events", () => {
-    const subagentsSrc = readSource("packages/subagents/src/index.ts");
-    const utilitySrc = readSource("packages/utility/src/index.ts");
-
-    // These are valid lifecycle events that should use pi.on()
-    const validLifecycleEvents = [
-      "session_start", "session_shutdown", "input",
-      "tool_call", "tool_execution_start",
-      "agent_end", "before_agent_start",
-    ];
-
-    // Check that pi.on() is only used with lifecycle events
-    const piOnPattern = /pi\.on\("([^"]+)"/g;
-    let match;
-    while ((match = piOnPattern.exec(subagentsSrc)) !== null) {
-      assert.ok(
-        validLifecycleEvents.includes(match[1]),
-        `subagents: pi.on("${match[1]}") should be a lifecycle event, use pi.events.on() for custom events`,
-      );
-    }
-    while ((match = piOnPattern.exec(utilitySrc)) !== null) {
-      assert.ok(
-        validLifecycleEvents.includes(match[1]),
-        `utility: pi.on("${match[1]}") should be a lifecycle event`,
-      );
-    }
-  });
-});
-
-// ─── Test: Event flow ──────────────────────────────────────────────
-
-describe("Badge generation — event flow", () => {
-  it("utility emits BADGE_GENERATE_REQUEST after agent responds (deferred from input)", () => {
-    const src = readSource("packages/utility/src/index.ts");
-
-    // BADGE_GENERATE_REQUEST should be emitted in agent_end handler, not input
-    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
-    assert.ok(src.includes('source: "input-hook"'));
-
-    // input handler should NOT emit BADGE_GENERATE_REQUEST directly
-    const inputBlock = src.match(/pi\.on\("input"[\s\S]*?(?=pi\.on\(|$)/)?.[0] ?? "";
-    assert.ok(
-      !inputBlock.includes("BADGE_GENERATE_REQUEST"),
-      "input handler should NOT emit BADGE_GENERATE_REQUEST — deferred to agent_end",
-    );
-
-    // agent_end handler should emit BADGE_GENERATE_REQUEST
-    const agentEndBlock = src.match(/pi\.on\("agent_end"[\s\S]*?(?=pi\.on\(|$)/)?.[0] ?? "";
-    assert.ok(
-      agentEndBlock.includes("BADGE_GENERATE_REQUEST"),
-      "agent_end handler should emit BADGE_GENERATE_REQUEST with full conversation context",
-    );
-  });
-
-  it("BADGE_GENERATE_REQUEST event is defined in core", () => {
-    const src = readSource("packages/core/events.ts");
-    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
-  });
-});
-
-// ─── Test: Model resolution ────────────────────────────────────────
-
-describe("Badge generation — model resolution", () => {
-  it("reads generationModel from badge.json instead of hardcoding", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(!src.includes('"openai/gpt-oss-20b"'));
-    assert.ok(src.includes(".unipi/config/badge.json"));
-    assert.ok(src.includes("parsed.generationModel"));
-  });
-});
-
-// ─── Summary ───────────────────────────────────────────────────────
-
-describe("Badge generation — ROOT CAUSE SUMMARY", () => {
-  it("BUG 1 FIXED: prompt no longer references non-existent tool", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(!src.includes("Call the set_session_name tool"),
-      "FIXED: prompt no longer tells agent to call set_session_name");
-    assert.ok(src.includes("Reply with ONLY the title"),
-      "FIXED: prompt asks agent to reply with only the title");
-  });
-
-  it("BUG 1 FIXED: onComplete extracts name and sets it directly", () => {
-    const src = readSource("packages/subagents/src/index.ts");
-
-    assert.ok(src.includes('record.description === "Generate session name"'),
-      "FIXED: onComplete detects badge generation agents");
-    assert.ok(src.includes("pi.setSessionName(name)"),
-      "FIXED: onComplete calls pi.setSessionName directly");
-  });
-
-  it("BUG 2 FIXED: cross-module events use pi.events.on, not pi.on", () => {
-    const subagentsSrc = readSource("packages/subagents/src/index.ts");
-    const utilitySrc = readSource("packages/utility/src/index.ts");
-    const workflowSrc = readSource("packages/workflow/index.ts");
-
-    // Subagents: correct event bus
-    assert.ok(
-      subagentsSrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
-      "subagents: must use pi.events.on for BADGE_GENERATE_REQUEST",
-    );
-
-    // Utility: no duplicate listener (input handler already handles it)
-    assert.ok(
-      !utilitySrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
-      "utility: no duplicate BADGE_GENERATE_REQUEST listener",    );
-
-    // Workflow: correct event bus
-    assert.ok(
-      workflowSrc.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
-      "workflow: must use pi.events.on for MODULE_READY",
-    );
-  });
-});

package/src/__tests__/config.test.ts

@@ -1,240 +0,0 @@
-/**
- * Test: Config auto-generation and corruption recovery
- *
- * Verifies:
- * - Missing config → auto-generated with defaults
- * - Corrupted config → renamed to .json.bak, fresh generated
- * - Workspace config overrides global config
- * - Atomic writes prevent corruption
- */
-
-import { describe, it, beforeEach, afterEach } from "node:test";
-import assert from "node:assert/strict";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, renameSync } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-
-// Inline config implementation for testing
-const DEFAULT_CONFIG = {
-  maxConcurrent: 4,
-  enabled: true,
-  types: {
-    explore: { enabled: true },
-    work: { enabled: true },
-  },
-};
-
-interface SubagentsConfig {
-  maxConcurrent: number;
-  enabled: boolean;
-  types: Record<string, { enabled?: boolean }>;
-}
-
-function loadConfigFromPath(filePath: string): SubagentsConfig | null {
-  if (!existsSync(filePath)) return null;
-  try {
-    const content = readFileSync(filePath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (typeof parsed !== "object" || parsed === null) return null;
-    return parsed as SubagentsConfig;
-  } catch {
-    return null;
-  }
-}
-
-function repairCorrupted(filePath: string): SubagentsConfig {
-  const backupPath = filePath + ".bak";
-  try {
-    renameSync(filePath, backupPath);
-  } catch {
-    // If rename fails, just overwrite
-  }
-  writeConfigAtomic(filePath, DEFAULT_CONFIG);
-  return DEFAULT_CONFIG;
-}
-
-function writeConfigAtomic(filePath: string, config: SubagentsConfig): void {
-  const tmpPath = filePath + ".tmp";
-  writeFileSync(tmpPath, JSON.stringify(config, null, 2), "utf-8");
-  renameSync(tmpPath, filePath);
-}
-
-function initConfig(globalDir: string, workspaceDir: string): SubagentsConfig {
-  const globalPath = join(globalDir, "subagents.json");
-  const workspacePath = join(workspaceDir, "subagents.json");
-
-  // Load or create global config
-  let globalConfig = loadConfigFromPath(globalPath);
-  if (globalConfig === null) {
-    globalConfig = repairCorrupted(globalPath);
-  }
-
-  // Load workspace override if exists
-  const workspaceConfig = loadConfigFromPath(workspacePath);
-
-  if (workspaceConfig) {
-    // Merge: workspace overrides global on any field present
-    return {
-      ...globalConfig,
-      ...workspaceConfig,
-      types: {
-        ...globalConfig.types,
-        ...workspaceConfig.types,
-      },
-    };
-  }
-
-  return globalConfig;
-}
-
-describe("Config Management", () => {
-  let testDir: string;
-  let globalDir: string;
-  let workspaceDir: string;
-
-  beforeEach(() => {
-    // Create temp directories for testing
-    testDir = join(tmpdir(), `subagents-test-${Date.now()}`);
-    globalDir = join(testDir, "global");
-    workspaceDir = join(testDir, "workspace");
-    mkdirSync(globalDir, { recursive: true });
-    mkdirSync(workspaceDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    // Cleanup
-    rmSync(testDir, { recursive: true, force: true });
-  });
-
-  describe("Missing config", () => {
-    it("should auto-generate with defaults when no config exists", () => {
-      const config = initConfig(globalDir, workspaceDir);
-
-      assert.deepEqual(config, DEFAULT_CONFIG);
-      assert.equal(existsSync(join(globalDir, "subagents.json")), true);
-
-      // Verify the generated file
-      const content = readFileSync(join(globalDir, "subagents.json"), "utf-8");
-      const parsed = JSON.parse(content);
-      assert.deepEqual(parsed, DEFAULT_CONFIG);
-    });
-
-    it("should create global config even if workspace exists", () => {
-      // Write workspace config only
-      const workspaceConfig = { maxConcurrent: 8, enabled: true, types: {} };
-      writeFileSync(join(workspaceDir, "subagents.json"), JSON.stringify(workspaceConfig));
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      // Global should be created
-      assert.equal(existsSync(join(globalDir, "subagents.json")), true);
-      // Config should merge
-      assert.equal(config.maxConcurrent, 8); // workspace overrides
-    });
-  });
-
-  describe("Corrupted config", () => {
-    it("should backup corrupted config and generate fresh", () => {
-      const configPath = join(globalDir, "subagents.json");
-      const backupPath = configPath + ".bak";
-
-      // Write corrupted JSON
-      writeFileSync(configPath, "{ invalid json !!!");
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      // Should have created backup
-      assert.equal(existsSync(backupPath), true, "Backup should exist");
-      // Backup should contain corrupted content
-      assert.equal(readFileSync(backupPath, "utf-8"), "{ invalid json !!!");
-      // New config should be defaults
-      assert.deepEqual(config, DEFAULT_CONFIG);
-      // New file should be valid JSON
-      const content = readFileSync(configPath, "utf-8");
-      assert.deepEqual(JSON.parse(content), DEFAULT_CONFIG);
-    });
-
-    it("should handle completely empty file", () => {
-      const configPath = join(globalDir, "subagents.json");
-      writeFileSync(configPath, "");
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      assert.deepEqual(config, DEFAULT_CONFIG);
-      assert.equal(existsSync(configPath + ".bak"), true);
-    });
-
-    it("should handle non-object JSON", () => {
-      const configPath = join(globalDir, "subagents.json");
-      writeFileSync(configPath, '"just a string"');
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      // JSON.parse succeeds but returns string, not object
-      // loadConfigFromPath checks typeof === "object"
-      assert.deepEqual(config, DEFAULT_CONFIG);
-    });
-  });
-
-  describe("Workspace override", () => {
-    it("should merge workspace config with global", () => {
-      const globalConfig = { maxConcurrent: 4, enabled: true, types: { explore: { enabled: true } } };
-      const workspaceConfig = { maxConcurrent: 8, types: { work: { enabled: false } } };
-
-      writeFileSync(join(globalDir, "subagents.json"), JSON.stringify(globalConfig));
-      writeFileSync(join(workspaceDir, "subagents.json"), JSON.stringify(workspaceConfig));
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      assert.equal(config.maxConcurrent, 8); // workspace overrides
-      assert.equal(config.enabled, true); // global preserved
-      assert.deepEqual(config.types.explore, { enabled: true }); // global preserved
-      assert.deepEqual(config.types.work, { enabled: false }); // workspace added
-    });
-
-    it("should override specific fields only", () => {
-      const globalConfig = {
-        maxConcurrent: 4,
-        enabled: true,
-        types: { explore: { enabled: true }, work: { enabled: true } },
-      };
-      const workspaceConfig = { enabled: false };
-
-      writeFileSync(join(globalDir, "subagents.json"), JSON.stringify(globalConfig));
-      writeFileSync(join(workspaceDir, "subagents.json"), JSON.stringify(workspaceConfig));
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      assert.equal(config.maxConcurrent, 4); // global preserved
-      assert.equal(config.enabled, false); // workspace overrides
-      assert.deepEqual(config.types, { explore: { enabled: true }, work: { enabled: true } }); // global preserved
-    });
-
-    it("should handle empty workspace config", () => {
-      const globalConfig = { maxConcurrent: 4, enabled: true, types: {} };
-      writeFileSync(join(globalDir, "subagents.json"), JSON.stringify(globalConfig));
-      writeFileSync(join(workspaceDir, "subagents.json"), "{}");
-
-      const config = initConfig(globalDir, workspaceDir);
-
-      assert.deepEqual(config, globalConfig);
-    });
-  });
-
-  describe("Atomic writes", () => {
-    it("should write config atomically", () => {
-      const configPath = join(globalDir, "subagents.json");
-      const config = { maxConcurrent: 8, enabled: false, types: {} };
-
-      writeConfigAtomic(configPath, config);
-
-      // Should have main file
-      assert.equal(existsSync(configPath), true);
-      // Should not have temp file
-      assert.equal(existsSync(configPath + ".tmp"), false);
-      // Content should be valid
-      const content = readFileSync(configPath, "utf-8");
-      assert.deepEqual(JSON.parse(content), config);
-    });
-  });
-});