pi-harness-runtime 1.1.440 → 1.1.441

package/packages/doc-generator/test/docs.test.ts

@@ -1,168 +0,0 @@
-/**
- * Doc Generator Tests (RFC-0014)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	detectProjectType,
-	parseSignals,
-	detectSymbols,
-	generateDocs,
-} from "../src/index.js";
-import type { SourceFile } from "../src/index.js";
-
-const src = (content: string, path = "src/utils.ts"): SourceFile => ({
-	path,
-	content,
-	language: "typescript",
-});
-
-describe("detectProjectType", () => {
-	it("detects Frappe/ERPNext", () => {
-		const signals = ["frappe-bench/apps/myapp/hooks.py", "doctype/CRM"];
-		const result = detectProjectType(signals);
-		expect(result.projectType).toBe("frappe_erpnext");
-		expect(result.signals).toContain("frappe-bench/apps/myapp/hooks.py");
-	});
-
-	it("detects Next.js", () => {
-		const signals = ["next.config.js", "app/layout.tsx", "pages/index.ts"];
-		const result = detectProjectType(signals);
-		expect(result.projectType).toBe("nextjs");
-	});
-
-	it("detects React/Vite", () => {
-		const signals = ["vite.config.ts", "src/main.tsx", "index.html"];
-		const result = detectProjectType(signals);
-		expect(result.projectType).toBe("react_vite");
-	});
-
-	it("detects Django", () => {
-		const signals = ["manage.py", "settings.py"];
-		const result = detectProjectType(signals);
-		expect(result.projectType).toBe("django");
-	});
-
-	it("detects Laravel", () => {
-		const signals = ["artisan", "database/seeders/UserSeeder.php"];
-		const result = detectProjectType(signals);
-		expect(result.projectType).toBe("laravel");
-	});
-
-	it("returns unknown for empty signals", () => {
-		const result = detectProjectType([]);
-		expect(result.projectType).toBe("unknown");
-		expect(result.confidence).toBe(0);
-	});
-
-	it("returns generic_web for package.json", () => {
-		const result = detectProjectType(["package.json", "index.js"]);
-		expect(result.projectType).toBe("generic_web");
-	});
-
-	it("includes recommended seed strategy", () => {
-		const result = detectProjectType(["manage.py"]);
-		expect(result.recommendedSeedStrategy).toBe("django_migrations");
-	});
-
-	it("includes recommended e2e strategy", () => {
-		const result = detectProjectType(["next.config.js"]);
-		expect(result.recommendedE2EStrategy).toBe("nextjs_dev_server_flow");
-	});
-
-	it("confidence is 0-1", () => {
-		const result = detectProjectType(["doctype/CRM"]);
-		expect(result.confidence).toBeGreaterThanOrEqual(0);
-		expect(result.confidence).toBeLessThanOrEqual(1);
-	});
-});
-
-describe("parseSignals", () => {
-	it("filters paths with dots or slashes", () => {
-		const entries = ["frappe-bench", "doctype", "README.md", "apps/main.py"];
-		const signals = parseSignals(entries);
-		expect(signals).toContain("README.md");
-		expect(signals).toContain("apps/main.py");
-		expect(signals).not.toContain("doctype");
-	});
-});
-
-describe("detectSymbols", () => {
-	it("detects function declarations", () => {
-		const s = src(
-			"export function add(a: number, b: number): number { return a + b; }",
-		);
-		const symbols = detectSymbols(s);
-		const fn = symbols.find((sym) => sym.kind === "function");
-		expect(fn).toBeDefined();
-		expect(fn!.name).toBe("add");
-		expect(fn!.signature).toContain("add");
-	});
-
-	it("detects async functions", () => {
-		const s = src("async function fetchData(): Promise<string> { return ''; }");
-		const symbols = detectSymbols(s);
-		expect(symbols.some((sym) => sym.kind === "function")).toBe(true);
-	});
-
-	it("detects class declarations", () => {
-		const s = src("export class UserService { }");
-		const symbols = detectSymbols(s);
-		expect(symbols.some((sym) => sym.kind === "class")).toBe(true);
-	});
-
-	it("detects interface declarations", () => {
-		const s = src("export interface Config { port: number; }");
-		const symbols = detectSymbols(s);
-		expect(symbols.some((sym) => sym.kind === "interface")).toBe(true);
-	});
-
-	it("detects type aliases", () => {
-		const s = src("export type ID = string | number;");
-		const symbols = detectSymbols(s);
-		expect(symbols.some((sym) => sym.kind === "type")).toBe(true);
-	});
-
-	it("detects const exports", () => {
-		const s = src("export const MAX_RETRIES = 3;");
-		const symbols = detectSymbols(s);
-		expect(symbols.some((sym) => sym.kind === "constant")).toBe(true);
-	});
-
-	it("includes file and line number", () => {
-		const s = src("function a() {}\nfunction b() {}");
-		const symbols = detectSymbols(s);
-		const b = symbols.find((sym) => sym.name === "b");
-		expect(b!.line).toBe(2);
-	});
-});
-
-describe("generateDocs", () => {
-	it("generates overview section", () => {
-		const sources = [
-			src("export function hello() {}", "src/a.ts"),
-			src("export type Config = {}", "src/b.ts"),
-		];
-		const docs = generateDocs(sources, ["next.config.js"]);
-		expect(docs.sections.some((s) => s.heading === "Overview")).toBe(true);
-		expect(docs.sections.some((s) => s.heading === "Functions")).toBe(true);
-	});
-
-	it("sets project type from signals", () => {
-		const docs = generateDocs([], ["vite.config.ts", "src/main.tsx"]);
-		expect(docs.projectType).toBe("react_vite");
-	});
-
-	it("lists exported symbols", () => {
-		const sources = [src("export function fn() {}")];
-		const docs = generateDocs(sources, []);
-		expect(docs.symbols.length).toBeGreaterThan(0);
-	});
-
-	it("includes exported functions in sections", () => {
-		const sources = [src("export function publicFn() {}")];
-		const docs = generateDocs(sources, []);
-		const fnSection = docs.sections.find((s) => s.heading === "Functions");
-		expect(fnSection!.content).toContain("publicFn");
-	});
-});

package/packages/durable-review/test/acceptance.test.ts

@@ -1,357 +0,0 @@
-/// <reference types="node" />
-/**
- * Durable Review Acceptance Tests
- *
- * Tests per wiki/pi-durable-reviewer-minimax-plan.md acceptance criteria.
- */
-
-import { describe, it, before, after, mock } from "node:test";
-import assert from "node:assert";
-import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, unlinkSync, rmdirSync, writeFileSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { validateAndHashRequest, hashWorkspaceKey, getWorkspaceDir } from "../dist/service.js";
-import { validateReviewRequest } from "../dist/types.js";
-import {
-  tryAcquireOwnership,
-  releaseOwnership,
-  startWorker,
-  stopWorker,
-  checkWorkerReady,
-} from "../dist/worker.js";
-import { handleReviewRequest, cancelJob, getJobStatus } from "../dist/worker.js";
-
-// Test workspace path
-const TEST_WORKSPACE = "/tmp/durable-review-test-" + Date.now();
-const TEST_DB_DIR = join(process.env.HOME || "/tmp", ".pi-harness-runtime", "durable");
-
-/**
- * The storage of the worker is SQLite, which needs `node:sqlite`.
- *
- * Node has that module, Bun does not. Without it the worker cannot start, so
- * the tests that need a running worker are skipped with a reason instead of
- * failing with a module error.
- */
-const sqliteAvailable = await (async () => {
-  try {
-    await import("node:sqlite");
-    return true;
-  } catch {
-    return false;
-  }
-})();
-
-const SKIP_WITHOUT_SQLITE = sqliteAvailable
-  ? false
-  : "node:sqlite is not available in this runtime";
-const describeWorker = sqliteAvailable ? describe : describe.skip;
-
-describe("Acceptance Tests", () => {
-  // Setup
-  before(() => {
-    mkdirSync(TEST_WORKSPACE, { recursive: true });
-  });
-
-  after(() => {
-    // Cleanup test workspace
-    try {
-      const workspaceKey = hashWorkspaceKey(TEST_WORKSPACE);
-      const testDir = getWorkspaceDir(workspaceKey);
-      const lockPath = join(testDir, ".worker.lock");
-      if (existsSync(lockPath)) unlinkSync(lockPath);
-    } catch {
-      // ignore cleanup errors
-    }
-  });
-
-  // --- Feature Disabled ---
-  describe("Feature disabled", () => {
-    it("validateReviewRequest works without HARNESS_DURABLE_REVIEW flag", () => {
-      const request = {
-        requestId: "test-1",
-        input: { workspacePath: TEST_WORKSPACE },
-      };
-      const validation = validateReviewRequest(request);
-      assert.strictEqual(validation.valid, true);
-    });
-  });
-
-  // --- Duplicate Admission ---
-  describe("Duplicate admission", () => {
-    it("same request returns same input hash", () => {
-      const request1 = {
-        requestId: "test-dup",
-        input: { workspacePath: TEST_WORKSPACE, diff: "test diff" },
-      };
-      const request2 = {
-        requestId: "test-dup",
-        input: { workspacePath: TEST_WORKSPACE, diff: "test diff" },
-      };
-
-      const val1 = validateAndHashRequest(request1);
-      const val2 = validateAndHashRequest(request2);
-
-      assert.strictEqual(val1.valid, true);
-      assert.strictEqual(val2.valid, true);
-      assert.strictEqual(val1.inputHash, val2.inputHash);
-    });
-
-    it("different input returns different hash", () => {
-      const request1 = {
-        requestId: "test-1",
-        input: { workspacePath: TEST_WORKSPACE, diff: "diff 1" },
-      };
-      const request2 = {
-        requestId: "test-2",
-        input: { workspacePath: TEST_WORKSPACE, diff: "diff 2" },
-      };
-
-      const val1 = validateAndHashRequest(request1);
-      const val2 = validateAndHashRequest(request2);
-
-      assert.strictEqual(val1.valid, true);
-      assert.strictEqual(val2.valid, true);
-      assert.notStrictEqual(val1.inputHash, val2.inputHash);
-    });
-  });
-
-  // --- Ownership ---
-  describe("Ownership race", () => {
-    it("first worker acquires ownership", async () => {
-      const workspaceKey = hashWorkspaceKey(TEST_WORKSPACE);
-      const workerId1 = "worker-1-" + randomUUID().slice(0, 8);
-
-      const result = await tryAcquireOwnership(workspaceKey, workerId1);
-      assert.strictEqual(result.acquired, true);
-
-      // Cleanup
-      await releaseOwnership(workspaceKey, workerId1);
-    });
-
-    it("second worker cannot acquire if first holds lock", async () => {
-      const workspaceKey = hashWorkspaceKey(TEST_WORKSPACE);
-      const workerId1 = "worker-1-" + randomUUID().slice(0, 8);
-      const workerId2 = "worker-2-" + randomUUID().slice(0, 8);
-
-      // First acquires
-      const result1 = await tryAcquireOwnership(workspaceKey, workerId1);
-      assert.strictEqual(result1.acquired, true);
-
-      // Second should fail
-      const result2 = await tryAcquireOwnership(workspaceKey, workerId2);
-      assert.strictEqual(result2.acquired, false);
-      assert.ok(result2.existingOwner);
-
-      // Cleanup
-      await releaseOwnership(workspaceKey, workerId1);
-    });
-
-    it("stale owner is recoverable", async () => {
-      const workspaceKey = hashWorkspaceKey(TEST_WORKSPACE);
-      const workerId1 = "stale-worker-" + randomUUID().slice(0, 8);
-      const workerId2 = "new-worker-" + randomUUID().slice(0, 8);
-
-      // First acquires
-      const result1 = await tryAcquireOwnership(workspaceKey, workerId1);
-      assert.strictEqual(result1.acquired, true);
-
-      // Simulate stale lock by directly writing old timestamp
-      const lockPath = join(getWorkspaceDir(workspaceKey), ".worker.lock");
-      const staleLock = {
-        workerId: workerId1,
-        pid: 99999,
-        startedAt: Date.now() - 120_000, // 2 minutes ago
-      };
-      writeFileSync(lockPath, JSON.stringify(staleLock));
-
-      // New worker should be able to acquire
-      const result2 = await tryAcquireOwnership(workspaceKey, workerId2);
-      assert.strictEqual(result2.acquired, true);
-
-      // Cleanup
-      await releaseOwnership(workspaceKey, workerId2);
-    });
-  });
-
-  // --- Worker Lifecycle ---
-  describeWorker("Worker lifecycle", () => {
-    it("startWorker succeeds", async () => {
-      const result = await startWorker(TEST_WORKSPACE);
-      assert.strictEqual(result.success, true);
-      assert.ok(result.workerId);
-      assert.ok(result.workspaceKey);
-    });
-
-    it("checkWorkerReady returns ready", async () => {
-      const ready = await checkWorkerReady();
-      assert.strictEqual(ready.ready, true);
-      assert.ok(ready.workerId);
-    });
-
-    it("stopWorker succeeds", async () => {
-      await stopWorker();
-      const ready = await checkWorkerReady();
-      assert.strictEqual(ready.ready, false);
-    });
-  });
-
-  // --- Request Handling ---
-  describeWorker("Request handling", () => {
-    before(async () => {
-      await startWorker(TEST_WORKSPACE);
-    });
-
-    after(async () => {
-      await stopWorker();
-    });
-
-    it("handleReviewRequest creates job", async () => {
-      const request = {
-        requestId: "test-review-" + randomUUID().slice(0, 8),
-        input: { workspacePath: TEST_WORKSPACE },
-      };
-
-      const result = await handleReviewRequest(request);
-      assert.ok(result.jobId);
-      assert.strictEqual(result.status.status, "queued");
-    });
-
-    it("handleReviewRequest rejects invalid request", async () => {
-      const invalidRequest = {
-        requestId: "",
-        input: { workspacePath: TEST_WORKSPACE },
-      };
-
-      await assert.rejects(
-        async () => handleReviewRequest(invalidRequest as any),
-        /requestId is required/
-      );
-    });
-
-    it("getJobStatus returns null for unknown job", async () => {
-      const status = await getJobStatus("unknown-job-id");
-      assert.strictEqual(status, null);
-    });
-
-    it("cancelJob returns false for unknown job", async () => {
-      const cancelled = await cancelJob("unknown-job-id");
-      assert.strictEqual(cancelled, false);
-    });
-  });
-
-  // --- Input Stability ---
-  describe("Input stability", () => {
-    it("validateAndHashRequest produces stable hash", () => {
-      const request = {
-        requestId: "test-hash",
-        input: { workspacePath: TEST_WORKSPACE, diff: "stable diff content" },
-      };
-
-      const result1 = validateAndHashRequest(request);
-      const result2 = validateAndHashRequest(request);
-
-      assert.strictEqual(result1.inputHash, result2.inputHash);
-    });
-
-    it("different content produces different hash", () => {
-      const request1 = {
-        requestId: "test",
-        input: { workspacePath: TEST_WORKSPACE, diff: "content A" },
-      };
-      const request2 = {
-        requestId: "test",
-        input: { workspacePath: TEST_WORKSPACE, diff: "content B" },
-      };
-
-      const result1 = validateAndHashRequest(request1);
-      const result2 = validateAndHashRequest(request2);
-
-      assert.notStrictEqual(result1.inputHash, result2.inputHash);
-    });
-  });
-
-  // --- Workspace Path ---
-  describe("Workspace path handling", () => {
-    it("hashWorkspaceKey produces consistent hash", () => {
-      const hash1 = hashWorkspaceKey("/some/path");
-      const hash2 = hashWorkspaceKey("/some/path");
-      assert.strictEqual(hash1, hash2);
-    });
-
-    it("different paths produce different hashes", () => {
-      const hash1 = hashWorkspaceKey("/path/a");
-      const hash2 = hashWorkspaceKey("/path/b");
-      assert.notStrictEqual(hash1, hash2);
-    });
-
-    it("getWorkspaceDir creates directory", () => {
-      const workspaceKey = hashWorkspaceKey(TEST_WORKSPACE);
-      const dir = getWorkspaceDir(workspaceKey);
-      assert.ok(existsSync(dir));
-    });
-  });
-
-  // --- Validation ---
-  describe("Request validation", () => {
-    it("rejects missing requestId", () => {
-      const result = validateReviewRequest({
-        requestId: "",
-        input: { workspacePath: TEST_WORKSPACE },
-      });
-      assert.strictEqual(result.valid, false);
-      assert.ok(result.error?.includes("requestId"));
-    });
-
-    it("rejects missing workspacePath", () => {
-      const result = validateReviewRequest({
-        requestId: "test",
-        input: { workspacePath: "" },
-      });
-      assert.strictEqual(result.valid, false);
-      assert.ok(result.error?.includes("workspacePath"));
-    });
-
-    it("accepts valid request", () => {
-      const result = validateReviewRequest({
-        requestId: "test",
-        input: { workspacePath: TEST_WORKSPACE },
-      });
-      assert.strictEqual(result.valid, true);
-      assert.ok(result.request);
-    });
-
-    it("applies default maxPasses and maxToolCalls", () => {
-      const result = validateReviewRequest({
-        requestId: "test",
-        input: { workspacePath: TEST_WORKSPACE },
-      });
-      assert.strictEqual(result.valid, true);
-      assert.strictEqual(result.request?.maxPasses, 5);
-      assert.strictEqual(result.request?.maxToolCalls, 100);
-    });
-
-    it("respects provided maxPasses and maxToolCalls", () => {
-      const result = validateReviewRequest({
-        requestId: "test",
-        input: { workspacePath: TEST_WORKSPACE },
-        maxPasses: 10,
-        maxToolCalls: 200,
-      });
-      assert.strictEqual(result.valid, true);
-      assert.strictEqual(result.request?.maxPasses, 10);
-      assert.strictEqual(result.request?.maxToolCalls, 200);
-    });
-  });
-
-  // --- Storage Failure ---
-  describe("Storage failure handling", () => {
-    it("validateAndHashRequest handles missing workspace path gracefully", () => {
-      const result = validateAndHashRequest({
-        requestId: "test",
-        input: { workspacePath: "/nonexistent/path/that/cannot/exist" },
-      });
-      assert.strictEqual(result.valid, true); // Validation passes, hash is computed
-      assert.ok(result.workspaceKey);
-    });
-  });
-});

