pi-harness-runtime 0.10.43 → 1.1.1

package/packages/autonomous-runtime/test/autonomous-runtime.test.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for autonomous-runtime (RFC-0101 Phase 1)
+ *
+ * Covers: TaskRecord, TaskStatus, TaskLease, TaskInbox, LeaseManager
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import type { TaskRecord, TaskLease } from "../src/types.js";
+import { TaskInbox, LeaseManager } from "../src/index.js";
+
+const TEST_DIR = mkdtempSync(join(tmpdir(), "pi-autonomous-"));
+const INBOX_DIR = join(TEST_DIR, "inbox");
+const LEASE_DIR = join(TEST_DIR, "leases");
+
+afterEach(() => {
+	try {
+		rmSync(TEST_DIR, { recursive: true, force: true });
+	} catch {
+		// ignore
+	}
+});
+
+describe("TaskRecord types", () => {
+	it("accepts valid task shape", () => {
+		const task: TaskRecord = {
+			id: "task-1",
+			status: "pending",
+			title: "Test task",
+			created_at: new Date().toISOString(),
+			updated_at: new Date().toISOString(),
+			attempts: 0,
+		};
+		expect(task.id).toBe("task-1");
+		expect(task.status).toBe("pending");
+	});
+});
+
+describe("LeaseManager", () => {
+	it("grants exclusive lease to first worker", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		const lease = await mgr.acquire("task-1", "worker-1");
+		expect(lease).not.toBeNull();
+		expect(lease!.worker_id).toBe("worker-1");
+		expect(lease!.task_id).toBe("task-1");
+		expect(lease!.acquired_at).toBeTruthy();
+	});
+
+	it("denies lease to second worker", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		await mgr.acquire("task-1", "worker-1");
+		const second = await mgr.acquire("task-1", "worker-2");
+		expect(second).toBeNull();
+	});
+
+	it("releases and allows re-acquisition", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		await mgr.acquire("task-1", "worker-1");
+		await mgr.release("task-1", "worker-1");
+		const next = await mgr.acquire("task-1", "worker-2");
+		expect(next).not.toBeNull();
+		expect(next!.worker_id).toBe("worker-2");
+	});
+
+	it("only owner can release", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		await mgr.acquire("task-1", "worker-1");
+		const released = await mgr.release("task-1", "worker-2");
+		expect(released).toBe(false);
+	});
+
+	it("renewLease extends expiry if owner", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		await mgr.acquire("task-1", "worker-1");
+		const renewed = await mgr.renewLease("task-1", "worker-1");
+		expect(renewed).toBe(true);
+	});
+
+	it("renewLease fails for non-owner", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		await mgr.acquire("task-1", "worker-1");
+		const renewed = await mgr.renewLease("task-1", "worker-2");
+		expect(renewed).toBe(false);
+	});
+
+	it("getLease returns current lease", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR });
+		const lease = await mgr.acquire("task-1", "worker-1");
+		const found = await mgr.getLease("task-1");
+		expect(found).toEqual(lease);
+	});
+
+	it("expired lease allows re-acquisition", async () => {
+		const mgr = new LeaseManager({ leases_dir: LEASE_DIR, default_ttl_ms: 1 });
+		await mgr.acquire("task-1", "worker-1");
+		// Wait for expiry
+		await new Promise((r) => setTimeout(r, 10));
+		const next = await mgr.acquire("task-1", "worker-2");
+		expect(next).not.toBeNull();
+		expect(next!.worker_id).toBe("worker-2");
+	});
+});
+
+describe("TaskInbox", () => {
+	it("accepts and returns pending tasks", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		await inbox.submit({
+			title: "Do the thing",
+			description: "A test task",
+			capability: "read",
+		});
+		const tasks = await inbox.getPending();
+		expect(tasks.length).toBe(1);
+		expect(tasks[0].status).toBe("pending");
+	});
+
+	it("assigns sequential integer IDs", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		await inbox.submit({ title: "Task 1", capability: "read" });
+		await inbox.submit({ title: "Task 2", capability: "read" });
+		const tasks = await inbox.getPending();
+		expect(tasks.length).toBe(2);
+		expect(tasks[0].id).toMatch(/^\d+$/);
+		expect(tasks[1].id).toMatch(/^\d+$/);
+		expect(Number(tasks[0].id)).toBeLessThan(Number(tasks[1].id));
+	});
+
+	it("transitions pending → running → completed", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		await inbox.submit({ title: "Test", capability: "read" });
+
+		const task = (await inbox.getPending())[0];
+		const started = await inbox.start(task.id);
+		expect(started.status).toBe("running");
+
+		const completed = await inbox.complete(task.id, { success: true });
+		expect(completed.status).toBe("completed");
+	});
+
+	it("fails a running task", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		await inbox.submit({ title: "Fail task", capability: "read" });
+		const task = (await inbox.getPending())[0];
+		await inbox.start(task.id);
+		const failed = await inbox.fail(task.id, "Intentional test failure");
+		expect(failed.status).toBe("failed");
+		expect(failed.error).toBe("Intentional test failure");
+	});
+
+	it("retries a failed task if max_attempts not exceeded", async () => {
+		const inbox = new TaskInbox({
+			inbox_dir: INBOX_DIR,
+			options: { max_attempts: 2 },
+		});
+		await inbox.submit({ title: "Retry task", capability: "read" });
+		const task = (await inbox.getPending())[0];
+		await inbox.start(task.id);
+		await inbox.fail(task.id, "First attempt failed");
+		const retried = (await inbox.getPending()).find((t) => t.id === task.id);
+		expect(retried).not.toBeUndefined();
+		expect(retried!.attempts).toBe(1);
+	});
+
+	it("does not retry if max_attempts exceeded", async () => {
+		const inbox = new TaskInbox({
+			inbox_dir: INBOX_DIR,
+			options: { max_attempts: 1 },
+		});
+		await inbox.submit({ title: "No retry task", capability: "read" });
+		const task = (await inbox.getPending())[0];
+		await inbox.start(task.id);
+		await inbox.fail(task.id, "Final failure");
+		const retried = await inbox.getTask(task.id);
+		expect(retried?.status).toBe("failed");
+		expect(retried?.attempts).toBe(1);
+	});
+
+	it("getTask returns specific task by id", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		await inbox.submit({ title: "Specific task", capability: "read" });
+		const [task] = await inbox.getPending();
+		const found = await inbox.getTask(task.id);
+		expect(found?.id).toBe(task.id);
+	});
+
+	it("returns null for non-existent task", async () => {
+		const inbox = new TaskInbox({ inbox_dir: INBOX_DIR });
+		const found = await inbox.getTask("nonexistent");
+		expect(found).toBeNull();
+	});
+});

