pi-harness-runtime 1.1.439 → 1.1.441

package/packages/checkpoint/test/engine.test.ts

@@ -1,265 +0,0 @@
-/**
- * Checkpoint Engine - Tests
- */
-
-import { describe, it, expect, beforeEach, afterAll } from "bun:test";
-import { createCheckpointEngine, SDK_VERSION } from "../src/index.js";
-import type { RuntimeState } from "../src/types.js";
-
-describe("CheckpointEngine", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createCheckpointEngine", () => {
-		it("should create a checkpoint engine instance", () => {
-			const engine = createCheckpointEngine({
-				rootDir: "/tmp/test-checkpoints",
-			});
-			expect(engine).toBeDefined();
-		});
-
-		it("should create with default config", () => {
-			const engine = createCheckpointEngine();
-			expect(engine).toBeDefined();
-		});
-	});
-
-	describe("save and load", () => {
-		const engine = createCheckpointEngine({
-			rootDir: "/tmp/checkpoint-test",
-			compression: false,
-			incremental: false,
-			autoPrune: false,
-		});
-
-		const testState: RuntimeState = {
-			version: 1,
-			jobId: "test-job-1",
-			status: "running",
-			requirement: "Test requirement",
-			tasks: [
-				{
-					id: "task-1",
-					title: "Task 1",
-					description: "First task",
-					status: "done",
-				},
-				{
-					id: "task-2",
-					title: "Task 2",
-					description: "Second task",
-					status: "pending",
-				},
-			],
-			createdAt: new Date().toISOString(),
-			updatedAt: new Date().toISOString(),
-		};
-
-		it("should save a checkpoint", async () => {
-			const metadata = await engine.save("test-job-1", testState);
-
-			expect(metadata).toBeDefined();
-			expect(metadata.jobId).toBe("test-job-1");
-			expect(metadata.version).toBe(1);
-			expect(metadata.type).toBe("full");
-		});
-
-		it("should increment version on save", async () => {
-			const state2 = {
-				...testState,
-				version: 2,
-				updatedAt: new Date().toISOString(),
-			};
-			const metadata = await engine.save("test-job-1", state2);
-
-			expect(metadata.version).toBe(2);
-		});
-
-		it("should load the latest checkpoint", async () => {
-			const loaded = await engine.load("test-job-1");
-
-			expect(loaded).toBeDefined();
-			expect(loaded?.jobId).toBe("test-job-1");
-			expect(loaded?.status).toBe("running");
-		});
-
-		it("should return null for non-existent job", async () => {
-			const loaded = await engine.load("non-existent-job");
-
-			expect(loaded).toBeNull();
-		});
-
-		it("should get metadata for all checkpoints", async () => {
-			const metadata = await engine.getMetadata("test-job-1");
-
-			expect(metadata.length).toBeGreaterThan(0);
-			expect(metadata[0].jobId).toBe("test-job-1");
-		});
-
-		it("should delete all checkpoints", async () => {
-			await engine.deleteAll("test-job-1");
-
-			const loaded = await engine.load("test-job-1");
-			expect(loaded).toBeNull();
-		});
-	});
-
-	describe("incremental checkpoints", () => {
-		const engine = createCheckpointEngine({
-			rootDir: "/tmp/checkpoint-incremental",
-			compression: false,
-			incremental: true,
-			autoPrune: false,
-		});
-
-		it("should save incremental checkpoint", async () => {
-			const state1: RuntimeState = {
-				version: 1,
-				jobId: "incremental-test",
-				status: "running",
-				requirement: "Test",
-				tasks: [],
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-			};
-
-			await engine.save("incremental-test", state1);
-
-			const state2: RuntimeState = {
-				...state1,
-				version: 2,
-				status: "completed",
-				updatedAt: new Date().toISOString(),
-			};
-
-			const metadata = await engine.save("incremental-test", state2);
-
-			// Should be incremental after first full checkpoint
-			expect(["full", "incremental"]).toContain(metadata.type);
-		});
-
-		afterAll(async () => {
-			await engine.deleteAll("incremental-test");
-		});
-	});
-
-	describe("recovery", () => {
-		const engine = createCheckpointEngine({
-			rootDir: "/tmp/checkpoint-recovery",
-			compression: false,
-			incremental: false,
-			autoPrune: false,
-		});
-
-		beforeEach(async () => {
-			// Clear any stale checkpoints from previous runs so version starts at 1
-			await engine.deleteAll("recovery-test");
-
-			const state: RuntimeState = {
-				version: 1,
-				jobId: "recovery-test",
-				status: "running",
-				requirement: "Recovery test",
-				tasks: [],
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-			};
-			await engine.save("recovery-test", state);
-		});
-
-		it("should recover with latest strategy", async () => {
-			const result = await engine.recover("recovery-test", "latest");
-
-			expect(result.success).toBe(true);
-			expect(result.recoveredVersion).toBe(1);
-			expect(result.recoveredState?.jobId).toBe("recovery-test");
-		});
-
-		it("should recover with specific version", async () => {
-			const result = await engine.recover("recovery-test", "specific:1");
-
-			expect(result.success).toBe(true);
-			expect(result.recoveredVersion).toBe(1);
-		});
-
-		it("should fail for non-existent job", async () => {
-			const result = await engine.recover("non-existent", "latest");
-
-			expect(result.success).toBe(false);
-		});
-	});
-
-	describe("pruning", () => {
-		const engine = createCheckpointEngine({
-			rootDir: "/tmp/checkpoint-prune",
-			compression: false,
-			incremental: false,
-			autoPrune: false,
-		});
-
-		it("should prune old checkpoints", async () => {
-			// Create multiple checkpoints
-			for (let i = 1; i <= 5; i++) {
-				const state: RuntimeState = {
-					version: i,
-					jobId: "prune-test",
-					status: "running",
-					requirement: `Version ${i}`,
-					tasks: [],
-					createdAt: new Date().toISOString(),
-					updatedAt: new Date().toISOString(),
-				};
-				await engine.save("prune-test", state);
-			}
-
-			// Prune to keep only 2
-			const result = await engine.prune("prune-test", 2);
-
-			expect(result.deletedCount).toBeGreaterThan(0);
-			expect(result.remainingCount).toBe(2);
-		});
-
-		afterAll(async () => {
-			await engine.deleteAll("prune-test");
-		});
-	});
-
-	describe("verification", () => {
-		const engine = createCheckpointEngine({
-			rootDir: "/tmp/checkpoint-verify",
-			compression: false,
-			incremental: false,
-			autoPrune: false,
-		});
-
-		beforeEach(async () => {
-			const state: RuntimeState = {
-				version: 1,
-				jobId: "verify-test",
-				status: "running",
-				requirement: "Verify test",
-				tasks: [],
-				createdAt: new Date().toISOString(),
-				updatedAt: new Date().toISOString(),
-			};
-			await engine.save("verify-test", state);
-		});
-
-		it("should verify checkpoint", async () => {
-			const result = await engine.verify("verify-test", 1);
-
-			expect(result.valid).toBe(true);
-			expect(result.checksumMatch).toBe(true);
-		});
-
-		it("should fail verification for non-existent checkpoint", async () => {
-			const result = await engine.verify("verify-test", 999);
-
-			expect(result.valid).toBe(false);
-		});
-	});
-});

