pi-harness-runtime 1.1.440 → 1.1.441

package/packages/experience-replay/test/replay.test.ts

@@ -1,267 +0,0 @@
-/**
- * Experience Replay Tests (RFC-0059)
- */
-
-import { describe, it, expect, beforeEach } from "@jest/globals";
-import { type ExperienceReplay, createExperienceReplay } from "../src/index.js";
-import type { ReplayRequest, ReplaySources } from "../src/index.js";
-
-describe("ExperienceReplay", () => {
-	let replay: ExperienceReplay;
-
-	beforeEach(() => {
-		replay = createExperienceReplay();
-	});
-
-	describe("replay", () => {
-		it("reconstructs state from event log", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				checkpoint: {
-					version: 1,
-					jobId: "job-1",
-					status: "running",
-					requirement: "Test requirement",
-					createdAt: new Date().toISOString(),
-					updatedAt: new Date().toISOString(),
-				},
-				events: [
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "task.started",
-						message: "Task started",
-						data: { taskId: "task-1" },
-					},
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "task.completed",
-						message: "Task completed",
-						data: { taskId: "task-1" },
-					},
-				],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.jobId).toBe("job-1");
-			expect(result.reconstructedState).toBeDefined();
-			expect(result.timeline.length).toBe(2);
-		});
-
-		it("returns error for missing sources", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {};
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.divergences.length).toBeGreaterThan(0);
-			expect(result.divergences[0].severity).toBe("error");
-		});
-
-		it("supports inspect mode (read-only)", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				events: [
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "test",
-						message: "Test event",
-					},
-				],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.reconstructedState).toBeDefined();
-			// No external calls made in inspect mode
-		});
-
-		it("emits replay.started event", async () => {
-			const events: any[] = [];
-			replay.onEvent((e) => events.push(e));
-
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				events: [],
-			};
-
-			await replay.replay(request, sources);
-
-			expect(events.some((e) => e.type === "replay.started")).toBe(true);
-		});
-
-		it("emits replay.completed event", async () => {
-			const events: any[] = [];
-			replay.onEvent((e) => events.push(e));
-
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				events: [],
-			};
-
-			await replay.replay(request, sources);
-
-			expect(events.some((e) => e.type === "replay.completed")).toBe(true);
-		});
-
-		it("filters events by sequence range", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				fromSequence: 1,
-				toSequence: 3,
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				events: [
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "event-0",
-						message: "0",
-					},
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "event-1",
-						message: "1",
-					},
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "event-2",
-						message: "2",
-					},
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "event-3",
-						message: "3",
-					},
-				],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.timeline.length).toBe(2); // events 1 and 2
-			expect(result.timeline[0].sequence).toBe(1);
-		});
-
-		it("simulate mode performs no external calls", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "simulate",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				events: [
-					{
-						ts: new Date().toISOString(),
-						jobId: "job-1",
-						type: "test",
-						message: "Test",
-					},
-				],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			// Should complete without making external calls
-			expect(result.reconstructedState).toBeDefined();
-		});
-
-		it("requires approval for reexecute mode", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "reexecute",
-				allowExternalCalls: false, // No approval
-			};
-
-			const sources: ReplaySources = {
-				events: [],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			// Should have error divergence
-			expect(result.divergences.some((d) => d.severity === "error")).toBe(true);
-		});
-
-		it("collects artifact references", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const sources: ReplaySources = {
-				prompts: {
-					"prompt-1": "Test prompt",
-					"prompt-2": "Another prompt",
-				},
-				outputs: {
-					"output-1": "Test output",
-				},
-				events: [],
-			};
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.artifacts.length).toBe(3);
-		});
-	});
-
-	describe("timeline reconstruction", () => {
-		it("preserves event sequence", async () => {
-			const request: ReplayRequest = {
-				jobId: "job-1",
-				mode: "inspect",
-				allowExternalCalls: false,
-			};
-
-			const events = [
-				{ ts: "2024-01-01T00:00:01Z", jobId: "job-1", type: "a", message: "a" },
-				{ ts: "2024-01-01T00:00:02Z", jobId: "job-1", type: "b", message: "b" },
-				{ ts: "2024-01-01T00:00:03Z", jobId: "job-1", type: "c", message: "c" },
-			];
-
-			const sources: ReplaySources = { events };
-
-			const result = await replay.replay(request, sources);
-
-			expect(result.timeline[0].sequence).toBe(0);
-			expect(result.timeline[1].sequence).toBe(1);
-			expect(result.timeline[2].sequence).toBe(2);
-		});
-	});
-});

