pi-harness-runtime 0.10.43 → 1.1.1

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

@@ -0,0 +1,233 @@
+/**
+ * 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/session-api/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@pi/session-api",
+  "version": "0.10.30",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/packages/session-export/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@pi/session-export",
+  "version": "0.10.30",
+  "type": "module",
+  "main": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/packages/shared-context/README.md

@@ -0,0 +1,3 @@
+# packages/shared-context
+
+Shared state/context between agents and tasks will live here.

package/packages/shared-context/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@pi-harness/shared-context",
+  "version": "0.10.30",
+  "description": "pi-harness-runtime — shared-context",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test"
+  },
+  "dependencies": {}
+}

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

@@ -0,0 +1,114 @@
+/**
+ * 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");
+		});
+	});
+});

package/packages/skill-registry/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pi-harness/skill-registry",
+  "version": "0.10.30",
+  "description": "Skill Registry for pi-harness-runtime — dynamic skill discovery and invocation",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun test",
+    "test:watch": "bun test --watch",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": [
+    "pi",
+    "harness",
+    "runtime",
+    "skill",
+    "registry",
+    "agent"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "bun-types": "^1.0.0"
+  }
+}