pi-harness-runtime 1.1.440 → 1.1.441

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

@@ -1,202 +0,0 @@
-/**
- * Autonomous Refactor Tests (RFC-0092)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	detectRefactorings,
-	assessRisk,
-	calculatePriority,
-	createPlan,
-	filterByRisk,
-	groupByFile,
-	groupByType,
-} from "../src/index.js";
-import type { RefactorFinding } from "../src/index.js";
-
-const makeFinding = (
-	overrides?: Partial<RefactorFinding>,
-): RefactorFinding => ({
-	id: `f${Math.random().toString(36).slice(2)}`,
-	type: "extract-method",
-	file: "src/test.ts",
-	location: { line: 10, column: 1 },
-	description: "Test finding",
-	risk: "low",
-	confidence: 0.7,
-	...overrides,
-});
-
-describe("detectRefactorings", () => {
-	it("detects magic literals", () => {
-		const files = [{ path: "src/test.ts", content: "const timeout = 5000;" }];
-		const findings = detectRefactorings(files);
-		expect(findings.some((f) => f.type === "replace-magic-literal")).toBe(true);
-	});
-
-	it("detects long functions", () => {
-		const lines = ["function longFunc() {"];
-		for (let i = 0; i < 38; i++) lines.push("  const x = " + i + ";");
-		lines.push("}");
-		const files = [{ path: "src/test.ts", content: lines.join("\n") }];
-		const findings = detectRefactorings(files);
-		expect(findings.some((f) => f.type === "extract-method")).toBe(true);
-	});
-
-	it("detects nested conditionals", () => {
-		const content = [
-			"if (a) {",
-			"  if (b) {",
-			"    if (c) {",
-			"      if (d) { console.log(1); }",
-			"    }",
-			"  }",
-			"}",
-		].join("\n");
-		const files = [{ path: "src/test.ts", content }];
-		const findings = detectRefactorings(files);
-		expect(findings.some((f) => f.type === "simplify-conditional")).toBe(true);
-	});
-
-	it("returns empty for clean code", () => {
-		const files = [
-			{
-				path: "src/test.ts",
-				content: "const x = 1;\nconst y = 2;\nconst sum = x + y;",
-			},
-		];
-		const findings = detectRefactorings(files);
-		expect(findings.length).toBeLessThanOrEqual(3);
-	});
-
-	it("limits magic literal findings per file", () => {
-		const lines = Array.from({ length: 20 }, (_, i) => `const val${i} = 999;`);
-		const files = [{ path: "src/test.ts", content: lines.join("\n") }];
-		const findings = detectRefactorings(files);
-		expect(
-			findings.filter((f) => f.type === "replace-magic-literal").length,
-		).toBeLessThanOrEqual(5);
-	});
-});
-
-describe("assessRisk", () => {
-	it("returns finding risk", () => {
-		expect(assessRisk(makeFinding({ risk: "high" }))).toBe("high");
-	});
-});
-
-describe("calculatePriority", () => {
-	it("higher for high-confidence", () => {
-		const high = makeFinding({ confidence: 0.9, risk: "low" });
-		const low = makeFinding({ confidence: 0.3, risk: "low" });
-		expect(calculatePriority(high)).toBeGreaterThan(calculatePriority(low));
-	});
-
-	it("higher for high-risk at same confidence", () => {
-		const critical = makeFinding({ confidence: 0.5, risk: "critical" });
-		const low = makeFinding({ confidence: 0.5, risk: "low" });
-		expect(calculatePriority(critical)).toBeGreaterThan(calculatePriority(low));
-	});
-
-	it("returns value between 0 and 1", () => {
-		const p = calculatePriority(
-			makeFinding({ confidence: 0.7, risk: "medium" }),
-		);
-		expect(p).toBeGreaterThanOrEqual(0);
-		expect(p).toBeLessThanOrEqual(1);
-	});
-});
-
-describe("createPlan", () => {
-	it("creates plan with findings", () => {
-		const findings = [makeFinding({ id: "f1" }), makeFinding({ id: "f2" })];
-		const plan = createPlan(findings);
-		expect(plan.findings).toHaveLength(2);
-		expect(plan.priorityOrder).toContain("f1");
-		expect(plan.priorityOrder).toContain("f2");
-	});
-
-	it("limits to maxFindings", () => {
-		const findings = Array.from({ length: 100 }, (_, i) =>
-			makeFinding({ id: `f${i}`, confidence: 1 - i / 100 }),
-		);
-		const plan = createPlan(findings, { maxFindings: 20 });
-		expect(plan.findings.length).toBeLessThanOrEqual(20);
-	});
-
-	it("filters by risk threshold", () => {
-		const findings = [
-			makeFinding({ id: "low", risk: "low" }),
-			makeFinding({ id: "high", risk: "high" }),
-			makeFinding({ id: "critical", risk: "critical" }),
-		];
-		const plan = createPlan(findings, { riskThreshold: "medium" });
-		expect(plan.findings.some((f) => f.id === "low")).toBe(true);
-		expect(plan.findings.some((f) => f.id === "high")).toBe(false);
-		expect(plan.findings.some((f) => f.id === "critical")).toBe(false);
-	});
-
-	it("includes blockers when preserveBehavior", () => {
-		const plan = createPlan([], { preserveBehavior: true });
-		expect(plan.blockers.length).toBeGreaterThan(0);
-	});
-
-	it("estimates positive impact", () => {
-		const findings = [
-			makeFinding({ risk: "medium" }),
-			makeFinding({ risk: "high" }),
-		];
-		const plan = createPlan(findings);
-		expect(plan.estimatedImpact.complexityReduction).toBeGreaterThan(0);
-	});
-});
-
-describe("filterByRisk", () => {
-	it("keeps low and medium when threshold is medium", () => {
-		const findings = [
-			makeFinding({ id: "low", risk: "low" }),
-			makeFinding({ id: "medium", risk: "medium" }),
-			makeFinding({ id: "high", risk: "high" }),
-		];
-		const filtered = filterByRisk(findings, "medium");
-		expect(filtered.map((f) => f.id)).toEqual(["low", "medium"]);
-	});
-
-	it("returns all when threshold is critical", () => {
-		const findings = [
-			makeFinding({ risk: "low" }),
-			makeFinding({ risk: "critical" }),
-		];
-		expect(filterByRisk(findings, "critical")).toHaveLength(2);
-	});
-});
-
-describe("groupByFile", () => {
-	it("groups findings by file", () => {
-		const findings = [
-			makeFinding({ id: "f1", file: "src/a.ts" }),
-			makeFinding({ id: "f2", file: "src/a.ts" }),
-			makeFinding({ id: "f3", file: "src/b.ts" }),
-		];
-		const groups = groupByFile(findings);
-		expect(groups.get("src/a.ts")).toHaveLength(2);
-		expect(groups.get("src/b.ts")).toHaveLength(1);
-	});
-
-	it("handles empty array", () => {
-		expect(groupByFile([]).size).toBe(0);
-	});
-});
-
-describe("groupByType", () => {
-	it("groups by type", () => {
-		const findings = [
-			makeFinding({ id: "f1", type: "extract-method" }),
-			makeFinding({ id: "f2", type: "extract-method" }),
-			makeFinding({ id: "f3", type: "rename-variable" }),
-		];
-		const groups = groupByType(findings);
-		expect(groups.get("extract-method")).toHaveLength(2);
-		expect(groups.get("rename-variable")).toHaveLength(1);
-	});
-});

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

@@ -1,95 +0,0 @@
-/// <reference types="bun-types" />
-/**
- * Tests for autonomous-runtime types.
- */
-
-import { describe, it, expect } from "bun:test";
-import type {
-	TaskStatus,
-	TaskEvent,
-	TaskRecord,
-	TaskLease,
-	WorkerHeartbeat,
-} from "../src/types.js";
-
-describe("TaskStatus", () => {
-	it("has all expected values", () => {
-		const values: TaskStatus[] = [
-			"queued",
-			"claimed",
-			"running",
-			"waiting_approval",
-			"waiting_quota",
-			"retrying",
-			"completed",
-			"failed",
-			"dead_letter",
-		];
-		for (const v of values) {
-			expect(typeof v).toBe("string");
-		}
-	});
-});
-
-describe("TaskEvent", () => {
-	it("accepts a minimal valid event", () => {
-		const event: TaskEvent = {
-			ts: new Date().toISOString(),
-			kind: "started",
-		};
-		expect(event.kind).toBe("started");
-		expect(typeof event.ts).toBe("string");
-	});
-});
-
-describe("TaskRecord", () => {
-	it("accepts a minimal valid record", () => {
-		const now = new Date().toISOString();
-		const record: TaskRecord = {
-			id: "task-1",
-			objective: "Do the thing",
-			acceptanceCriteria: ["it is done"],
-			source: { kind: "manual", createdBy: "test" },
-			priority: 2,
-			capabilities: [],
-			approvalClass: "automatic_read_only",
-			status: "queued",
-			attempts: 0,
-			maxAttempts: 3,
-			createdAt: now,
-			updatedAt: now,
-			history: [],
-		};
-		expect(record.id).toBe("task-1");
-		expect(record.status).toBe("queued");
-	});
-});
-
-describe("TaskLease", () => {
-	it("accepts a valid lease", () => {
-		const now = new Date().toISOString();
-		const lease: TaskLease = {
-			taskId: "task-1",
-			workerId: "worker-1",
-			acquiredAt: now,
-			expiresAt: now,
-			heartbeatAt: now,
-			attempt: 1,
-		};
-		expect(lease.workerId).toBe("worker-1");
-	});
-});
-
-describe("WorkerHeartbeat", () => {
-	it("accepts a valid heartbeat", () => {
-		const now = new Date().toISOString();
-		const heartbeat: WorkerHeartbeat = {
-			workerId: "worker-1",
-			startedAt: now,
-			lastBeatAt: now,
-			capacity: 2,
-			inflightTaskIds: [],
-		};
-		expect(heartbeat.workerId).toBe("worker-1");
-	});
-});

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

