pi-harness-runtime 1.1.440 → 1.1.441

package/packages/notification/test/pending-question.test.ts

@@ -1,331 +0,0 @@
-/**
- * Pending Question Controller Tests
- * 
- * Tests for the pending question detection, state management,
- * and channel delivery logic.
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { 
-  PendingQuestionController,
-  createPendingQuestionController,
-  type QuestionKind,
-} from "../src/pending-question.js";
-
-describe("PendingQuestionController", () => {
-  let controller: PendingQuestionController;
-
-  beforeEach(() => {
-    controller = createPendingQuestionController({
-      evaluationDelayMs: 5 * 60 * 1000,
-      jevEnabled: false,
-    });
-  });
-
-  describe("detectQuestion", () => {
-    it("should detect 'Want me to implement X?' pattern", () => {
-      const result = controller.detectQuestion(
-        "I've finished the toggle implementation. Want me to implement the toggle buttons now?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.questionText).toContain("Want me to implement");
-      expect(result.kind).toBe("approval");
-      expect(result.isRoutine).toBe(false);
-    });
-
-    it("should detect 'Would you like me to add X?' pattern", () => {
-      const result = controller.detectQuestion(
-        "Would you like me to add the persistence layer next?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.questionText).toContain("Would you like me to add");
-      expect(result.kind).toBe("approval");
-    });
-
-    it("should detect 'Shall I start X?' pattern", () => {
-      const result = controller.detectQuestion(
-        "Shall I start with the database schema?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.kind).toBe("approval");
-    });
-
-    it("should detect 'Should I implement X?' pattern", () => {
-      const result = controller.detectQuestion(
-        "Should I implement the SQLite persistence now?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.kind).toBe("approval");
-    });
-
-    it("should detect question ending with ? with request + intent words", () => {
-      const result = controller.detectQuestion(
-        "Should I continue with the next task?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.kind).toBe("routine");
-      expect(result.isRoutine).toBe(true);
-    });
-
-    it("should detect 'Should I continue?' as routine", () => {
-      const result = controller.detectQuestion("Should I continue?");
-      expect(result.detected).toBe(true);
-      expect(result.isRoutine).toBe(true);
-    });
-
-    it("should NOT detect quoted questions", () => {
-      const result = controller.detectQuestion(
-        `Here's an example: "Want me to implement this?" - that's what I might ask.`
-      );
-      // The quoted question should not be detected
-      expect(result.detected).toBe(false);
-    });
-
-    it("should NOT detect rhetorical questions in code blocks", () => {
-      const result = controller.detectQuestion(
-        `\`\`\`\n// Want me to implement this?\n\`\`\`\nThe code above shows what we need.`
-      );
-      expect(result.detected).toBe(false);
-    });
-
-    it("should detect clarification questions", () => {
-      const result = controller.detectQuestion(
-        "Do you mean the SQLite or the file-based approach?"
-      );
-      expect(result.detected).toBe(true);
-      expect(result.kind).toBe("clarification");
-    });
-
-    it("should NOT detect plain progress statements", () => {
-      const result = controller.detectQuestion(
-        "I've implemented the toggle buttons and they work correctly."
-      );
-      expect(result.detected).toBe(false);
-    });
-
-    it("should detect 'Can I proceed?' as routine", () => {
-      const result = controller.detectQuestion("Can I proceed with the next step?");
-      expect(result.detected).toBe(true);
-      expect(result.isRoutine).toBe(true);
-    });
-  });
-
-  describe("question lifecycle", () => {
-    it("should create and track a pending question", () => {
-      const question = controller.createQuestion({
-        text: "Want me to implement the toggle buttons now?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      expect(question.requestId).toBeDefined();
-      expect(question.state).toBe("pending");
-      expect(question.kind).toBe("approval");
-      expect(controller.hasPendingQuestion()).toBe(true);
-      expect(controller.getCurrentQuestion()).toEqual(question);
-    });
-
-    it("should resolve a question with 'yes'", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.resolve({ resolution: "yes", by: "user" });
-
-      expect(controller.isResolved()).toBe(true);
-      expect(controller.getResolution()).toBe("yes");
-      expect(controller.getCurrentQuestion()?.state).toBe("resolved");
-      expect(controller.getCurrentQuestion()?.resolvedBy).toBe("user");
-    });
-
-    it("should resolve a question with 'no'", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.resolve({ resolution: "no", by: "user" });
-
-      expect(controller.getResolution()).toBe("no");
-    });
-
-    it("should cancel a question", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.cancel("Session switched");
-
-      expect(controller.hasPendingQuestion()).toBe(false);
-      expect(controller.getCurrentQuestion()).toBe(null);
-    });
-
-    it("should start evaluation", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.startEvaluation();
-
-      expect(controller.getCurrentQuestion()?.state).toBe("evaluating");
-    });
-  });
-
-  describe("channel delivery state", () => {
-    it("should update Telegram delivery state", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.updateDeliveryState("telegram", true);
-      
-      const question = controller.getCurrentQuestion();
-      expect(question?.deliveryState.telegram?.delivered).toBe(true);
-      expect(question?.deliveryState.telegram?.deliveredAt).toBeDefined();
-      expect(question?.userNotified).toBe(true);
-    });
-
-    it("should update LINE delivery state", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.updateDeliveryState("line", true);
-      
-      const question = controller.getCurrentQuestion();
-      expect(question?.deliveryState.line?.delivered).toBe(true);
-    });
-
-    it("should track delivery errors", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.updateDeliveryState("telegram", false, "Network error");
-      
-      const question = controller.getCurrentQuestion();
-      expect(question?.deliveryState.telegram?.delivered).toBe(false);
-      expect(question?.deliveryState.telegram?.error).toBe("Network error");
-    });
-  });
-
-  describe("suppress completion", () => {
-    it("should suppress completion when pending question exists", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      expect(controller.shouldSuppressCompletion()).toBe(true);
-    });
-
-    it("should NOT suppress completion when no pending question", () => {
-      expect(controller.shouldSuppressCompletion()).toBe(false);
-    });
-
-    it("should NOT suppress completion when question is resolved", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.resolve({ resolution: "yes", by: "user" });
-
-      expect(controller.shouldSuppressCompletion()).toBe(false);
-    });
-  });
-
-  describe("callbacks", () => {
-    it("should call user answer callback on resolution", () => {
-      let callbackCalled = false;
-      let callbackResolution = "";
-      
-      controller.onUserAnswer((question, answer) => {
-        callbackCalled = true;
-        callbackResolution = answer;
-      });
-
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.resolve({ resolution: "yes", by: "user" });
-
-      expect(callbackCalled).toBe(true);
-      expect(callbackResolution).toBe("yes");
-    });
-  });
-
-  describe("cleanup", () => {
-    it("should clean up old resolved questions", () => {
-      controller.createQuestion({
-        text: "Want me to implement X?",
-        sessionId: "test-session",
-        workspacePath: "/test",
-        kind: "approval",
-      });
-
-      controller.resolve({ resolution: "yes", by: "user" });
-
-      // Wait a tiny bit then cleanup with 0ms max age
-      setTimeout(() => {
-        controller.cleanup(0);
-        const questions = controller.getAllQuestions();
-        expect(questions.length).toBe(0);
-      }, 10);
-    });
-  });
-});
-
-describe("Question detection edge cases", () => {
-  let controller: PendingQuestionController;
-
-  beforeEach(() => {
-    controller = createPendingQuestionController();
-  });
-
-  it("should handle multiple questions in one message", () => {
-    const result = controller.detectQuestion(
-      "I've finished task 1. Want me to implement the toggle buttons now? Should I continue with the next task?"
-    );
-    // Should detect the approval question, not the routine continuation
-    expect(result.detected).toBe(true);
-    expect(result.kind).toBe("approval");
-  });
-
-  it("should handle mixed content with questions", () => {
-    const result = controller.detectQuestion(
-      `Here's what I did:\n1. Implemented toggle state\n2. Added persistence\n\nWant me to continue with the UI?`
-    );
-    expect(result.detected).toBe(true);
-    expect(result.kind).toBe("approval");
-  });
-});

package/packages/notification/test/tooling-proposal-payload.test.ts

@@ -1,212 +0,0 @@
-/**
- * Tooling proposal payload tests.
- *
- * The proposal (Biome.js instead of ESLint/Prettier) is a decision of its
- * own. Its buttons carry the tooling action, never the approval action:
- * a "No" on a proposal must not pause the work, and a "Yes" must not
- * resume a pending question.
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { NotificationCenter } from "../src/notification-center.js";
-import { parseCallbackData } from "../src/telegram-webhook-handler.js";
-import type { NotificationConfig } from "../src/types.js";
-
-const PROPOSAL =
-	"This workspace looks like a Next.js + React project that still uses ESLint and Prettier. " +
-	"Biome.js can replace both: one tool for linting, formatting and import order.";
-
-interface CapturedRequest {
-	url: string;
-	body: Record<string, any>;
-}
-
-let captured: CapturedRequest[] = [];
-let originalFetch: typeof globalThis.fetch;
-
-function createCenter(): NotificationCenter {
-	const config: NotificationConfig = {
-		channels: [
-			{
-				id: "telegram",
-				type: "telegram",
-				enabled: true,
-				config: {
-					botToken: "test-bot-token",
-					chatId: "12345",
-					enableInlineKeyboard: true,
-				},
-			},
-			{
-				id: "line",
-				type: "line",
-				enabled: true,
-				config: { channelAccessToken: "test-line-token", userId: "U-test" },
-			},
-		],
-	};
-	return new NotificationCenter(config);
-}
-
-function lineRequests(): CapturedRequest[] {
-	return captured.filter((r) => r.url.includes("api.line.me"));
-}
-
-/**
- * Capture the payload the Telegram adapter is asked to send.
- *
- * The adapter is replaced instead of the network, so the test does not
- * depend on which adapter implementation is loaded.
- */
-function captureTelegramPayload(center: NotificationCenter): {
-	payloads: Array<Record<string, any>>;
-} {
-	const payloads: Array<Record<string, any>> = [];
-	const adapter = center.getTelegramAdapter();
-	if (adapter) {
-		adapter.send = (async (payload: any) => {
-			payloads.push(payload);
-			return { success: true, channel: "telegram" };
-		}) as typeof adapter.send;
-	}
-	return { payloads };
-}
-
-async function sendProposal(center: NotificationCenter): Promise<void> {
-	await center.notifyWithButtons(
-		"ToolingPreferenceProposal",
-		{
-			jobId: "biome-abc123",
-			questionId: "biome-abc123",
-			requirement: PROPOSAL,
-			taskTitle: "Tooling proposal",
-		},
-		[
-			{ text: "Yes - use Biome.js", action: "biome", targetId: "yes-biome-abc123" },
-			{ text: "No - keep the current tools", action: "biome", targetId: "no-biome-abc123" },
-		],
-		{
-			additionalDetails: { _actionPrompt: "Use Biome.js in this workspace?" },
-		},
-	);
-}
-
-beforeEach(() => {
-	captured = [];
-	originalFetch = globalThis.fetch;
-	globalThis.fetch = (async (input: any, init?: any) => {
-		const url = typeof input === "string" ? input : (input?.url ?? "");
-		let body: any = {};
-		try {
-			body = JSON.parse(init?.body ?? "{}");
-		} catch {
-			body = {};
-		}
-		captured.push({ url, body });
-
-		if (url.includes("typesafe.ai")) {
-			return new Response("unauthorized", { status: 401 });
-		}
-		return new Response(JSON.stringify({ ok: true, result: {} }), {
-			status: 200,
-			headers: { "Content-Type": "application/json" },
-		});
-	}) as typeof globalThis.fetch;
-});
-
-afterEach(() => {
-	globalThis.fetch = originalFetch;
-});
-
-describe("the tooling proposal payload", () => {
-	it("sends the proposal to Telegram with two buttons of the tooling action", async () => {
-		const center = createCenter();
-		const { payloads } = captureTelegramPayload(center);
-
-		await sendProposal(center);
-
-		const payload = payloads[0];
-		expect(payload).toBeDefined();
-
-		const buttons = payload.details._actionButtons as Array<{
-			callbackData: string;
-		}>;
-		expect(buttons).toHaveLength(2);
-
-		const parsedYes = parseCallbackData(buttons[0].callbackData);
-		const parsedNo = parseCallbackData(buttons[1].callbackData);
-
-		expect(parsedYes.action).toBe("biome");
-		expect(parsedNo.action).toBe("biome");
-		expect(parsedYes.targetId).toBe("yes-biome-abc123");
-		expect(parsedNo.targetId).toBe("no-biome-abc123");
-	});
-
-	it("never uses the approval action for a proposal button", async () => {
-		const center = createCenter();
-		const { payloads } = captureTelegramPayload(center);
-
-		await sendProposal(center);
-
-		const buttons = payloads[0].details._actionButtons as Array<{
-			callbackData: string;
-		}>;
-
-		for (const button of buttons) {
-			const parsed = parseCallbackData(button.callbackData);
-			expect(parsed.action).not.toBe("approve");
-			expect(parsed.action).not.toBe("reject");
-		}
-	});
-
-	it("sends the same buttons to LINE", async () => {
-		await sendProposal(createCenter());
-
-		const line = lineRequests()[0];
-		const messages = line?.body?.messages ?? [];
-		const template = messages.find((m: any) => m.type === "template");
-		expect(template).toBeDefined();
-
-		const actions = template.template.actions ?? [];
-		expect(actions).toHaveLength(2);
-		expect(actions[0].data).toBe("biome_yes-biome-abc123");
-		expect(actions[1].data).toBe("biome_no-biome-abc123");
-	});
-
-	it("shows the wording of the proposal on LINE", async () => {
-		await sendProposal(createCenter());
-
-		const line = lineRequests()[0];
-		const messages = line?.body?.messages ?? [];
-		const template = messages.find((m: any) => m.type === "template");
-
-		expect(String(template.template.title)).toContain("Biome.js");
-		expect(String(template.altText)).toContain("Biome.js");
-	});
-
-	it("sends the complete proposal to the user", async () => {
-		const center = createCenter();
-		const { payloads } = captureTelegramPayload(center);
-
-		await sendProposal(center);
-
-		const payload = payloads[0];
-		expect(String(payload.message)).toContain("Biome.js");
-		expect(String(payload.message)).toContain("ESLint");
-		expect(String(payload.message)).toContain("Prettier");
-		expect(String(payload.message)).not.toContain("...");
-	});
-
-	it("never sends the proposal to a channel the user turned off", async () => {
-		const center = createCenter();
-		center.setChannelEnabled("telegram", false);
-		const { payloads } = captureTelegramPayload(center);
-
-		await sendProposal(center);
-
-		// The button of a channel that stays silent could never be answered.
-		expect(payloads).toHaveLength(0);
-		// The other channel still receives the proposal.
-		expect(lineRequests().length).toBeGreaterThan(0);
-	});
-});