package/packages/autonomous-runtime/test/inbox.test.ts

@@ -0,0 +1,80 @@
+/**
+ * Tests for TaskInbox (filesystem-backed).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { TaskInbox } from "../src/inbox.js";
+
+const DIR = mkdtempSync(join(tmpdir(), "pi-inbox-test-"));
+
+// Set env so inbox uses our temp dir
+process.env.PI_HARNESS_RUNTIME_ROOT = DIR;
+
+const inbox = new TaskInbox({ rootDir: DIR });
+
+afterEach(async () => {
+	await inbox.clear?.();
+});
+
+afterAll(() => {
+	try { rmSync(DIR, { recursive: true }); } catch { /* ignore */ }
+});
+
+describe("TaskInbox.submit", () => {
+	it("accepts and returns a pending task", async () => {
+		const spec = {
+			id: "test-1",
+			kind: "once" as const,
+			priority: 5,
+			spec: {},
+		};
+		const record = await inbox.submit(spec);
+		expect(record.id).toBe("test-1");
+		expect(record.status).toBe("pending");
+		expect(record.submittedAt).toBeDefined();
+	});
+
+	it("rejects duplicate ids", async () => {
+		const spec = {
+			id: "dup-test",
+			kind: "once" as const,
+			priority: 5,
+			spec: {},
+		};
+		await inbox.submit(spec);
+		await expect(inbox.submit(spec)).rejects.toThrow();
+	});
+});
+
+describe("TaskInbox.list", () => {
+	it("returns all submitted tasks", async () => {
+		await inbox.submit({ id: "l1", kind: "once", priority: 1, spec: {} });
+		await inbox.submit({ id: "l2", kind: "once", priority: 2, spec: {} });
+		const records = await inbox.list();
+		expect(records.length).toBeGreaterThanOrEqual(2);
+	});
+
+	it("filters by status", async () => {
+		await inbox.submit({ id: "f1", kind: "once", priority: 1, spec: {} });
+		const pending = await inbox.list({ status: "pending" });
+		expect(pending.every((r) => r.status === "pending")).toBe(true);
+	});
+});
+
+describe("TaskInbox.claim", () => {
+	it("returns null when nothing is pending", async () => {
+		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
+		expect(lease).toBeNull();
+	});
+
+	it("returns a lease for a pending task", async () => {
+		await inbox.submit({ id: "claim-1", kind: "once", priority: 5, spec: {} });
+		const lease = await inbox.claim({ workerId: "w1", heartbeatIntervalMs: 30_000 });
+		expect(lease).not.toBeNull();
+		expect(lease!.taskId).toBe("claim-1");
+		expect(lease!.status).toBe("active");
+	});
+});