package/packages/feedback-collector/test/collector.test.ts

@@ -1,142 +0,0 @@
-/**
- * Feedback Collector Tests (RFC-0021)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { FeedbackCollector } from "../src/index.js";
-import type { FeedbackBatch } from "../src/index.js";
-
-describe("FeedbackCollector", () => {
-  let collector: FeedbackCollector;
-
-  beforeEach(() => { collector = new FeedbackCollector(); });
-
-  it("collects feedback from human source", () => {
-    const item = collector.collect("human", "Great product, love it!");
-    expect(item.id).toBeDefined();
-    expect(item.source).toBe("human");
-    expect(item.sentiment).toBe("positive");
-    expect(item.status).toBe("pending");
-  });
-
-  it("collects feedback from automated source", () => {
-    const item = collector.collect("automated", "Build failed on line 42");
-    expect(item.source).toBe("automated");
-    expect(item.sentiment).toBe("negative");
-  });
-
-  it("infers negative sentiment from error messages", () => {
-    const item = collector.collect("system", "Bug: crash on startup");
-    expect(item.sentiment).toBe("negative");
-  });
-
-  it("infers neutral sentiment", () => {
-    const item = collector.collect("system", "Process completed");
-    expect(item.sentiment).toBe("neutral");
-  });
-
-  it("collectBatch adds all items", () => {
-    const batch: FeedbackBatch = {
-      id: "batch-1",
-      source: "user",
-      receivedAt: new Date().toISOString(),
-      items: [
-        { id: "f1", message: "msg1", source: "user", status: "pending" },
-        { id: "f2", message: "msg2", source: "user", status: "pending" },
-      ],
-    };
-    collector.collectBatch(batch);
-    expect(collector.count()).toBe(2);
-  });
-
-  it("query filters by source", () => {
-    collector.collect("human", "human msg");
-    collector.collect("automated", "automated msg");
-    const results = collector.query({ source: "human" });
-    expect(results).toHaveLength(1);
-    expect(results[0].source).toBe("human");
-  });
-
-  it("query filters by sentiment", () => {
-    collector.collect("system", "good thing");
-    collector.collect("system", "bad thing");
-    const results = collector.query({ sentiment: "positive" });
-    expect(results).toHaveLength(1);
-  });
-
-  it("query filters by status", () => {
-    collector.collect("human", "msg1");
-    collector.collect("human", "msg2");
-    collector.updateStatus(collector.query()[0].id, "reviewed");
-    const results = collector.query({ status: "pending" });
-    expect(results).toHaveLength(1);
-  });
-
-  it("query filters by tags", () => {
-    collector.collect("human", "msg1", { tags: ["auth"] });
-    collector.collect("human", "msg2", { tags: ["ui"] });
-    const results = collector.query({ tags: ["auth"] });
-    expect(results).toHaveLength(1);
-  });
-
-  it("summary aggregates correctly", () => {
-    collector.collect("human", "great work");
-    collector.collect("human", "bad bug");
-    collector.collect("automated", "system msg");
-    const summary = collector.summary();
-    expect(summary.total).toBe(3);
-    expect(summary.bySource.human).toBe(2);
-    expect(summary.bySource.automated).toBe(1);
-    expect(summary.pending).toBe(3);
-  });
-
-  it("summary calculates avgScore", () => {
-    collector.collect("human", "msg1");
-    const items = collector.query();
-    items[0].score = 4;
-    items[0].sentiment = "positive";
-    collector.collect("human", "msg2");
-    const items2 = collector.query();
-    items2[1].score = 2;
-    items2[1].sentiment = "neutral";
-    const summary = collector.summary();
-    expect(summary.avgScore).toBe(3);
-  });
-
-  it("updateStatus changes status", () => {
-    const item = collector.collect("human", "msg");
-    collector.updateStatus(item.id, "reviewed");
-    expect(collector.query({ status: "reviewed" })).toHaveLength(1);
-  });
-
-  it("resolve sets resolvedAt", () => {
-    const item = collector.collect("human", "msg");
-    collector.resolve(item.id, "actioned");
-    const updated = collector.query()[0];
-    expect(updated.resolvedAt).toBeDefined();
-    expect(updated.status).toBe("actioned");
-  });
-
-  it("autoCloseOld closes old items", () => {
-    const item = collector.collect("human", "old msg");
-    const oldDate = new Date(Date.now() - 100 * 86_400_000).toISOString();
-    const items = collector.query();
-    items[0].createdAt = oldDate;
-    const count = collector.autoCloseOld();
-    expect(count).toBeGreaterThanOrEqual(0);
-  });
-
-  it("count returns total items", () => {
-    collector.collect("human", "msg1");
-    collector.collect("human", "msg2");
-    expect(collector.count()).toBe(2);
-  });
-
-  it("listBatches returns batches", () => {
-    const batch: FeedbackBatch = {
-      id: "b1", source: "user", receivedAt: "", items: [],
-    };
-    collector.collectBatch(batch);
-    expect(collector.listBatches()).toHaveLength(1);
-  });
-});

package/packages/framework-detector/test/detector.test.ts

@@ -1,75 +0,0 @@
-/**
- * Framework Detector - Tests
- */
-
-import { describe, it, expect } from "bun:test";
-import { createFrameworkDetector, SDK_VERSION } from "../src/index.js";
-
-describe("FrameworkDetector", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createFrameworkDetector", () => {
-		it("should create a framework detector instance", () => {
-			const detector = createFrameworkDetector();
-			expect(detector).toBeDefined();
-		});
-
-		it("should create with custom config", () => {
-			const detector = createFrameworkDetector({
-				confidenceThreshold: 0.5,
-				detectVersions: true,
-			});
-			expect(detector).toBeDefined();
-		});
-	});
-
-	describe("framework signatures", () => {
-		const detector = createFrameworkDetector();
-
-		it("should have built-in signatures", () => {
-			const registry = detector.getRegistry();
-			const signatures = registry.list();
-			expect(signatures.length).toBeGreaterThan(0);
-		});
-
-		it("should detect React", () => {
-			const signatures = detector.getRegistry().list();
-			const react = signatures.find((s) => s.id === "react");
-			expect(react).toBeDefined();
-			expect(react?.name).toBe("React");
-		});
-
-		it("should detect Next.js", () => {
-			const signatures = detector.getRegistry().list();
-			const nextjs = signatures.find((s) => s.id === "nextjs");
-			expect(nextjs).toBeDefined();
-			expect(nextjs?.name).toBe("Next.js");
-		});
-
-		it("should detect Frappe", () => {
-			const signatures = detector.getRegistry().list();
-			const frappe = signatures.find((s) => s.id === "frappe");
-			expect(frappe).toBeDefined();
-			expect(frappe?.name).toBe("Frappe");
-		});
-	});
-
-	describe("registry operations", () => {
-		const detector = createFrameworkDetector();
-
-		it("should get signatures by category", () => {
-			const frontend = detector.getRegistry().byCategory("frontend");
-			expect(frontend.length).toBeGreaterThan(0);
-		});
-
-		it("should get registry", () => {
-			const registry = detector.getRegistry();
-			expect(registry).toBeDefined();
-		});
-	});
-});