package/packages/cli-plugin-sdk/test/cli.test.ts

@@ -1,45 +0,0 @@
-/**
- * CLI Plugin SDK Tests (RFC-0067)
- */
-
-import { describe, it, expect } from "bun:test";
-import { PluginCLI } from "../src/index.js";
-
-describe("PluginCLI", () => {
-	const cli = new PluginCLI({ cwd: "/tmp/test-cli-plugins" });
-
-	it("creates instance with defaults", () => {
-		const c = new PluginCLI();
-		expect(c).toBeDefined();
-	});
-
-	it("creates instance with custom config", () => {
-		const c = new PluginCLI({
-			cwd: "/custom/path",
-			globalDir: "/custom/global",
-			registry: "https://custom.registry",
-		});
-		expect(c).toBeDefined();
-	});
-
-	it("getPluginPath returns null for non-existent plugin", () => {
-		const path = cli.getPluginPath("nonexistent-plugin");
-		expect(path).toBeNull();
-	});
-
-	it("list returns empty array for non-plugin dir", async () => {
-		const plugins = await cli.list();
-		expect(Array.isArray(plugins)).toBe(true);
-	});
-
-	it("search returns array", async () => {
-		const results = await cli.search("frappe");
-		expect(Array.isArray(results)).toBe(true);
-	});
-
-	it("invoke returns error for non-existent plugin", async () => {
-		const result = await cli.invoke("nonexistent-plugin", "analyze");
-		expect(result.success).toBe(false);
-		expect(result.error).toContain("not found");
-	});
-});

package/packages/code-generation/test/generator.test.ts

