pi-harness-runtime 1.1.440 → 1.1.441

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

@@ -1,198 +0,0 @@
-/**
- * Context Manager Tests (RFC-0010)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-	DEFAULT_POLICY,
-	estimatePressure,
-	getPressureLevel,
-	createSessionScope,
-	setTTL,
-	addToScope,
-	evictExpired,
-	prioritize,
-	estimateTokens,
-	calculateTotalTokens,
-	compactContext,
-	generateResumePrompt,
-	formatResumeMarkdown,
-} from "../src/index.js";
-
-const makeItem = (
-	overrides?: Partial<import("../src/index.js").ContextItem>,
-): import("../src/index.js").ContextItem => ({
-	id: `item-${Math.random().toString(36).slice(2)}`,
-	role: "user",
-	content: "Test content",
-	tokens: 10,
-	priority: 5,
-	timestamp: Date.now(),
-	...overrides,
-});
-
-describe("DEFAULT_POLICY", () => {
-	it("has threshold values", () => {
-		expect(DEFAULT_POLICY.warningThreshold).toBe(0.6);
-		expect(DEFAULT_POLICY.compactThreshold).toBe(0.7);
-		expect(DEFAULT_POLICY.hardStopThreshold).toBe(0.85);
-	});
-});
-
-describe("estimatePressure", () => {
-	it("returns ratio", () => expect(estimatePressure(5000, 10000)).toBe(0.5));
-	it("caps at 1", () => expect(estimatePressure(15000, 10000)).toBe(1));
-	it("handles zero max", () => expect(estimatePressure(100, 0)).toBe(1));
-});
-
-describe("getPressureLevel", () => {
-	it("normal below warning", () =>
-		expect(getPressureLevel(0.3)).toBe("normal"));
-	it("warning above warningThreshold", () =>
-		expect(getPressureLevel(0.65)).toBe("warning"));
-	it("compact above compactThreshold", () =>
-		expect(getPressureLevel(0.75)).toBe("compact"));
-	it("hard_stop above hardStopThreshold", () =>
-		expect(getPressureLevel(0.9)).toBe("hard_stop"));
-	it("uses custom policy", () => {
-		const custom = {
-			warningThreshold: 0.1,
-			compactThreshold: 0.2,
-			hardStopThreshold: 0.3,
-		};
-		expect(getPressureLevel(0.25, custom)).toBe("compact");
-	});
-});
-
-describe("createSessionScope", () => {
-	it("creates with defaults", () => {
-		const scope = createSessionScope("session-1");
-		expect(scope.id).toBe("session-1");
-		expect(scope.items).toEqual([]);
-		expect(scope.ttlMs).toBe(30 * 60 * 1000);
-		expect(scope.createdAt).toBeGreaterThan(0);
-	});
-});
-
-describe("setTTL", () => {
-	it("updates ttl", () => {
-		const scope = createSessionScope("s1");
-		const updated = setTTL(scope, 60_000);
-		expect(updated.ttlMs).toBe(60_000);
-		expect(updated.id).toBe("s1");
-	});
-});
-
-describe("addToScope", () => {
-	it("appends item", () => {
-		const scope = createSessionScope("s1");
-		const item = makeItem({ id: "i1" });
-		const updated = addToScope(scope, item);
-		expect(updated.items).toHaveLength(1);
-		expect(updated.items[0].id).toBe("i1");
-	});
-});
-
-describe("evictExpired", () => {
-	it("removes expired items", () => {
-		const scope = createSessionScope("s1");
-		const item1 = makeItem({ id: "i1", expiresAt: Date.now() + 10000 });
-		const item2 = makeItem({ id: "i2", expiresAt: Date.now() - 1000 });
-		const updated = addToScope(addToScope(scope, item1), item2);
-		const evicted = evictExpired(updated);
-		expect(evicted.items.map((i) => i.id)).toEqual(["i1"]);
-	});
-
-	it("keeps items without expiry", () => {
-		const scope = createSessionScope("s1");
-		const item = makeItem({ id: "i1" });
-		const updated = addToScope(scope, item);
-		expect(evictExpired(updated).items).toHaveLength(1);
-	});
-});
-
-describe("prioritize", () => {
-	it("sorts by priority ascending", () => {
-		const items = [
-			makeItem({ id: "low", priority: 9 }),
-			makeItem({ id: "high", priority: 1 }),
-			makeItem({ id: "mid", priority: 5 }),
-		];
-		const sorted = prioritize(items);
-		expect(sorted.map((i) => i.id)).toEqual(["high", "mid", "low"]);
-	});
-
-	it("respects limit", () => {
-		const items = [
-			makeItem({ id: "a", priority: 3 }),
-			makeItem({ id: "b", priority: 1 }),
-			makeItem({ id: "c", priority: 2 }),
-		];
-		expect(prioritize(items, 2)).toHaveLength(2);
-	});
-});
-
-describe("estimateTokens", () => {
-	it("counts chars/4", () => expect(estimateTokens("abcdefgh")).toBe(2));
-	it("rounds up", () => expect(estimateTokens("abc")).toBe(1));
-});
-
-describe("calculateTotalTokens", () => {
-	it("sums tokens", () => {
-		const items = [makeItem({ tokens: 10 }), makeItem({ tokens: 20 })];
-		expect(calculateTotalTokens(items)).toBe(30);
-	});
-	it("empty returns 0", () => expect(calculateTotalTokens([])).toBe(0));
-});
-
-describe("compactContext", () => {
-	it("extracts decisions", () => {
-		const items = [makeItem({ content: "DECISION: use tRPC for API" })];
-		const result = compactContext(items, 1000);
-		expect(result.decisions.length).toBeGreaterThan(0);
-	});
-
-	it("extracts questions", () => {
-		const items = [
-			makeItem({
-				content: "Should we use Redis? TODO: decide caching strategy",
-			}),
-		];
-		const result = compactContext(items, 1000);
-		expect(result.openQuestions.length).toBeGreaterThan(0);
-	});
-
-	it("respects maxTokens threshold", () => {
-		const items = [makeItem({ tokens: 100 })];
-		const result = compactContext(items, 50);
-		expect(result.remainingTokens).toBeLessThan(100);
-	});
-});
-
-describe("generateResumePrompt", () => {
-	it("creates prompt from result", () => {
-		const result = compactContext([], 1000);
-		const prompt = generateResumePrompt(result, "Continue with API");
-		expect(prompt.nextAction).toBe("Continue with API");
-		expect(prompt.decisions).toEqual([]);
-	});
-});
-
-describe("formatResumeMarkdown", () => {
-	it("includes headings", () => {
-		const prompt = generateResumePrompt(
-			{
-				decisions: ["Use tRPC"],
-				openQuestions: ["Which DB?"],
-				taskProgress: {},
-				remainingTokens: 100,
-				compactedContent: "",
-			},
-			"Continue",
-		);
-		const md = formatResumeMarkdown(prompt);
-		expect(md).toContain("# Resume Prompt");
-		expect(md).toContain("## Decisions");
-		expect(md).toContain("## Next Action");
-	});
-});

package/packages/contracts/test/delegation.test.ts

@@ -1,350 +0,0 @@
-/**
- * Delegation Assessment Tests
- */
-
-import { describe, it, expect, beforeEach } from "bun:test";
-import {
-  shouldTriggerAssessment,
-  DEFAULT_DELEGATION_TRIGGERS,
-  type ScopeFacts,
-  type DelegationTriggerConfig,
-  type DelegationStrategy,
-  type WorkGroup,
-} from "../src/delegation.js";
-import {
-  partitionWork,
-  detectOwnershipConflicts,
-  getUnownedFiles,
-  updateGroupStatus,
-  areAllGroupsComplete,
-  DEFAULT_PARTITION_CONFIG,
-} from "../src/work-partitioner.js";
-
-describe("Delegation Triggers", () => {
-  it("should trigger on 10+ files", () => {
-    const facts: ScopeFacts = {
-      estimatedFiles: 15,
-      observedFiles: 15,
-      estimatedCallSites: 20,
-      observedCallSites: 20,
-      independentComponents: 1,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: {},
-      fingerprint: "",
-    };
-
-    expect(shouldTriggerAssessment(facts)).toBe(true);
-  });
-
-  it("should trigger on 50+ call sites", () => {
-    const facts: ScopeFacts = {
-      estimatedFiles: 5,
-      observedFiles: 5,
-      estimatedCallSites: 60,
-      observedCallSites: 60,
-      independentComponents: 1,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: {},
-      fingerprint: "",
-    };
-
-    expect(shouldTriggerAssessment(facts)).toBe(true);
-  });
-
-  it("should trigger on 2+ independent components", () => {
-    const facts: ScopeFacts = {
-      estimatedFiles: 5,
-      observedFiles: 5,
-      estimatedCallSites: 10,
-      observedCallSites: 10,
-      independentComponents: 3,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: {},
-      fingerprint: "",
-    };
-
-    expect(shouldTriggerAssessment(facts)).toBe(true);
-  });
-
-  it("should not trigger on small scope", () => {
-    const facts: ScopeFacts = {
-      estimatedFiles: 3,
-      observedFiles: 3,
-      estimatedCallSites: 5,
-      observedCallSites: 5,
-      independentComponents: 1,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: {},
-      fingerprint: "",
-    };
-
-    expect(shouldTriggerAssessment(facts)).toBe(false);
-  });
-
-  it("should respect custom config", () => {
-    const facts: ScopeFacts = {
-      estimatedFiles: 5,
-      observedFiles: 5,
-      estimatedCallSites: 10,
-      observedCallSites: 10,
-      independentComponents: 1,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: {},
-      fingerprint: "",
-    };
-
-    const customConfig: DelegationTriggerConfig = {
-      minFiles: 5,
-      minCallSites: 10,
-      minIndependentComponents: 1,
-      assessOnDiscovery: true,
-    };
-
-    expect(shouldTriggerAssessment(facts, customConfig)).toBe(true);
-  });
-});
-
-describe("Work Partitioning", () => {
-  it("should partition files by directory", () => {
-    const files = [
-      "src/components/Button.ts",
-      "src/components/Modal.ts",
-      "src/utils/helper.ts",
-      "src/utils/format.ts",
-    ];
-
-    const facts: ScopeFacts = {
-      estimatedFiles: 4,
-      observedFiles: 4,
-      estimatedCallSites: 10,
-      observedCallSites: 10,
-      independentComponents: 2,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: { ".ts": 4 },
-      fingerprint: "",
-    };
-
-    const groups = partitionWork(files, facts);
-
-    expect(groups.length).toBe(2);
-    expect(groups.some((g) => g.description.includes("components"))).toBe(true);
-    expect(groups.some((g) => g.description.includes("utils"))).toBe(true);
-  });
-
-  it("should limit files per group", () => {
-    const files = Array.from({ length: 40 }, (_, i) => `src/dir${i % 3}/file${i}.ts`);
-
-    const facts: ScopeFacts = {
-      estimatedFiles: 40,
-      observedFiles: 40,
-      estimatedCallSites: 100,
-      observedCallSites: 100,
-      independentComponents: 3,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: { ".ts": 40 },
-      fingerprint: "",
-    };
-
-    const groups = partitionWork(files, facts);
-
-    // Should have multiple groups (max 15 files per group for 40 files = 3 groups)
-    expect(groups.length).toBeGreaterThanOrEqual(3);
-    for (const group of groups) {
-      expect(group.ownedPaths.length).toBeLessThanOrEqual(
-        DEFAULT_PARTITION_CONFIG.maxFilesPerGroup + 5 // Allow small overflow
-      );
-    }
-  });
-
-  it("should exclude shared paths", () => {
-    const files = [
-      "index.ts",
-      "src/main.ts",
-      "src/index.ts",
-      "src/components/Button.ts",
-    ];
-
-    const facts: ScopeFacts = {
-      estimatedFiles: 4,
-      observedFiles: 4,
-      estimatedCallSites: 10,
-      observedCallSites: 10,
-      independentComponents: 1,
-      tightlyCoupled: false,
-      isMechanical: false,
-      isComplex: false,
-      fileTypes: { ".ts": 4 },
-      fingerprint: "",
-    };
-
-    const groups = partitionWork(files, facts);
-
-    // All groups combined should not include shared paths
-    const allOwned = groups.flatMap((g) => g.ownedPaths);
-    expect(allOwned).not.toContain("index.ts");
-    expect(allOwned).not.toContain("main.ts");
-  });
-});
-
-describe("Ownership Conflicts", () => {
-  it("should detect conflicts", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "components",
-        ownedPaths: ["src/components/Button.ts"],
-        isMechanical: false,
-        status: "pending",
-      },
-    ];
-
-    const conflicts = detectOwnershipConflicts(groups, ["src/components/Button.ts"]);
-
-    expect(conflicts.length).toBe(1);
-    expect(conflicts[0]).toContain("already owned");
-  });
-
-  it("should detect conflict with completed groups (already owned)", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "components",
-        ownedPaths: ["src/components/Button.ts"],
-        isMechanical: false,
-        status: "completed",
-      },
-    ];
-
-    // Completed groups still own files - conflict should be detected
-    const conflicts = detectOwnershipConflicts(groups, ["src/components/Button.ts"]);
-
-    expect(conflicts.length).toBe(1);
-  });
-
-  it("should not conflict with cancelled groups", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "components",
-        ownedPaths: ["src/components/Button.ts"],
-        isMechanical: false,
-        status: "cancelled",
-      },
-    ];
-
-    const conflicts = detectOwnershipConflicts(groups, ["src/components/Button.ts"]);
-
-    expect(conflicts.length).toBe(0);
-  });
-});
-
-describe("Group Status Updates", () => {
-  it("should update group status", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "test",
-        ownedPaths: ["file.ts"],
-        isMechanical: false,
-        status: "pending",
-      },
-    ];
-
-    const updated = updateGroupStatus(groups, "group-1", "dispatched", "child-123");
-
-    expect(updated[0].status).toBe("dispatched");
-    expect(updated[0].childId).toBe("child-123");
-  });
-
-  it("should check completion", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "test1",
-        ownedPaths: ["file1.ts"],
-        isMechanical: false,
-        status: "completed",
-      },
-      {
-        groupId: "group-2",
-        description: "test2",
-        ownedPaths: ["file2.ts"],
-        isMechanical: false,
-        status: "completed",
-      },
-    ];
-
-    expect(areAllGroupsComplete(groups)).toBe(true);
-  });
-
-  it("should not report complete with pending", () => {
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "test1",
-        ownedPaths: ["file1.ts"],
-        isMechanical: false,
-        status: "completed",
-      },
-      {
-        groupId: "group-2",
-        description: "test2",
-        ownedPaths: ["file2.ts"],
-        isMechanical: false,
-        status: "pending",
-      },
-    ];
-
-    expect(areAllGroupsComplete(groups)).toBe(false);
-  });
-});
-
-describe("Unowned Files", () => {
-  it("should identify unowned files", () => {
-    const allFiles = ["file1.ts", "file2.ts", "file3.ts"];
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "test",
-        ownedPaths: ["file1.ts", "file2.ts"],
-        isMechanical: false,
-        status: "pending",
-      },
-    ];
-
-    const unowned = getUnownedFiles(allFiles, groups);
-
-    expect(unowned).toEqual(["file3.ts"]);
-  });
-
-  it("should consider completed groups as owned", () => {
-    const allFiles = ["file1.ts", "file2.ts"];
-    const groups: WorkGroup[] = [
-      {
-        groupId: "group-1",
-        description: "test",
-        ownedPaths: ["file1.ts"],
-        isMechanical: false,
-        status: "completed",
-      },
-    ];
-
-    const unowned = getUnownedFiles(allFiles, groups);
-
-    expect(unowned).toEqual(["file2.ts"]);
-  });
-});