@pi-unipi/unipi 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -24,10 +24,12 @@
   ],
   "scripts": {
     "typecheck": "npx tsc --noEmit --skipLibCheck",
+    "test": "npm test --workspaces",
     "publish:all": "npm publish --workspaces --access public"
   },
   "files": [
     "packages/*/index.ts",
+    "packages/*/src/**/*.ts",
     "packages/*/extensions/**/*.ts",
     "packages/*/skills/**/*",
     "packages/*/README.md"
@@ -39,7 +41,8 @@
       "node_modules/@pi-unipi/memory/index.ts",
       "node_modules/@pi-unipi/info-screen/index.ts",
       "node_modules/@pi-unipi/subagents/src/index.ts",
-      "node_modules/@pi-unipi/btw/extensions/btw.ts"
+      "node_modules/@pi-unipi/btw/extensions/btw.ts",
+      "node_modules/@pi-unipi/web-api/src/index.ts"
     ],
     "skills": [
       "node_modules/@pi-unipi/workflow/skills",
@@ -61,7 +64,8 @@
     "@pi-unipi/memory": "*",
     "@pi-unipi/info-screen": "*",
     "@pi-unipi/subagents": "*",
-    "@pi-unipi/btw": "*"
+    "@pi-unipi/btw": "*",
+    "@pi-unipi/web-api": "*"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/packages/memory/index.ts

@@ -26,8 +26,9 @@ import {
   searchAllProjects,
   listAllProjects,
 } from "./storage.js";
-import { registerMemoryTools, MEMORY_TOOLS } from "./tools.js";
+import { registerMemoryTools, MEMORY_TOOLS, GLOBAL_SEARCH_ALIAS } from "./tools.js";
 import { registerMemoryCommands } from "./commands.js";
+import { isEmbeddingReady, hasModelChanged } from "./settings.js";
 
 /** Package version */
 const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
@@ -47,6 +48,10 @@ function getStorage(): MemoryStorage {
 }
 
 export default function (pi: ExtensionAPI) {
+  // Lifecycle state — tracks whether recall/store have happened this session
+  let recallDone = false;
+  let storeDone = false;
+
   // Register skills directory
   const skillsDir = new URL("./skills", import.meta.url).pathname;
   pi.on("resources_discover", async (_event, _ctx) => {
@@ -56,11 +61,15 @@ export default function (pi: ExtensionAPI) {
   });
 
   // Register tools and commands
-  registerMemoryTools(pi, getStorage);
+  registerMemoryTools(pi, getStorage, () => { recallDone = true; storeDone = true; });
   registerMemoryCommands(pi, getStorage);
 
   // Session lifecycle
   pi.on("session_start", async (_event, ctx) => {
+    // Reset lifecycle flags
+    recallDone = false;
+    storeDone = false;
+
     // Initialize project storage
     const projectName = getProjectName(ctx.cwd);
     projectStorage = new MemoryStorage(projectName);
@@ -78,13 +87,14 @@ export default function (pi: ExtensionAPI) {
         "unipi:memory-forget",
         "unipi:global-memory-search",
         "unipi:global-memory-list",
+        "unipi:memory-settings",
       ],
       tools: [
         MEMORY_TOOLS.STORE,
         MEMORY_TOOLS.SEARCH,
         MEMORY_TOOLS.DELETE,
         MEMORY_TOOLS.LIST,
-        MEMORY_TOOLS.GLOBAL_SEARCH,
+        GLOBAL_SEARCH_ALIAS,
         MEMORY_TOOLS.GLOBAL_LIST,
       ],
     });
@@ -146,59 +156,76 @@ export default function (pi: ExtensionAPI) {
       const projectCount = projectStorage.listAll().length;
       const allMemories = listAllProjects();
       const projectCountAll = allMemories.length;
+      const vecReady = isEmbeddingReady();
+      const vecIcon = vecReady ? "⚡" : "📝";
       ctx.ui.setStatus(
         "unipi-memory",
-        `🧠 memory ${projectCount}p/${projectCountAll}all`
+        `${vecIcon} memory ${projectCount}p/${projectCountAll}all${hasModelChanged() ? " ⚠" : ""}`
       );
     }
   });
 
-  // Inject memory titles at session start
+  // Inject memory recall reminder at agent start (hidden message, not system prompt)
   pi.on("before_agent_start", async (event, ctx) => {
+    if (recallDone) return;
     if (!projectStorage) return;
 
     const projectName = getProjectName(ctx.cwd);
     const projectMemories = projectStorage.listAll();
 
     if (projectMemories.length === 0) {
-      return; // No memories to inject
-    }
-
-    let injection = "\n\n<memory>\n";
-    injection += `Available memories for project "${projectName}":\n\n`;
-
-    // Project memories
-    for (const m of projectMemories) {
-      injection += `- ${m.title}\n`;
+      recallDone = true; // Nothing to recall, skip
+      return;
     }
 
-    injection += "\nUse memory_search to retrieve full content. Use memory_store to save new memories.\n";
-    injection += "Use global_memory_search to search across ALL projects.\n";
-    injection += "</memory>";
+    const titleList = projectMemories.slice(0, 20).map(m => `- ${m.title}`).join("\n");
+    const extra = projectMemories.length > 20 ? `\n... and ${projectMemories.length - 20} more` : "";
 
     return {
-      systemPrompt: event.systemPrompt + injection,
+      message: {
+        customType: "unipi-memory-recall-reminder",
+        content: [
+          "## 🧠 Memory System Active",
+          "",
+          `You have ${projectMemories.length} memories stored for project "${projectName}".`,
+          "**BEFORE starting work**, call `memory_search` with relevant keywords to check for existing context.",
+          "",
+          "Available memories:",
+          titleList + extra,
+          "",
+          "**AFTER completing the task**, if you learned something non-obvious,",
+          "call `memory_store` to save it for future sessions.",
+          "",
+          "Guardrails: read max 10 memory results per search. Update existing memories instead of creating duplicates.",
+        ].join("\n"),
+        display: false,
+      },
     };
   });
 
-  // Auto-consolidation on compaction
-  pi.on("session_before_compact", async (event, ctx) => {
-    const { preparation } = event;
-
-    // Extract summary text
-    const summary = preparation.previousSummary || "";
-
-    if (!summary || summary.length < 100) {
-      // Summary too short to extract memories from
-      return;
-    }
-
-    // For now, just log that consolidation would happen
-    // Future: Use LLM to extract memories
-    console.log("[unipi/memory] Auto-consolidation triggered, summary length:", summary.length);
+  // After each agent response, remind LLM to save if it hasn't yet
+  pi.on("agent_end", async (_event, _ctx) => {
+    if (storeDone || !recallDone) return;
+
+    pi.sendMessage(
+      {
+        customType: "unipi-memory-retro-reminder",
+        content: [
+          "**🧠 Memory reminder:** If you learned something non-obvious in this task,",
+          "call `memory_store` to save it as a memory for future sessions.",
+          "Update existing memories instead of creating duplicates.",
+        ].join(" "),
+        display: false,
+      },
+      {
+        deliverAs: "nextTurn",
+      },
+    );
+  });
 
-    // Don't modify the compaction summary - return unchanged
-    return {};
+  // After compaction, reset recall state so reminder re-injects
+  pi.on("session_compact", async (_event, _ctx) => {
+    recallDone = false;
   });
 
   // Cleanup on shutdown

package/packages/memory/skills/memory/SKILL.md

@@ -9,7 +9,6 @@ allowed-tools:
   - memory_search
   - memory_delete
   - memory_list
-  - global_memory_store
   - global_memory_search
   - global_memory_list
   - read
@@ -87,16 +86,18 @@ memory_list()
 memory_delete(title: "auth_jwt_prefer_refresh_tokens")
 ```
 
-## Project vs Cross-Project Search
+## Search Scope
 
-| Action | Scope | Tools |
-|--------|-------|-------|
+`memory_search` searches ALL projects by default. Use `scope` param to narrow:
+
+| Action | Scope | Tool |
+|--------|-------|------|
 | **Store** | Always project-scoped | `memory_store` |
-| **Search this project** | Current project only | `memory_search` |
-| **Search all projects** | Cross-project | `global_memory_search` |
+| **Search all projects** | Cross-project (default) | `memory_search(query)` or `memory_search(query, scope="all")` |
+| **Search this project** | Current project only | `memory_search(query, scope="project")` |
 | **List all** | Cross-project | `global_memory_list` |
 
-**All memories are project-scoped.** When you store a memory, it belongs to the current project. Use `global_memory_search` to search across ALL projects when looking for past work or user preferences.
+**All memories are project-scoped.** When you store a memory, it belongs to the current project. `memory_search` searches everything by default — no need to call a separate global search.
 
 ## Update-First Principle
 
@@ -108,7 +109,27 @@ memory_delete(title: "auth_jwt_prefer_refresh_tokens")
 
 This prevents memory duplication and keeps memory clean.
 
-## Consolidation
+## Vector Search (Embeddings)
+
+Memory supports vector similarity search via OpenRouter API.
+
+### Setup
+1. Run `/unipi:memory-settings`
+2. Add your OpenRouter API key
+3. Select embedding model (default: `openai/text-embedding-3-small`)
+
+### How it works
+- Embeddings are generated when storing/searching memories
+- Search combines **vector similarity** + **fuzzy text matching** for best results
+- Vector search finds semantically similar memories even without exact keyword matches
+
+### Model compatibility
+⚠ **Different embedding models produce incompatible vectors.**
+If you switch models, existing embeddings won't match new searches.
+Use `/unipi:memory-settings` → "Re-embed All Memories" to fix.
+
+### No API key?
+Falls back to fuzzy text-only search. Still works, just less semantic.
 
 When the user runs `/unipi:memory-consolidate` or during compaction:
 
@@ -149,3 +170,4 @@ You can read these files directly with the `read` tool for full context.
 | Use vague titles | Use specific `<category>_<detail>` format |
 | Store in wrong scope | Project-specific = project scope, universal = global |
 | Forget to update | When context changes, update the memory |
+| Switch embedding models without re-embedding | Re-embed or accept fuzzy-only fallback |

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`);
+    });
+  });
+});