@@ -1,137 +0,0 @@
-/**
- * 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/test/registry.test.ts

@@ -1,204 +0,0 @@
-/**
- * Capability Registry Tests (RFC-0051)
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-	createCapabilityRegistry,
-	type InMemoryCapabilityRegistry,
-	DEFAULT_CAPABILITIES,
-	queryCapabilities,
-	findBestModel,
-	filterByLatency,
-	LATENCY_RANK,
-} from "../src/index.js";
-import type { CapabilityProfile, Capability } from "../src/types.js";
-
-describe("CapabilityRegistry", () => {
-	let registry: InMemoryCapabilityRegistry;
-
-	beforeEach(() => {
-		registry = createCapabilityRegistry(true);
-	});
-
-	describe("initialization", () => {
-		it("should load default capabilities", () => {
-			const providers = registry.listProviders();
-			expect(providers.length).toBeGreaterThan(0);
-		});
-
-		it("should have OpenAI providers", () => {
-			const providers = registry.listProviders();
-			expect(providers).toContain("openai");
-		});
-
-		it("should have Anthropic providers", () => {
-			const providers = registry.listProviders();
-			expect(providers).toContain("anthropic");
-		});
-	});
-
-	describe("register and unregister", () => {
-		it("should register new capabilities", () => {
-			const newCaps: CapabilityProfile[] = [
-				{
-					capability: "code_generation",
-					score: 90,
-					latency: "fast",
-					contextWindow: 100000,
-					maxOutputTokens: 4096,
-				},
-			];
-
-			registry.register("test-provider", "test-model", newCaps);
-
-			const caps = registry.getCapabilities("test-provider", "test-model");
-			expect(caps).toHaveLength(1);
-			expect(caps[0].capability).toBe("code_generation");
-			expect(caps[0].score).toBe(90);
-		});
-
-		it("should unregister capabilities", () => {
-			registry.unregister("openai", "gpt-4o");
-
-			const caps = registry.getCapabilities("openai", "gpt-4o");
-			expect(caps).toHaveLength(0);
-		});
-
-		it("should track events", () => {
-			const events: any[] = [];
-			registry.onEvent((e) => events.push(e));
-
-			const caps: CapabilityProfile[] = [
-				{
-					capability: "planning",
-					score: 85,
-					latency: "fast",
-					contextWindow: 50000,
-					maxOutputTokens: 2048,
-				},
-			];
-
-			registry.register("event-test", "model-v1", caps);
-
-			expect(events).toContainEqual({
-				type: "capability.registered",
-				providerId: "event-test",
-				modelId: "model-v1",
-				count: 1,
-			});
-		});
-	});
-
-	describe("query", () => {
-		it("should query by capability", () => {
-			const results = registry.query("code_generation");
-			expect(results.length).toBeGreaterThan(0);
-		});
-
-		it("should filter by minimum score", () => {
-			const results = registry.query("code_generation", { minScore: 95 });
-			expect(results.every((r) => r.profile.score >= 95)).toBe(true);
-		});
-
-		it("should filter by latency", () => {
-			const results = registry.query("code_generation", { maxLatency: "fast" });
-			expect(
-				results.every(
-					(r) => LATENCY_RANK[r.profile.latency] <= LATENCY_RANK["fast"],
-				),
-			).toBe(true);
-		});
-
-		it("should filter by context window", () => {
-			const results = registry.query("code_generation", {
-				requiresContextWindow: 200000,
-			});
-			expect(results.every((r) => r.profile.contextWindow >= 200000)).toBe(
-				true,
-			);
-		});
-
-		it("should sort by score descending", () => {
-			const results = registry.query("code_generation");
-			for (let i = 1; i < results.length; i++) {
-				expect(results[i - 1].profile.score).toBeGreaterThanOrEqual(
-					results[i].profile.score,
-				);
-			}
-		});
-
-		it("should emit query event", () => {
-			const events: any[] = [];
-			registry.onEvent((e) => events.push(e));
-
-			registry.query("code_generation");
-
-			expect(events).toContainEqual(
-				expect.objectContaining({
-					type: "capability.queried",
-					capability: "code_generation",
-				}),
-			);
-		});
-	});
-
-	describe("listProviders and listModels", () => {
-		it("should list providers", () => {
-			const providers = registry.listProviders();
-			expect(Array.isArray(providers)).toBe(true);
-			expect(providers.length).toBeGreaterThan(0);
-		});
-
-		it("should list models for a provider", () => {
-			const models = registry.listModels("openai");
-			expect(models).toContain("gpt-4o");
-		});
-
-		it("should return empty array for unknown provider", () => {
-			const models = registry.listModels("unknown-provider");
-			expect(models).toHaveLength(0);
-		});
-	});
-
-	describe("findBestModel", () => {
-		it("should find the highest scoring model", () => {
-			const candidates = registry.query("code_generation");
-			const best = findBestModel(candidates);
-
-			expect(best).toBeDefined();
-			const maxScore = Math.max(...candidates.map((c) => c.profile.score));
-			expect(best!.profile.score).toBe(maxScore);
-		});
-
-		it("should return undefined for empty array", () => {
-			const result = findBestModel([]);
-			expect(result).toBeUndefined();
-		});
-	});
-
-	describe("filterByLatency", () => {
-		it("should filter to fast latency", () => {
-			const candidates = registry.query("code_generation");
-			const fast = filterByLatency(candidates, "fast");
-
-			expect(fast.every((c) => c.profile.latency === "fast")).toBe(true);
-		});
-
-		it("should sort by quality when preference is quality", () => {
-			const candidates = registry.query("code_generation");
-			const sorted = filterByLatency(candidates, "quality");
-
-			expect(sorted[0].profile.score).toBeGreaterThanOrEqual(
-				sorted[1].profile.score,
-			);
-		});
-	});
-});
-
-describe("LATENCY_RANK", () => {
-	it("should have correct ordering", () => {
-		expect(LATENCY_RANK["fast"]).toBeLessThan(LATENCY_RANK["medium"]);
-		expect(LATENCY_RANK["medium"]).toBeLessThan(LATENCY_RANK["slow"]);
-	});
-});