package/packages/autonomous-runtime/test/types.test.ts

@@ -0,0 +1,68 @@
+/**
+ * Tests for autonomous-runtime types.
+ */
+
+import { describe, it, expect } from "bun:test";
+import type {
+	TaskSpec,
+	TaskStatus,
+	TaskEvent,
+	TaskRecord,
+	LeaseStatus,
+	WorkerStatus,
+} from "../src/types.js";
+
+describe("TaskStatus enum", () => {
+	it("has all expected values", () => {
+		const values: TaskStatus[] = [
+			"pending",
+			"claimed",
+			"running",
+			"completed",
+			"failed",
+			"cancelled",
+		];
+		for (const v of values) {
+			expect(typeof v).toBe("string");
+		}
+	});
+});
+
+describe("LeaseStatus enum", () => {
+	it("has all expected values", () => {
+		const values: LeaseStatus[] = [
+			"active",
+			"renewed",
+			"released",
+			"expired",
+		];
+		for (const v of values) {
+			expect(typeof v).toBe("string");
+		}
+	});
+});
+
+describe("TaskSpec", () => {
+	it("accepts a minimal valid spec", () => {
+		const spec: TaskSpec = {
+			id: "task-1",
+			kind: "once",
+			priority: 5,
+			spec: {},
+		};
+		expect(spec.id).toBe("task-1");
+		expect(spec.kind).toBe("once");
+		expect(spec.priority).toBe(5);
+	});
+});
+
+describe("WorkerStatus", () => {
+	it("accepts a valid status", () => {
+		const status: WorkerStatus = {
+			workerId: "worker-1",
+			running: true,
+			heartbeatIntervalMs: 30_000,
+		};
+		expect(status.running).toBe(true);
+	});
+});

package/packages/cache-strategy/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/cache-strategy",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Smart caching with TTL and invalidation strategies (RFC-0022)",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc --noEmit",
+    "test": "bun test"
+  },
+  "devDependencies": {
+    "bun-types": "^1.0.0"
+  }
+}

package/packages/cache-strategy/test/cache.test.ts

