@pi-unipi/unipi 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -29,6 +29,7 @@
   },
   "files": [
     "packages/*/index.ts",
+    "packages/*/src/**/*.ts",
     "packages/*/extensions/**/*.ts",
     "packages/*/skills/**/*",
     "packages/*/README.md"

package/packages/subagents/src/__tests__/config.test.ts

@@ -0,0 +1,240 @@
+/**
+ * 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);
+    });
+  });
+});

package/packages/subagents/src/__tests__/esc-propagation.test.ts

@@ -0,0 +1,162 @@
+/**
+ * Test: ESC propagation — all children abort on parent ESC
+ *
+ * Verifies:
+ * - forwardAbortSignal wires parent signal to child session
+ * - abortAll stops all running agents
+ * - All agents stop within reasonable time
+ */
+
+import { describe, it, mock, beforeEach } from "node:test";
+import assert from "node:assert/strict";
+
+// Mock AbortController to track abort calls
+function createMockAbortController() {
+  let aborted = false;
+  const listeners: Array<() => void> = [];
+  return {
+    get signal() {
+      return {
+        aborted,
+        addEventListener: (_event: string, listener: () => void) => {
+          listeners.push(listener);
+        },
+        removeEventListener: (_event: string, listener: () => void) => {
+          const idx = listeners.indexOf(listener);
+          if (idx !== -1) listeners.splice(idx, 1);
+        },
+      };
+    },
+    abort() {
+      aborted = true;
+      for (const listener of listeners) listener();
+    },
+    get wasAborted() {
+      return aborted;
+    },
+  };
+}
+
+describe("ESC Propagation", () => {
+  describe("forwardAbortSignal", () => {
+    it("should call session.abort() when signal fires", () => {
+      // Simulate the forwardAbortSignal logic from agent-runner.ts
+      const sessionAborted = { value: false };
+      const session = { abort: () => { sessionAborted.value = true; } };
+      const controller = createMockAbortController();
+
+      // Wire abort signal
+      const onAbort = () => session.abort();
+      controller.signal.addEventListener("abort", onAbort);
+
+      // Trigger abort
+      controller.abort();
+
+      assert.equal(sessionAborted.value, true, "Session should be aborted");
+    });
+
+    it("should not call session.abort() if signal not fired", () => {
+      const sessionAborted = { value: false };
+      const session = { abort: () => { sessionAborted.value = true; } };
+      const controller = createMockAbortController();
+
+      const onAbort = () => session.abort();
+      controller.signal.addEventListener("abort", onAbort);
+
+      // Don't abort
+      assert.equal(sessionAborted.value, false, "Session should not be aborted");
+    });
+
+    it("should cleanup listener when returned function called", () => {
+      const controller = createMockAbortController();
+      let callCount = 0;
+      const onAbort = () => { callCount++; };
+      controller.signal.addEventListener("abort", onAbort);
+
+      // Simulate cleanup
+      const cleanup = () => controller.signal.removeEventListener("abort", onAbort);
+      cleanup();
+
+      controller.abort();
+      assert.equal(callCount, 0, "Listener should not fire after cleanup");
+    });
+  });
+
+  describe("abortAll", () => {
+    it("should abort all running agents", () => {
+      const agents = new Map<string, { abortController: ReturnType<typeof createMockAbortController>; status: string }>();
+
+      // Create 3 mock agents
+      for (let i = 0; i < 3; i++) {
+        const controller = createMockAbortController();
+        agents.set(`agent-${i}`, {
+          abortController: controller,
+          status: "running",
+        });
+      }
+
+      // Simulate abortAll
+      let abortedCount = 0;
+      for (const [id, record] of agents) {
+        if (record.status === "running") {
+          record.abortController.abort();
+          record.status = "stopped";
+          abortedCount++;
+        }
+      }
+
+      assert.equal(abortedCount, 3, "Should abort all 3 agents");
+      for (const [_, record] of agents) {
+        assert.equal(record.status, "stopped", "All agents should be stopped");
+        assert.equal(record.abortController.wasAborted, true, "All controllers should be aborted");
+      }
+    });
+
+    it("should handle queued agents by removing from queue", () => {
+      const queue = [
+        { id: "queued-1", status: "queued" },
+        { id: "queued-2", status: "queued" },
+      ];
+      const agents = new Map<string, { status: string }>();
+
+      for (const item of queue) {
+        agents.set(item.id, { status: item.status });
+      }
+
+      // Simulate abortAll for queued
+      for (const item of queue) {
+        const record = agents.get(item.id);
+        if (record) {
+          record.status = "stopped";
+        }
+      }
+      queue.length = 0;
+
+      assert.equal(queue.length, 0, "Queue should be empty");
+      for (const [_, record] of agents) {
+        assert.equal(record.status, "stopped", "All queued agents should be stopped");
+      }
+    });
+  });
+
+  describe("ESC timing", () => {
+    it("should abort within reasonable time", async () => {
+      const controller = createMockAbortController();
+      let abortedAt: number | null = null;
+      const startedAt = Date.now();
+
+      const onAbort = () => { abortedAt = Date.now(); };
+      controller.signal.addEventListener("abort", onAbort);
+
+      // Simulate abort after small delay
+      setTimeout(() => controller.abort(), 10);
+
+      // Wait for abort
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      assert.notEqual(abortedAt, null, "Should have aborted");
+      const elapsed = abortedAt! - startedAt;
+      assert.ok(elapsed < 500, `Abort should happen within 500ms, took ${elapsed}ms`);
+    });
+  });
+});

package/packages/subagents/src/__tests__/file-lock.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Test: File locking — concurrent writes to same file queue correctly
+ *
+ * Verifies:
+ * - Per-file locking works correctly
+ * - Same file writes queue (second waits for first)
+ * - Different file writes proceed in parallel
+ * - Lock release unblocks waiting acquires
+ * - releaseAll releases all locks for an agent
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+// Inline FileLock implementation for testing (avoids TS import issues)
+interface FileLockEntry {
+  agentId: string;
+  filePath: string;
+  promise: Promise<void>;
+  release: () => void;
+}
+
+class FileLock {
+  private locks = new Map<string, FileLockEntry>();
+  private queues = new Map<string, Array<() => void>>();
+
+  async acquire(filePath: string, agentId: string): Promise<() => void> {
+    while (this.locks.has(filePath)) {
+      await new Promise<void>((resolve) => {
+        const queue = this.queues.get(filePath) ?? [];
+        queue.push(resolve);
+        this.queues.set(filePath, queue);
+      });
+    }
+
+    let releaseFn: () => void;
+    const promise = new Promise<void>((resolve) => {
+      releaseFn = () => {
+        this.locks.delete(filePath);
+        resolve();
+        const queue = this.queues.get(filePath);
+        if (queue && queue.length > 0) {
+          const next = queue.shift()!;
+          next();
+        }
+      };
+    });
+
+    const entry: FileLockEntry = {
+      agentId,
+      filePath,
+      promise,
+      release: releaseFn!,
+    };
+
+    this.locks.set(filePath, entry);
+    return releaseFn!;
+  }
+
+  isLocked(filePath: string): boolean {
+    return this.locks.has(filePath);
+  }
+
+  getHolder(filePath: string): string | undefined {
+    return this.locks.get(filePath)?.agentId;
+  }
+
+  get lockCount(): number {
+    return this.locks.size;
+  }
+
+  releaseAll(agentId: string): void {
+    for (const [filePath, entry] of this.locks) {
+      if (entry.agentId === agentId) {
+        entry.release();
+      }
+    }
+  }
+
+  clear(): void {
+    for (const entry of this.locks.values()) {
+      entry.release();
+    }
+    this.locks.clear();
+    this.queues.clear();
+  }
+}
+
+describe("FileLock", () => {
+  describe("Basic locking", () => {
+    it("should acquire lock on unlocked file", async () => {
+      const lock = new FileLock();
+      const release = await lock.acquire("/src/auth.ts", "agent-1");
+
+      assert.equal(lock.isLocked("/src/auth.ts"), true);
+      assert.equal(lock.getHolder("/src/auth.ts"), "agent-1");
+      assert.equal(lock.lockCount, 1);
+
+      release();
+      assert.equal(lock.isLocked("/src/auth.ts"), false);
+    });
+
+    it("should track multiple locks on different files", async () => {
+      const lock = new FileLock();
+      const release1 = await lock.acquire("/src/auth.ts", "agent-1");
+      const release2 = await lock.acquire("/src/login.ts", "agent-2");
+
+      assert.equal(lock.lockCount, 2);
+      assert.equal(lock.getHolder("/src/auth.ts"), "agent-1");
+      assert.equal(lock.getHolder("/src/login.ts"), "agent-2");
+
+      release1();
+      release2();
+      assert.equal(lock.lockCount, 0);
+    });
+  });
+
+  describe("Queuing behavior", () => {
+    it("should queue second acquire on same file", async () => {
+      const lock = new FileLock();
+      const events: string[] = [];
+
+      // First acquire
+      const release1 = await lock.acquire("/src/auth.ts", "agent-1");
+      events.push("agent-1-acquired");
+
+      // Second acquire (should queue)
+      const acquire2Promise = lock.acquire("/src/auth.ts", "agent-2").then((release) => {
+        events.push("agent-2-acquired");
+        return release;
+      });
+
+      // agent-2 should not have acquired yet
+      assert.deepEqual(events, ["agent-1-acquired"]);
+
+      // Release first lock
+      release1();
+      events.push("agent-1-released");
+
+      // Wait for agent-2
+      const release2 = await acquire2Promise;
+      assert.deepEqual(events, ["agent-1-acquired", "agent-1-released", "agent-2-acquired"]);
+
+      release2();
+    });
+
+    it("should queue multiple acquires on same file", async () => {
+      const lock = new FileLock();
+      const events: string[] = [];
+
+      const release1 = await lock.acquire("/src/auth.ts", "agent-1");
+      events.push("1-acquired");
+
+      const p2 = lock.acquire("/src/auth.ts", "agent-2").then(r => { events.push("2-acquired"); return r; });
+      const p3 = lock.acquire("/src/auth.ts", "agent-3").then(r => { events.push("3-acquired"); return r; });
+
+      release1();
+      const release2 = await p2;
+      assert.deepEqual(events, ["1-acquired", "2-acquired"]);
+
+      release2();
+      const release3 = await p3;
+      assert.deepEqual(events, ["1-acquired", "2-acquired", "3-acquired"]);
+
+      release3();
+    });
+  });
+
+  describe("Parallel different files", () => {
+    it("should allow parallel writes to different files", async () => {
+      const lock = new FileLock();
+      const events: string[] = [];
+
+      // Both should acquire immediately (different files)
+      const release1 = await lock.acquire("/src/auth.ts", "agent-1");
+      events.push("auth-acquired");
+
+      const release2 = await lock.acquire("/src/login.ts", "agent-2");
+      events.push("login-acquired");
+
+      assert.deepEqual(events, ["auth-acquired", "login-acquired"]);
+      assert.equal(lock.lockCount, 2);
+
+      release1();
+      release2();
+    });
+  });
+
+  describe("releaseAll", () => {
+    it("should release all locks for a specific agent", async () => {
+      const lock = new FileLock();
+
+      // agent-1 holds 3 files
+      await lock.acquire("/src/a.ts", "agent-1");
+      await lock.acquire("/src/b.ts", "agent-1");
+      await lock.acquire("/src/c.ts", "agent-1");
+
+      // agent-2 holds 1 file
+      await lock.acquire("/src/d.ts", "agent-2");
+
+      assert.equal(lock.lockCount, 4);
+
+      // Release all for agent-1
+      lock.releaseAll("agent-1");
+
+      assert.equal(lock.lockCount, 1);
+      assert.equal(lock.isLocked("/src/a.ts"), false);
+      assert.equal(lock.isLocked("/src/b.ts"), false);
+      assert.equal(lock.isLocked("/src/c.ts"), false);
+      assert.equal(lock.isLocked("/src/d.ts"), true);
+    });
+
+    it("should unblock queued acquires when releasing all", async () => {
+      const lock = new FileLock();
+      const events: string[] = [];
+
+      const release1 = await lock.acquire("/src/a.ts", "agent-1");
+      const p2 = lock.acquire("/src/a.ts", "agent-2").then(r => { events.push("agent-2-acquired"); return r; });
+
+      // Release all for agent-1
+      lock.releaseAll("agent-1");
+
+      const release2 = await p2;
+      assert.deepEqual(events, ["agent-2-acquired"]);
+
+      release2();
+    });
+  });
+
+  describe("clear", () => {
+    it("should release all locks and clear queues", async () => {
+      const lock = new FileLock();
+
+      await lock.acquire("/src/a.ts", "agent-1");
+      await lock.acquire("/src/b.ts", "agent-2");
+
+      lock.clear();
+
+      assert.equal(lock.lockCount, 0);
+      assert.equal(lock.isLocked("/src/a.ts"), false);
+      assert.equal(lock.isLocked("/src/b.ts"), false);
+    });
+  });
+});