pi-harness-runtime 1.1.440 → 1.1.441

package/packages/session/test/manager.test.ts

@@ -1,233 +0,0 @@
-/**
- * Session Manager - Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	createSessionManager,
-	createPolicyEngine,
-	SDK_VERSION,
-} from "../src/index.js";
-
-describe("SessionManager", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createSessionManager", () => {
-		it("should create a session manager instance", () => {
-			const manager = createSessionManager({
-				rootDir: "/tmp/sessions-test",
-			});
-			expect(manager).toBeDefined();
-		});
-	});
-
-	describe("session lifecycle", () => {
-		const manager = createSessionManager({
-			rootDir: "/tmp/session-lifecycle-test",
-			sessionTtlMs: 60000,
-			autoCleanup: false,
-		});
-
-		let sessionId: string;
-
-		it("should create a session", async () => {
-			const session = await manager.create("user-123", { project: "test" });
-
-			expect(session).toBeDefined();
-			expect(session.id).toBeDefined();
-			expect(session.userId).toBe("user-123");
-			expect(session.status).toBe("active");
-			sessionId = session.id;
-		});
-
-		it("should get session", async () => {
-			const session = await manager.get(sessionId);
-
-			expect(session).toBeDefined();
-			expect(session?.id).toBe(sessionId);
-		});
-
-		it("should get session context", async () => {
-			const context = await manager.getContext(sessionId);
-
-			expect(context).toBeDefined();
-			expect(context?.messages).toBeDefined();
-			expect(Array.isArray(context?.messages)).toBe(true);
-		});
-
-		it("should list sessions by user", async () => {
-			const sessions = await manager.listByUser("user-123");
-
-			expect(sessions.length).toBeGreaterThan(0);
-			expect(sessions[0].userId).toBe("user-123");
-		});
-
-		it("should add messages", async () => {
-			const message = await manager.addMessage(sessionId, {
-				role: "user",
-				content: "Hello, world!",
-				timestamp: new Date().toISOString(),
-			});
-
-			expect(message).toBeDefined();
-			expect(message?.content).toBe("Hello, world!");
-		});
-
-		it("should get messages", async () => {
-			const messages = await manager.getMessages(sessionId);
-
-			expect(messages.length).toBeGreaterThan(0);
-			expect(messages[0].role).toBe("user");
-		});
-
-		it("should update token usage", async () => {
-			await manager.updateTokenUsage(sessionId, {
-				inputTokens: 100,
-				outputTokens: 50,
-				totalTokens: 150,
-				totalCost: 0.001,
-			});
-
-			const context = await manager.getContext(sessionId);
-			expect(context?.tokenUsage.totalTokens).toBe(150);
-		});
-
-		it("should suspend session", async () => {
-			await manager.suspend(sessionId, "User requested pause");
-
-			const session = await manager.get(sessionId);
-			expect(session?.status).toBe("suspended");
-		});
-
-		it("should resume session", async () => {
-			await manager.resume(sessionId);
-
-			const session = await manager.get(sessionId);
-			expect(session?.status).toBe("active");
-		});
-
-		it("should end session", async () => {
-			await manager.end(sessionId);
-
-			const session = await manager.get(sessionId);
-			expect(session?.status).toBe("closed");
-		});
-	});
-
-	describe("event system", () => {
-		const manager = createSessionManager({
-			rootDir: "/tmp/session-events-test",
-			autoCleanup: false,
-		});
-
-		let sessionId: string;
-		let events: string[] = [];
-
-		beforeEach(async () => {
-			events = [];
-			const session = await manager.create("user-events");
-			sessionId = session.id;
-		});
-
-		it("should emit session:created event", async () => {
-			manager.on("session:created", () => {
-				events.push("session:created");
-			});
-
-			const session = await manager.create("new-user");
-			expect(events).toContain("session:created");
-
-			await manager.delete(session.id);
-		});
-
-		it("should emit message:added event", async () => {
-			manager.on("message:added", () => {
-				events.push("message:added");
-			});
-
-			await manager.addMessage(sessionId, {
-				role: "user",
-				content: "Test",
-				timestamp: new Date().toISOString(),
-			});
-
-			expect(events).toContain("message:added");
-		});
-	});
-});
-
-describe("PolicyEngine", () => {
-	describe("createPolicyEngine", () => {
-		it("should create a policy engine instance", () => {
-			const engine = createPolicyEngine();
-			expect(engine).toBeDefined();
-		});
-
-		it("should create with custom config", () => {
-			const engine = createPolicyEngine({
-				maxRequestsPerMinute: 100,
-				sessionBudget: 10,
-			});
-			expect(engine).toBeDefined();
-		});
-	});
-
-	describe("rate limiting", () => {
-		const engine = createPolicyEngine({
-			maxRequestsPerMinute: 5,
-		});
-
-		it("should allow requests within limit", () => {
-			expect(engine.canProceed("test-session", "message")).toBe(true);
-		});
-
-		it("should track remaining requests", () => {
-			engine.recordAction("test-session", "message");
-
-			const state = engine.getPolicyState("test-session");
-			expect(state.rateLimitRemaining).toBeLessThan(5);
-		});
-	});
-
-	describe("budget tracking", () => {
-		const engine = createPolicyEngine({
-			sessionBudget: 1,
-		});
-
-		it("should track budget", () => {
-			engine.setSessionBudget("budget-session", 1, 60000);
-
-			const state = engine.getPolicyState("budget-session");
-			expect(state.budgetRemaining).toBeDefined();
-		});
-	});
-
-	describe("suspension", () => {
-		const engine = createPolicyEngine();
-
-		it("should suspend session", () => {
-			engine.suspend("suspended-session", "Violation");
-
-			const state = engine.getPolicyState("suspended-session");
-			expect(state.suspended).toBe(true);
-			expect(state.suspensionReason).toBe("Violation");
-		});
-
-		it("should not allow actions on suspended session", () => {
-			expect(engine.canProceed("suspended-session", "message")).toBe(false);
-		});
-
-		it("should resume session", () => {
-			engine.resume("suspended-session");
-
-			const state = engine.getPolicyState("suspended-session");
-			expect(state.suspended).toBe(false);
-			expect(engine.canProceed("suspended-session", "message")).toBe(true);
-		});
-	});
-});

package/packages/shared-context/test/shared-context.test.ts

@@ -1,114 +0,0 @@
-/**
- * Shared Context Store Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { FileSharedContextStore } from "../src/shared-context";
-
-const TMP = join(process.cwd(), ".test-context-tmp");
-
-function store(): FileSharedContextStore {
-	return new FileSharedContextStore(TMP);
-}
-
-beforeEach(() => {
-	rmSync(TMP, { force: true, recursive: true });
-	mkdirSync(TMP, { recursive: true });
-});
-
-describe("FileSharedContextStore", () => {
-	describe("writeRequirement / readRequirement", () => {
-		it("writes and reads back a requirement", async () => {
-			const s = store();
-			await s.writeRequirement("job-42", "Implement the login feature");
-			const text = await s.readRequirement("job-42");
-			expect(text).toBe("Implement the login feature\n");
-		});
-
-		it("returns null for missing requirement", async () => {
-			const s = store();
-			const text = await s.readRequirement("nonexistent-job");
-			expect(text).toBeNull();
-		});
-
-		it("overwrites existing requirement", async () => {
-			const s = store();
-			await s.writeRequirement("job-1", "original");
-			await s.writeRequirement("job-1", "updated");
-			const text = await s.readRequirement("job-1");
-			expect(text).toContain("updated");
-		});
-
-		it("handles multiline content", async () => {
-			const s = store();
-			const multiline = "Line 1\nLine 2\nLine 3";
-			await s.writeRequirement("job-3", multiline);
-			const text = await s.readRequirement("job-3");
-			expect(text).toBe("Line 1\nLine 2\nLine 3\n");
-		});
-	});
-
-	describe("writeResumePrompt", () => {
-		it("writes to resume_prompt.md", async () => {
-			const s = store();
-			await s.writeResumePrompt("job-7", "Resume context for job-7");
-			const text = await s.readRequirement("job-7");
-			expect(text).toBeNull(); // readRequirement reads requirement.md
-			// Read via the file system directly
-			const { readFileSync } = await import("node:fs");
-			const content = readFileSync(
-				join(TMP, "jobs", "job-7", "resume_prompt.md"),
-				"utf-8",
-			);
-			expect(content).toContain("Resume context for job-7");
-		});
-	});
-
-	describe("appendDecision", () => {
-		it("appends a decision entry", async () => {
-			const s = store();
-			await s.appendDecision("job-5", "Chose approach A because of simplicity");
-			const { readFileSync } = await import("node:fs");
-			const content = readFileSync(
-				join(TMP, "jobs", "job-5", "decisions.md"),
-				"utf-8",
-			);
-			expect(content).toContain("Chose approach A");
-			expect(content).toContain("## 20"); // ISO date prefix
-		});
-
-		it("appends multiple decisions sequentially", async () => {
-			const s = store();
-			await s.appendDecision("job-9", "Decision 1");
-			await s.appendDecision("job-9", "Decision 2");
-			const { readFileSync } = await import("node:fs");
-			const content = readFileSync(
-				join(TMP, "jobs", "job-9", "decisions.md"),
-				"utf-8",
-			);
-			expect(content).toContain("Decision 1");
-			expect(content).toContain("Decision 2");
-		});
-
-		it("creates intermediate directories", async () => {
-			const s = store();
-			await s.appendDecision("deeply-nested-job", "Made a decision");
-			const { existsSync } = await import("node:fs");
-			expect(existsSync(join(TMP, "jobs", "deeply-nested-job"))).toBe(true);
-		});
-	});
-
-	describe("multiple jobs", () => {
-		it("isolates jobs by ID", async () => {
-			const s = store();
-			await s.writeRequirement("job-A", "Content for A");
-			await s.writeRequirement("job-B", "Content for B");
-			const textA = await s.readRequirement("job-A");
-			const textB = await s.readRequirement("job-B");
-			expect(textA).toContain("Content for A");
-			expect(textB).toContain("Content for B");
-		});
-	});
-});