@@ -0,0 +1,137 @@
+/**
+ * Cache Strategy Tests (RFC-0022)
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import { CacheStrategy } from "../src/index.js";
+
+describe("CacheStrategy", () => {
+  it("set and get work", () => {
+    const cache = new CacheStrategy({ strategy: "lru", maxSize: 10 });
+    cache.set("k1", "value1");
+    expect(cache.get("k1")).toBe("value1");
+  });
+
+  it("get returns undefined for missing key", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    expect(cache.get("nonexistent")).toBeUndefined();
+  });
+
+  it("has returns true for existing key", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    expect(cache.has("k1")).toBe(true);
+    expect(cache.has("nonexistent")).toBe(false);
+  });
+
+  it("delete removes entry", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    expect(cache.delete("k1")).toBe(true);
+    expect(cache.get("k1")).toBeUndefined();
+  });
+
+  it("clear removes all entries", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    cache.set("k2", "v2");
+    cache.clear();
+    expect(cache.size()).toBe(0);
+  });
+
+  it("enforces maxSize with LRU", () => {
+    const cache = new CacheStrategy({ strategy: "lru", maxSize: 3 });
+    cache.set("k1", 1);
+    cache.set("k2", 2);
+    cache.set("k3", 3);
+    cache.set("k4", 4); // evicts k1
+    expect(cache.has("k1")).toBe(false);
+    expect(cache.has("k4")).toBe(true);
+  });
+
+  it("enforces maxSize with LFU", () => {
+    const cache = new CacheStrategy({ strategy: "lfu", maxSize: 2 });
+    cache.set("k1", 1);
+    cache.set("k2", 2);
+    cache.get("k1"); // hit k1
+    cache.get("k1");
+    cache.set("k3", 3); // evicts k2 (least hits)
+    expect(cache.has("k1")).toBe(true);
+    expect(cache.has("k2")).toBe(false);
+  });
+
+  it("TTL expiration works", () => {
+    const cache = new CacheStrategy({ strategy: "ttl", defaultTtlMs: 10 });
+    cache.set("k1", "v1", 5); // 5ms TTL
+    expect(cache.get("k1")).toBe("v1");
+    // Note: entry expires immediately or after TTL — fast TTL
+    cache.set("k2", "v2", 1000); // 1s
+    expect(cache.get("k2")).toBe("v2");
+  });
+
+  it("tag-based invalidation", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("user:1:profile", "data1", undefined, ["user", "profile"]);
+    cache.set("user:1:settings", "data2", undefined, ["user", "settings"]);
+    cache.set("post:1:title", "title1", undefined, ["post"]);
+    const result = cache.invalidateByTag("user");
+    expect(result.invalidated).toBe(2);
+    expect(cache.has("user:1:profile")).toBe(false);
+    expect(cache.has("post:1:title")).toBe(true);
+  });
+
+  it("pattern invalidation", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("user:1", "u1");
+    cache.set("user:2", "u2");
+    cache.set("post:1", "p1");
+    const result = cache.invalidateByPattern(/^user:/);
+    expect(result.invalidated).toBe(2);
+    expect(cache.has("post:1")).toBe(true);
+  });
+
+  it("stats track hits and misses", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    cache.get("k1");
+    cache.get("nonexistent");
+    const stats = cache.stats();
+    expect(stats.hits).toBe(1);
+    expect(stats.misses).toBe(1);
+    expect(stats.hitRate).toBeCloseTo(0.5, 1);
+  });
+
+  it("resetStats clears counters", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    cache.get("k1");
+    cache.get("nonexistent");
+    cache.resetStats();
+    const stats = cache.stats();
+    expect(stats.hits).toBe(0);
+    expect(stats.misses).toBe(0);
+  });
+
+  it("getTagGroups returns all tag groups", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1", undefined, ["auth", "session"]);
+    cache.set("k2", "v2", undefined, ["auth"]);
+    const groups = cache.getTagGroups();
+    expect(groups.find((g) => g.tag === "auth")?.keys).toHaveLength(2);
+  });
+
+  it("size returns entry count", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("k1", "v1");
+    cache.set("k2", "v2");
+    expect(cache.size()).toBe(2);
+  });
+
+  it("keys returns all keys", () => {
+    const cache = new CacheStrategy({ strategy: "lru" });
+    cache.set("a", 1);
+    cache.set("b", 2);
+    expect(cache.keys()).toContain("a");
+    expect(cache.keys()).toContain("b");
+  });
+});

package/packages/capability-registry/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pi-harness/capability-registry",
+  "version": "0.10.30",
+  "description": "Capability Registry for pi-harness-runtime — tracks model capabilities and enables capability-based routing",
+  "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",
+    "capability",
+    "registry",
+    "model"
+  ],
+  "author": "",
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "^20.14.0",
+    "bun-types": "^1.0.0"
+  }
+}