pi-harness-runtime 1.1.440 → 1.1.441

package/packages/prompt-versioning/test/versioning.test.ts

@@ -1,112 +0,0 @@
-/**
- * Prompt Versioning Tests (RFC-0019)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import { PromptVersioning } from "../src/index.js";
-
-describe("PromptVersioning", () => {
-  let pv: PromptVersioning;
-
-  beforeEach(() => { pv = new PromptVersioning(); });
-
-  it("creates a prompt with initial version", () => {
-    const record = pv.createPrompt("login-prompt", "Hello {{name}}");
-    expect(record.name).toBe("login-prompt");
-    expect(record.versions).toHaveLength(1);
-    expect(record.activeVersion).toBe(record.versions[0].version);
-  });
-
-  it("addVersion creates a new version", () => {
-    const record = pv.createPrompt("greet", "Hi {{name}}");
-    const v2 = pv.addVersion(record.id, "Hello {{name}}");
-    expect(v2.version).not.toBe(record.versions[0].version);
-    expect(record.versions).toHaveLength(2);
-    expect(record.activeVersion).toBe(v2.version);
-  });
-
-  it("getVersion returns correct version", () => {
-    const record = pv.createPrompt("test", "v1");
-    const v2 = pv.addVersion(record.id, "v2");
-    const found = pv.getVersion(record.id, v2.version);
-    expect(found?.prompt).toBe("v2");
-  });
-
-  it("getVersion returns active when no version specified", () => {
-    const record = pv.createPrompt("test", "v1");
-    pv.addVersion(record.id, "v2");
-    const found = pv.getVersion(record.id);
-    expect(found?.prompt).toBe("v2");
-  });
-
-  it("listVersions returns all versions", () => {
-    const record = pv.createPrompt("test", "v1");
-    pv.addVersion(record.id, "v2");
-    pv.addVersion(record.id, "v3");
-    const versions = pv.listVersions(record.id);
-    expect(versions).toHaveLength(3);
-  });
-
-  it("diff shows added and removed lines", () => {
-    const record = pv.createPrompt("test", "line1\nline2\nline3");
-    pv.addVersion(record.id, "line1\nnewLine\nline3");
-    const d = pv.diff(record.id, record.versions[0].version, record.versions[1].version);
-    expect(d).not.toBeNull();
-    expect(d!.added).toBe(1);
-    expect(d!.removed).toBe(1);
-  });
-
-  it("rollback reverts to previous version", () => {
-    const record = pv.createPrompt("test", "v1");
-    const v2 = pv.addVersion(record.id, "v2");
-    const result = pv.rollback(record.id, record.versions[0].version);
-    expect(result?.rolledBackTo).toBe(record.versions[0].version);
-    expect(result?.previousVersion).toBe(v2.version);
-  });
-
-  it("rollback returns null for unknown version", () => {
-    const record = pv.createPrompt("test", "v1");
-    const result = pv.rollback(record.id, "nonexistent");
-    expect(result).toBeNull();
-  });
-
-  it("delete removes prompt when allowed", () => {
-    pv = new PromptVersioning({ allowDelete: true });
-    const record = pv.createPrompt("test", "content");
-    expect(pv.delete(record.id)).toBe(true);
-    expect(pv.getVersion(record.id)).toBeNull();
-  });
-
-  it("delete returns false when not allowed", () => {
-    const record = pv.createPrompt("test", "content");
-    expect(pv.delete(record.id)).toBe(false);
-  });
-
-  it("enforces maxVersions", () => {
-    pv = new PromptVersioning({ maxVersions: 3 });
-    const record = pv.createPrompt("test", "v1");
-    for (let i = 2; i <= 10; i++) pv.addVersion(record.id, `v${i}`);
-    expect(record.versions).toHaveLength(3);
-  });
-
-  it("getStats returns correct stats", () => {
-    const record = pv.createPrompt("test", "v1");
-    pv.addVersion(record.id, "v2");
-    const stats = pv.getStats(record.id);
-    expect(stats?.versionCount).toBe(2);
-  });
-
-  it("getStats returns null for unknown prompt", () => {
-    expect(pv.getStats("nonexistent")).toBeNull();
-  });
-
-  it("listPrompts returns all prompts", () => {
-    pv.createPrompt("a", "content a");
-    pv.createPrompt("b", "content b");
-    expect(pv.listPrompts()).toHaveLength(2);
-  });
-
-  it("throws for unknown promptId on addVersion", () => {
-    expect(() => pv.addVersion("nonexistent", "content")).toThrow();
-  });
-});

package/packages/provider-adapter-sdk/test/sdk.test.ts

@@ -1,220 +0,0 @@
-/**
- * Provider Adapter SDK - Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	createProviderBuilder,
-	createAdapterRegistry,
-	createAdapterTester,
-	AdapterBuilder,
-	AdapterRegistry,
-	AdapterTester,
-	SDK_VERSION,
-} from "../src/index.js";
-import type { ProviderAdapter } from "../src/types.js";
-
-describe("ProviderAdapterSDK", () => {
-	describe("SDK_VERSION", () => {
-		it("should export SDK_VERSION", () => {
-			expect(SDK_VERSION).toBeDefined();
-			expect(typeof SDK_VERSION).toBe("string");
-		});
-	});
-
-	describe("createProviderBuilder", () => {
-		it("should create a provider builder instance", () => {
-			const builder = createProviderBuilder("test-provider");
-			expect(builder).toBeInstanceOf(AdapterBuilder);
-		});
-
-		it("should configure provider with complete method", () => {
-			const builder = createProviderBuilder("test-provider");
-			const adapter = builder
-				.id("test-adapter")
-				.complete(async (prompt) => ({ content: `Response to: ${prompt}` }))
-				.build();
-
-			expect(adapter).toBeDefined();
-			expect(adapter.name).toBe("test-provider");
-			expect(adapter.id).toBe("test-adapter");
-		});
-
-		it("should configure with invoke method", () => {
-			const builder = createProviderBuilder("invoke-provider");
-			const adapter = builder
-				.id("invoke-adapter")
-				.invoke(async () => ({ content: "test response" }))
-				.build();
-
-			expect(adapter).toBeDefined();
-		});
-
-		it("should set models", () => {
-			const builder = createProviderBuilder("multi-model");
-			const adapter = builder
-				.id("multi-model-adapter")
-				.models("gpt-4", "gpt-3.5")
-				.complete(async () => ({ content: "test" }))
-				.build();
-
-			expect(adapter.getModels()).toContain("gpt-4");
-			expect(adapter.getModels()).toContain("gpt-3.5");
-		});
-
-		it("should set capabilities", () => {
-			const builder = createProviderBuilder("capable-adapter");
-			const adapter = builder
-				.id("capable")
-				.capabilities("code", "review")
-				.complete(async () => ({ content: "test" }))
-				.build();
-
-			expect(adapter.getCapabilities()).toContain("code");
-			expect(adapter.getCapabilities()).toContain("review");
-		});
-
-		it("should throw on build without id", () => {
-			const builder = createProviderBuilder("no-id");
-			expect(() =>
-				builder.complete(async () => ({ content: "test" })).build(),
-			).toThrow();
-		});
-	});
-
-	describe("createAdapterRegistry", () => {
-		let registry: AdapterRegistry;
-
-		beforeEach(() => {
-			registry = createAdapterRegistry();
-		});
-
-		it("should create an adapter registry instance", () => {
-			expect(registry).toBeInstanceOf(AdapterRegistry);
-		});
-
-		it("should register and retrieve adapters", async () => {
-			const adapter: ProviderAdapter = {
-				name: "test-adapter",
-				provider: "openai",
-				complete: async () => ({ content: "test" }),
-			};
-
-			await registry.register(adapter);
-			const retrieved = registry.get("test-adapter");
-
-			expect(retrieved).toBeDefined();
-		});
-
-		it("should list all registered adapters", async () => {
-			const adapter1: ProviderAdapter = {
-				name: "adapter-1",
-				provider: "openai",
-				complete: async () => ({ content: "test1" }),
-			};
-
-			const adapter2: ProviderAdapter = {
-				name: "adapter-2",
-				provider: "anthropic",
-				complete: async () => ({ content: "test2" }),
-			};
-
-			await registry.register(adapter1);
-			await registry.register(adapter2);
-
-			const all = registry.listAll();
-			expect(all.length).toBeGreaterThanOrEqual(2);
-		});
-
-		it("should unregister adapters", async () => {
-			const adapter: ProviderAdapter = {
-				name: "removable",
-				provider: "openai",
-				complete: async () => ({ content: "test" }),
-			};
-
-			await registry.register(adapter);
-			expect(registry.get("removable")).toBeDefined();
-
-			await registry.unregister("removable");
-			expect(registry.get("removable")).toBeUndefined();
-		});
-
-		it("should check if adapter exists", async () => {
-			const adapter: ProviderAdapter = {
-				name: "checkable",
-				provider: "openai",
-				complete: async () => ({ content: "test" }),
-			};
-
-			await registry.register(adapter);
-			expect(registry.has("checkable")).toBe(true);
-			expect(registry.has("non-existent")).toBe(false);
-		});
-
-		it("should throw on duplicate registration", async () => {
-			const adapter: ProviderAdapter = {
-				name: "duplicate",
-				provider: "openai",
-				complete: async () => ({ content: "test" }),
-			};
-
-			await registry.register(adapter);
-			await expect(registry.register(adapter)).rejects.toThrow();
-		});
-	});
-
-	describe("createAdapterTester", () => {
-		it("should create an adapter tester instance", () => {
-			const tester = createAdapterTester({} as any);
-			expect(tester).toBeInstanceOf(AdapterTester);
-		});
-	});
-
-	describe("AdapterBuilder", () => {
-		it("should build adapter with configuration", () => {
-			const builder = createProviderBuilder("configured-adapter");
-
-			const adapter = builder
-				.id("configured")
-				.complete(async (prompt) => ({ content: `Config: ${prompt}` }))
-				.build();
-
-			expect(adapter).toBeDefined();
-		});
-
-		it("should validate required methods", () => {
-			const builder = createProviderBuilder("incomplete");
-
-			expect(() => builder.build()).toThrow();
-		});
-	});
-
-	describe("BuiltAdapter", () => {
-		it("should have invoke method", async () => {
-			const builder = createProviderBuilder("invoke-test");
-			const adapter = builder
-				.id("invoke-test")
-				.complete(async () => ({ content: "hello" }))
-				.build();
-
-			const result = await adapter.invoke({
-				model: "test",
-				messages: [{ role: "user", content: "test" }],
-			});
-
-			expect(result.response.content).toBe("hello");
-		});
-
-		it("should parse errors", () => {
-			const builder = createProviderBuilder("error-test");
-			const adapter = builder
-				.id("error-test")
-				.complete(async () => ({ content: "test" }))
-				.build();
-
-			const error = adapter.parseError(new Error("rate limit exceeded"));
-			expect(error).toBeDefined();
-		});
-	});
-});