@@ -1,238 +0,0 @@
-/**
- * Code Generation Pipeline - Tests
- */
-
-import { describe, expect, it } from "bun:test";
-import { SDK_VERSION, createCodeGenerator, createFaker } from "../src/index.js";
-
-describe("CodeGeneration", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createFaker", () => {
-		it("should create faker instance", () => {
-			const faker = createFaker(12345);
-			expect(faker).toBeDefined();
-		});
-
-		it("should generate consistent data with seed", () => {
-			const faker1 = createFaker(12345);
-			const faker2 = createFaker(12345);
-
-			expect(faker1.firstName()).toBe(faker2.firstName());
-		});
-
-		it("should generate different data without seed", () => {
-			const faker1 = createFaker();
-			const faker2 = createFaker();
-
-			// May or may not be different (random)
-			expect(typeof faker1.firstName()).toBe("string");
-			expect(typeof faker2.firstName()).toBe("string");
-		});
-	});
-
-	describe("Faker data generation", () => {
-		const faker = createFaker(12345);
-
-		it("should generate names", () => {
-			expect(typeof faker.firstName()).toBe("string");
-			expect(typeof faker.lastName()).toBe("string");
-			expect(typeof faker.fullName()).toBe("string");
-		});
-
-		it("should generate email", () => {
-			const email = faker.email();
-			expect(email).toContain("@");
-			expect(email).toContain(".");
-		});
-
-		it("should generate uuid", () => {
-			const uuid = faker.uuid();
-			expect(uuid).toMatch(/^[0-9a-f-]+$/);
-		});
-
-		it("should generate phone", () => {
-			const phone = faker.phone();
-			expect(phone).toMatch(/\d/);
-		});
-
-		it("should generate addresses", () => {
-			expect(typeof faker.address()).toBe("string");
-			expect(typeof faker.city()).toBe("string");
-			expect(typeof faker.country()).toBe("string");
-			expect(typeof faker.zipCode()).toBe("string");
-		});
-
-		it("should generate company info", () => {
-			expect(typeof faker.company()).toBe("string");
-			expect(typeof faker.department()).toBe("string");
-			expect(typeof faker.jobTitle()).toBe("string");
-		});
-
-		it("should generate text", () => {
-			expect(typeof faker.word()).toBe("string");
-			expect(typeof faker.sentence()).toBe("string");
-			expect(typeof faker.paragraph()).toBe("string");
-		});
-
-		it("should generate numbers within range", () => {
-			const num = faker.number(10, 20);
-			expect(num).toBeGreaterThanOrEqual(10);
-			expect(num).toBeLessThanOrEqual(20);
-		});
-
-		it("should generate boolean", () => {
-			const bool = faker.boolean();
-			expect(typeof bool).toBe("boolean");
-		});
-	});
-
-	describe("createCodeGenerator", () => {
-		it("should create code generator instance", () => {
-			const generator = createCodeGenerator();
-			expect(generator).toBeDefined();
-		});
-
-		it("should create with custom config", () => {
-			const generator = createCodeGenerator({
-				seed: 12345,
-				verbose: true,
-			});
-			expect(generator).toBeDefined();
-		});
-	});
-
-	describe("code generation", () => {
-		const generator = createCodeGenerator({
-			seed: 12345,
-		});
-
-		it("should generate code from template", async () => {
-			const result = await generator.generate({
-				template: {
-					id: "test",
-					name: "Test",
-					description: "Test template",
-					content: "Hello, <%= name %>!",
-					engine: "ejs",
-				},
-				variables: { name: "World" },
-			});
-
-			expect(result.success).toBe(true);
-			expect(result.files[0].content).toContain("Hello, World!");
-		});
-
-		it("should generate with multiple variables", async () => {
-			const result = await generator.generate({
-				template: {
-					id: "test2",
-					name: "Test2",
-					description: "Test template 2",
-					content: "User: <%= firstName %> <%= lastName %>",
-					engine: "ejs",
-				},
-				variables: { firstName: "John", lastName: "Doe" },
-			});
-
-			expect(result.success).toBe(true);
-			expect(result.files[0].content).toContain("John Doe");
-		});
-
-		it("should return errors for missing template", async () => {
-			const result = await generator.generate({
-				schemaId: "non-existent",
-				variables: {},
-			});
-
-			expect(result.success).toBe(false);
-			expect(result.errors.length).toBeGreaterThan(0);
-		});
-
-		it("should validate required variables", async () => {
-			const result = await generator.generate({
-				template: {
-					id: "required",
-					name: "Required",
-					description: "Required vars",
-					content: "Hello <%= name %>",
-					engine: "ejs",
-					variables: [{ name: "name", type: "string", required: true }],
-				},
-				variables: {},
-			});
-
-			expect(result.success).toBe(false);
-		});
-
-		it("should support dry run", async () => {
-			const result = await generator.generate({
-				template: {
-					id: "dry-run",
-					name: "DryRun",
-					description: "Dry run test",
-					content: "Test",
-					engine: "ejs",
-				},
-				variables: {},
-				dryRun: true,
-			});
-
-			expect(result.dryRun).toBe(true);
-		});
-
-		it("should calculate generation time", async () => {
-			const result = await generator.generate({
-				template: {
-					id: "timing",
-					name: "Timing",
-					description: "Timing test",
-					content: "Test content",
-					engine: "ejs",
-				},
-				variables: {},
-			});
-
-			expect(result.durationMs).toBeGreaterThanOrEqual(0);
-		});
-	});
-
-	describe("schema registration", () => {
-		const generator = createCodeGenerator();
-
-		it("should register schemas", () => {
-			generator.registerSchema({
-				name: "User",
-				fields: [{ name: "name", type: "string" }],
-			});
-
-			const schema = generator.getSchema("User");
-			expect(schema).toBeDefined();
-			expect(schema?.name).toBe("User");
-		});
-
-		it("should generate using registered schema", async () => {
-			generator.registerSchema({
-				id: "registered",
-				name: "Product",
-				description: "Product schema",
-				fields: [
-					{ name: "name", type: "string" },
-					{ name: "price", type: "number" },
-				],
-			});
-
-			const result = await generator.generate({
-				schemaId: "registered",
-				variables: {},
-			});
-
-			expect(result.success).toBe(true);
-		});
-	});
-});