pi-harness-runtime 0.9.4 → 0.9.6

package/packages/worktree/test/worktree.test.ts

@@ -0,0 +1,163 @@
+/**
+ * Worktree Manager Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from "bun:test";
+import { WorktreeManager } from "../src/worktree.js";
+
+// Mock Node.js modules at module level
+const mockExecSync = vi.fn().mockReturnValue("/mocked/path/worktrees/test-wt");
+const mockExistsSync = vi.fn().mockReturnValue(false);
+const mockMkdirSync = vi.fn();
+const mockWriteFileSync = vi.fn();
+const mockReadFileSync = vi.fn().mockReturnValue("[]");
+
+vi.mock("node:child_process", () => ({
+	execSync: mockExecSync,
+}));
+
+vi.mock("node:fs", () => ({
+	existsSync: mockExistsSync,
+	mkdirSync: mockMkdirSync,
+	writeFileSync: mockWriteFileSync,
+	readFileSync: mockReadFileSync,
+}));
+
+describe("WorktreeManager", () => {
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockExecSync.mockReturnValue("/mocked/path/worktrees/test-wt");
+		mockExistsSync.mockReturnValue(false);
+		mockReadFileSync.mockReturnValue("[]");
+	});
+
+	describe("constructor", () => {
+		it("creates instance with rootDir", () => {
+			const manager = new WorktreeManager({
+				rootDir: "/tmp/test-repo",
+				baseBranch: "main",
+			});
+			expect(manager).toBeDefined();
+		});
+	});
+
+	describe("create", () => {
+		it("creates a worktree with name", async () => {
+			const manager = new WorktreeManager({
+				rootDir: "/tmp/test-repo",
+				baseBranch: "main",
+			});
+			const result = await manager.create({ name: "test-wt" });
+			expect(result.name).toBe("test-wt");
+			expect(result.branch).toBe("worktree/test-wt");
+			expect(result.status).toBe("active");
+		});
+
+		it("sanitizes name", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.create({ name: "my worktree!" });
+			expect(result.name).toBe("my-worktree-");
+		});
+
+		it("uses custom branch if provided", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.create({
+				name: "my-wt",
+				branch: "feature/my-branch",
+			});
+			expect(result.branch).toBe("feature/my-branch");
+		});
+
+		it("stores jobId and taskId", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.create({
+				name: "job-wt",
+				jobId: "job-123",
+				taskId: "task-456",
+			});
+			expect(result.jobId).toBe("job-123");
+			expect(result.taskId).toBe("task-456");
+		});
+
+		it("sets createdAt timestamp", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const before = Date.now();
+			const result = await manager.create({ name: "time-wt" });
+			const after = Date.now();
+			const created = Date.parse(result.createdAt);
+			expect(created >= before && created <= after).toBe(true);
+		});
+	});
+
+	describe("list", () => {
+		it("returns empty array when no worktrees", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.list();
+			expect(result).toEqual([]);
+		});
+	});
+
+	describe("get", () => {
+		it("returns null for unknown worktree", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.get("nonexistent");
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("getByJob", () => {
+		it("returns null when no worktree for job", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			const result = await manager.getByJob("unknown-job");
+			expect(result).toBeNull();
+		});
+	});
+
+	describe("remove", () => {
+		it("throws for unknown worktree", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			await expect(manager.remove("nonexistent")).rejects.toThrow();
+		});
+	});
+
+	describe("prune", () => {
+		it("returns pruned worktrees", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			mockExecSync.mockReturnValue("worktree /mocked/path/worktrees/test-wt");
+			const result = await manager.prune();
+			expect(Array.isArray(result)).toBe(true);
+		});
+	});
+
+	describe("getUncommitted", () => {
+		it("parses numstat output", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			mockExecSync.mockReturnValue("10\t5\tfile.ts\n20\t0\tnew.ts\n");
+
+			const diffs = await manager.getUncommitted(
+				"/mocked/path/worktrees/test-wt",
+			);
+			expect(diffs.length).toBe(2);
+			expect(diffs[0].file).toBe("file.ts");
+			expect(diffs[0].insertions).toBe(10);
+			expect(diffs[0].deletions).toBe(5);
+		});
+	});
+
+	describe("markMerged", () => {
+		it("marks worktree as merged", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			await manager.create({ name: "merge-wt" });
+			await manager.markMerged("merge-wt");
+			// Should not throw
+		});
+	});
+
+	describe("metadata persistence", () => {
+		it("saves worktree to .worktrees.json", async () => {
+			const manager = new WorktreeManager({ rootDir: "/tmp/test-repo" });
+			await manager.create({ name: "persist-wt" });
+			expect(mockWriteFileSync).toHaveBeenCalled();
+		});
+	});
+});

package/packages/worktree/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"]
+}

package/proactive-compact.ts

@@ -1,15 +1,90 @@
 import type { ContextUsage } from "@earendil-works/pi-coding-agent";
 
 export const PROACTIVE_COMPACT_THRESHOLD = 0.9;
+export const PROACTIVE_COMPACT_HEADROOM_TOKENS = 15_000;
 export const PROACTIVE_COMPACT_COOLDOWN_MS = 10 * 60 * 1000;
+export const MAX_PROACTIVE_COMPACT_FAILURES = 3;
+export const OUTPUT_LIMIT_AUTO_RESUME_LIMIT = 3;
+export const OUTPUT_LIMIT_RESUME_PROMPT =
+	"Output token limit hit. Resume directly — no apology, no recap. Pick up mid-thought if the cut happened there. Break remaining work into smaller pieces.";
 
 export function shouldTriggerProactiveCompact(
 	usage: ContextUsage | undefined,
-	options?: { threshold?: number },
+	options?: { threshold?: number; headroomTokens?: number },
 ): boolean {
+	if (!usage) {
+		return false;
+	}
+
+	const headroomTokens =
+		options?.headroomTokens ?? PROACTIVE_COMPACT_HEADROOM_TOKENS;
+	if (
+		usage.tokens !== null &&
+		usage.contextWindow - usage.tokens <= headroomTokens
+	) {
+		return true;
+	}
+
 	const threshold = options?.threshold ?? PROACTIVE_COMPACT_THRESHOLD;
-	if (!usage || usage.percent === null) {
+	return usage.percent !== null && usage.percent >= threshold;
+}
+
+export type AssistantStopLike = {
+	role?: string;
+	stopReason?: unknown;
+	errorMessage?: unknown;
+};
+
+export function isOutputLimitAssistantMessage(
+	message: AssistantStopLike,
+): boolean {
+	if (message.role !== "assistant") {
 		return false;
 	}
-	return usage.percent >= threshold;
+
+	if (
+		message.stopReason === "length" ||
+		message.stopReason === "max_output_tokens" ||
+		message.stopReason === "max_tokens"
+	) {
+		return true;
+	}
+
+	return (
+		typeof message.errorMessage === "string" &&
+		/reached the maximum output token limit|maximum output token limit|output token limit/i.test(
+			message.errorMessage,
+		)
+	);
+}
+
+export function shouldQueueOutputLimitResume(
+	message: AssistantStopLike,
+	resumeAttempts: number,
+	hasPendingMessages: boolean,
+	options?: { maxAttempts?: number },
+): boolean {
+	const maxAttempts = options?.maxAttempts ?? OUTPUT_LIMIT_AUTO_RESUME_LIMIT;
+	return (
+		isOutputLimitAssistantMessage(message) &&
+		resumeAttempts < maxAttempts &&
+		!hasPendingMessages
+	);
+}
+
+export function shouldQueuePostCompactionResume(
+	event: {
+		willRetry?: boolean;
+		reason?: "manual" | "threshold" | "overflow" | string;
+	},
+	hasPendingMessages: boolean,
+	options?: { force?: boolean },
+): boolean {
+	if (event.reason === "manual" && options?.force !== true) {
+		return false;
+	}
+
+	return (
+		(options?.force === true || event.willRetry !== true) && !hasPendingMessages
+	);
 }