package/packages/durable-review/test/smoke.test.ts

@@ -1,107 +0,0 @@
-/// <reference types="node" />
-/**
- * SQLite Smoke Test
- *
- * Verifies SQLite storage works correctly with Node's built-in sqlite.
- *
- * The storage needs `node:sqlite`. Node has that module, Bun does not, so
- * the tests are skipped with a reason where the module is missing.
- */
-
-import { describe, it, before, after } from "node:test";
-import assert from "node:assert";
-import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
-import { join } from "node:path";
-import { mkdirSync, unlinkSync, existsSync } from "node:fs";
-
-const TEST_DB_PATH = join(process.env.HOME || "/tmp", ".pi-harness-runtime", "test", "smoke.sqlite");
-
-/** Whether this runtime has the SQLite module of Node. */
-const sqliteAvailable = await (async () => {
-	try {
-		await import("node:sqlite");
-		return true;
-	} catch {
-		return false;
-	}
-})();
-
-const SKIP_WITHOUT_SQLITE = sqliteAvailable
-	? false
-	: "node:sqlite is not available in this runtime";
-const itSqlite = sqliteAvailable ? it : it.skip;
-
-/** Open the storage of the test database. */
-async function openStorage(): Promise<{
-	close: (ctx: unknown) => Promise<void>;
-}> {
-	const { openNodeSqliteStorage } = await import(
-		"@earendil-works/pi-durable/storage/sqlite/node"
-	);
-	return (await openNodeSqliteStorage(TEST_DB_PATH)) as {
-		close: (ctx: unknown) => Promise<void>;
-	};
-}
-
-describe("SQLite Smoke Test", () => {
-	before(() => {
-		// Ensure directory exists
-		const dir = TEST_DB_PATH.replace(/\/[^/]+$/, "");
-		mkdirSync(dir, { recursive: true });
-		// Clean up any existing test db
-		if (existsSync(TEST_DB_PATH)) {
-			try {
-				unlinkSync(TEST_DB_PATH);
-			} catch {
-				// ignore
-			}
-		}
-	});
-
-	after(() => {
-		// Cleanup
-		if (existsSync(TEST_DB_PATH)) {
-			try {
-				unlinkSync(TEST_DB_PATH);
-			} catch {
-				// ignore
-			}
-		}
-	});
-
-	itSqlite("opens SQLite storage", { skip: SKIP_WITHOUT_SQLITE }, async () => {
-		const storage = await openStorage();
-		assert.ok(storage, "Storage should be defined");
-		await storage.close(BACKGROUND_CONTEXT);
-	});
-
-	itSqlite(
-		"creates and reopens database",
-		{ skip: SKIP_WITHOUT_SQLITE },
-		async () => {
-			// First open
-			const storage1 = await openStorage();
-			await storage1.close(BACKGROUND_CONTEXT);
-
-			// Second open - should work
-			const storage2 = await openStorage();
-			assert.ok(storage2, "Storage should be reopened");
-			await storage2.close(BACKGROUND_CONTEXT);
-		},
-	);
-
-	itSqlite(
-		"persists data across reopen",
-		{ skip: SKIP_WITHOUT_SQLITE },
-		async () => {
-			// Open and write
-			const storage1 = await openStorage();
-			await storage1.close(BACKGROUND_CONTEXT);
-
-			// Reopen and verify
-			const storage2 = await openStorage();
-			assert.ok(storage2, "Storage should be reopened with data");
-			await storage2.close(BACKGROUND_CONTEXT);
-		},
-	);
-});