@ilya-lesikov/pi-pi 0.5.0 → 0.6.0

package/extensions/orchestrator/event-handlers.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it, vi, beforeEach } from "vitest";
 import { registerEventHandlers } from "./event-handlers.js";
 import { Orchestrator, type ActiveTask } from "./orchestrator.js";
+import { getDefaultConfig } from "./config.js";
 
 type Handler = (event: any, ctx: any) => any;
 
@@ -25,30 +26,25 @@ function makePi() {
     setSessionName: vi.fn(),
     _handlers: handlers,
     _eventHandlers: eventHandlers,
+    // Drive a synthetic lifecycle/session event by invoking the pi.on-registered
+    // handler (NOT pi.events.emit, which is only for extension/subagent events).
+    emitAgentEnd: (event: any = { type: "agent_end" }, ctx: any = {}) => handlers.get("agent_end")?.(event, ctx),
+    emitSessionCompact: (event: any = { type: "session_compact", fromExtension: true }, ctx: any = {}) =>
+      handlers.get("session_compact")?.(event, ctx),
   };
 }
 
 function makeConfig() {
-  return {
-    mainModel: {
-      implement: { model: "a/b", thinking: "high" },
-      debug: { model: "a/b", thinking: "high" },
-      brainstorm: { model: "a/b", thinking: "high" },
-      review: { model: "a/b", thinking: "high" },
-    },
-    planners: {},
-    planReviewers: {},
-    codeReviewers: {},
-    brainstormReviewers: {},
-    agents: {
-      explore: { model: "x/e", thinking: "low" },
-      librarian: { model: "x/l", thinking: "medium" },
-      task: { model: "x/t", thinking: "medium" },
-    },
-    commands: { afterEdit: [], afterImplement: [] },
-    timeouts: { afterEdit: 1, afterImplement: 1, agentSpawn: 1, agentReadyPing: 1, lockStale: 1, lockUpdate: 1 },
-    autoCommit: false,
-  };
+  const config = getDefaultConfig();
+  config.general.autoCommit = false;
+  config.commands.afterEdit = {};
+  config.commands.afterImplement = {};
+  config.performance.commands.afterEdit = 1;
+  config.performance.commands.afterImplement = 1;
+  config.performance.internals.subagentStale = 1;
+  config.performance.internals.taskLockStale = 1;
+  config.performance.internals.taskLockRefresh = 1;
+  return config;
 }
 
 function makeActiveTask(): ActiveTask {
@@ -153,7 +149,7 @@ describe("tool_result implementation tracking", () => {
       { toolName: "write", input: { path: "src/index.ts" }, isError: false, content: [] },
       {},
     );
-    expect(orchestrator.active.modifiedFiles.has("src/index.ts")).toBe(true);
+    expect(orchestrator.active.modifiedFiles.has("/project/src/index.ts")).toBe(true);
   });
 
   it("skips .pp/ paths in modified-file tracking", async () => {
@@ -186,6 +182,72 @@ describe("tool_result implementation tracking", () => {
       { toolName: "edit", input: { file_path: "src/bar.ts" }, isError: false, content: [] },
       {},
     );
-    expect(orchestrator.active.modifiedFiles.has("src/bar.ts")).toBe(true);
+    expect(orchestrator.active.modifiedFiles.has("/project/src/bar.ts")).toBe(true);
+  });
+});
+
+describe("ask_user ESC aborts the turn", () => {
+  it("aborts the turn when the user cancels (reason 'user')", async () => {
+    const handler = getHandler("tool_result");
+    const ctx = { abort: vi.fn() };
+    await handler(
+      {
+        toolName: "ask_user",
+        input: {},
+        isError: false,
+        content: [{ type: "text", text: "User cancelled the question" }],
+        details: { cancelled: true, response: null, cancelReason: "user" },
+      },
+      ctx,
+    );
+    expect(ctx.abort).toHaveBeenCalledTimes(1);
+  });
+
+  it("does NOT abort on a timeout cancellation", async () => {
+    const handler = getHandler("tool_result");
+    const ctx = { abort: vi.fn() };
+    await handler(
+      {
+        toolName: "ask_user",
+        input: {},
+        isError: false,
+        content: [{ type: "text", text: "User cancelled the question" }],
+        details: { cancelled: true, response: null, cancelReason: "timeout" },
+      },
+      ctx,
+    );
+    expect(ctx.abort).not.toHaveBeenCalled();
+  });
+
+  it("does NOT abort on a programmatic signal cancellation", async () => {
+    const handler = getHandler("tool_result");
+    const ctx = { abort: vi.fn() };
+    await handler(
+      {
+        toolName: "ask_user",
+        input: {},
+        isError: false,
+        content: [{ type: "text", text: "User cancelled the question" }],
+        details: { cancelled: true, response: null, cancelReason: "signal" },
+      },
+      ctx,
+    );
+    expect(ctx.abort).not.toHaveBeenCalled();
+  });
+
+  it("does NOT abort when the user actually answered", async () => {
+    const handler = getHandler("tool_result");
+    const ctx = { abort: vi.fn() };
+    await handler(
+      {
+        toolName: "ask_user",
+        input: {},
+        isError: false,
+        content: [{ type: "text", text: "User answered: Alpha" }],
+        details: { cancelled: false, response: { kind: "selection", selections: ["Alpha"] } },
+      },
+      ctx,
+    );
+    expect(ctx.abort).not.toHaveBeenCalled();
   });
 });