pi-harness-runtime 1.1.440 → 1.1.441

package/packages/skills/test/vector-threshold.test.ts

@@ -1,108 +0,0 @@
-/**
- * The score that decides whether a hit of the vector store is a hit.
- *
- * The score of a vector search is a cosine between two vectors, and its
- * scale belongs to the model that produced them. The runtime embeds with
- * `text-embedding-3-small`, whose cosines for a query that names a skill
- * land between 0.31 and 0.56 - while a query about something else reaches
- * 0.23 at most.
- *
- * The threshold used to be 0.5, a value of the MiniLM collection, whose
- * vectors are not comparable. Against the runtime collection it threw away
- * every clear match (0.47) - a search of a filled collection returned
- * nothing at all, and the skill was invisible.
- *
- * The threshold therefore lives next to the model, and the tests below
- * hold it there.
- */
-
-import { describe, expect, it } from "bun:test";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
-
-import {
-	createSkillRegistry,
-	type QdrantClientLike,
-	type QdrantEmbedderLike,
-} from "../src/loader.js";
-import { SKILL_MIN_SCORE } from "../src/vector-schema.js";
-
-/** A client that answers a query with the given points. */
-function fakeClient(points: Array<{ id: number; score: number }>): QdrantClientLike {
-	return {
-		async upsert(): Promise<void> {},
-		async query(): Promise<unknown> {
-			return { points };
-		},
-		async getCollection(): Promise<unknown> {
-			return { config: { params: { vectors: { size: 1536, distance: "Cosine" } } } };
-		},
-	};
-}
-
-/** An embedder that returns a fixed vector. */
-const fakeEmbedder: QdrantEmbedderLike = {
-	async createEmbedding() {
-		return { embedding: [0.1, 0.2, 0.3], tokens: 3 };
-	},
-};
-
-const registryWith = (scores: number[]) =>
-	createSkillRegistry({
-		qdrantClient: fakeClient(
-			scores.map((score, index) => ({
-				id: index + 1,
-				score,
-				payload: { name: `skill-${index}`, description: "d", body: "b" },
-			})),
-		),
-		embedder: fakeEmbedder,
-		collection: "pi-harness-skills-test",
-	});
-
-describe("the score that decides whether a hit is a hit", () => {
-	it("belongs to the model of the collection", () => {
-		// The measured values: a query that names a skill scores 0.31 to
-		// 0.56, a query about something else 0.10 to 0.23.
-		expect(SKILL_MIN_SCORE).toBeGreaterThan(0.23);
-		expect(SKILL_MIN_SCORE).toBeLessThan(0.31);
-	});
-
-	it("keeps a clear match that the old threshold of 0.5 threw away", async () => {
-		// 0.47 is a clear match of the runtime model - and below 0.5.
-		const registry = registryWith([0.47]);
-
-		const results = await registry.findVector("approve a purchase order");
-
-		expect(results).toHaveLength(1);
-		expect(results[0].score).toBe(0.47);
-	});
-
-	it("drops a hit that is noise", async () => {
-		const registry = registryWith([0.23]);
-
-		const results = await registry.findVector("cook a risotto");
-
-		expect(results).toHaveLength(0);
-	});
-
-	it("keeps the hits above it and drops the hits below it", async () => {
-		const registry = registryWith([0.55, 0.12, 0.4, 0.2]);
-
-		const results = await registry.findVector("a query");
-
-		expect(results.map((r) => r.score)).toEqual([0.55, 0.4]);
-	});
-
-	it("is the threshold of the skill command too", () => {
-		// The command passed 0.5 itself, so the fix of the default would
-		// not have reached the search of the user.
-		const source = readFileSync(
-			fileURLToPath(new URL("../src/skill-commands.ts", import.meta.url)),
-			"utf8",
-		);
-
-		expect(source).toContain("SKILL_MIN_SCORE");
-		expect(source).not.toMatch(/findVector\([^)]*,\s*5,\s*0\.5/);
-	});
-});

package/packages/sprint-planner/test/planner.test.ts

@@ -1,187 +0,0 @@
-/**
- * Sprint Planner Tests (RFC-0074)
- */
-
-import { describe, it, expect } from "bun:test";
-import {
-  planSprints,
-  createSprintConfig,
-  sortRequirements,
-  calculateVelocity,
-  decomposeRequirement,
-  assignEstimate,
-  sumPoints,
-} from "../src/index.js";
-import type { Requirement } from "../src/index.js";
-
-const makeReq = (overrides?: Partial<Requirement>): Requirement => ({
-  id: `req-${Math.random().toString(36).slice(2)}`,
-  title: "Test Requirement",
-  description: "Test description",
-  priority: "medium",
-  acceptanceCriteria: [],
-  labels: [],
-  dependencies: [],
-  ...overrides,
-});
-
-describe("decomposeRequirement", () => {
-  it("creates at least 3 tasks", () => {
-    const req = makeReq();
-    const tasks = decomposeRequirement(req);
-    expect(tasks.length).toBeGreaterThanOrEqual(3);
-  });
-
-  it("all tasks reference requirement ID", () => {
-    const req = makeReq({ id: "req-123" });
-    const tasks = decomposeRequirement(req);
-    for (const t of tasks) {
-      expect(t.requirementId).toBe("req-123");
-    }
-  });
-
-  it("respects custom estimate", () => {
-    const req = makeReq({ estimate: 8 });
-    const tasks = decomposeRequirement(req);
-    expect(tasks[0].estimate).toBe(8);
-  });
-
-  it("creates AC tasks", () => {
-    const req = makeReq({ acceptanceCriteria: ["AC1", "AC2"] });
-    const tasks = decomposeRequirement(req);
-    expect(tasks.some((t) => t.title.includes("AC1"))).toBe(true);
-    expect(tasks.some((t) => t.title.includes("AC2"))).toBe(true);
-  });
-});
-
-describe("assignEstimate", () => {
-  it("returns 1 for complexity 1", () => expect(assignEstimate(1)).toBe(1));
-  it("returns 3 for mid complexity", () => expect(assignEstimate(5)).toBe(3));
-  it("caps at 21", () => expect(assignEstimate(100)).toBe(21));
-});
-
-describe("sumPoints", () => {
-  it("sums task estimates", () => {
-    const tasks = [
-      { estimate: 3, requirementId: "1", title: "", description: "", status: "todo", labels: [] },
-      { estimate: 5, requirementId: "1", title: "", description: "", status: "todo", labels: [] },
-    ] as any[];
-    expect(sumPoints(tasks)).toBe(8);
-  });
-
-  it("treats undefined as 0", () => {
-    const tasks = [
-      { estimate: undefined, requirementId: "1", title: "", description: "", status: "todo", labels: [] },
-    ] as any[];
-    expect(sumPoints(tasks)).toBe(0);
-  });
-});
-
-describe("sortRequirements", () => {
-  it("sorts critical before high before medium before low", () => {
-    const reqs = [
-      makeReq({ id: "low", priority: "low" }),
-      makeReq({ id: "critical", priority: "critical" }),
-      makeReq({ id: "high", priority: "high" }),
-      makeReq({ id: "medium", priority: "medium" }),
-    ];
-    const sorted = sortRequirements(reqs, "priority-then-dependencies");
-    expect(sorted.map((r) => r.priority)).toEqual(["critical", "high", "medium", "low"]);
-  });
-
-  it("respects moSCoW strategy", () => {
-    const reqs = [
-      makeReq({ id: "a", priority: "low" }),
-      makeReq({ id: "b", priority: "critical" }),
-    ];
-    const sorted = sortRequirements(reqs, "moSCoW");
-    expect(sorted[0].id).toBe("b");
-  });
-});
-
-describe("createSprintConfig", () => {
-  it("has sensible defaults", () => {
-    const cfg = createSprintConfig();
-    expect(cfg.sprintDurationDays).toBe(14);
-    expect(cfg.capacityPerDay).toBe(5);
-    expect(cfg.defaultEstimate).toBe(3);
-  });
-
-  it("accepts overrides", () => {
-    const cfg = createSprintConfig({ sprintDurationDays: 7 });
-    expect(cfg.sprintDurationDays).toBe(7);
-    expect(cfg.capacityPerDay).toBe(5);
-  });
-});
-
-describe("planSprints", () => {
-  it("creates at least one sprint", () => {
-    const reqs = [makeReq()];
-    const result = planSprints(reqs);
-    expect(result.sprints.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it("assigns all requirements to sprints", () => {
-    const reqs = [makeReq({ id: "r1" }), makeReq({ id: "r2" })];
-    const result = planSprints(reqs);
-    const assigned = new Set(result.sprints.flatMap((s) => s.tasks.map((t) => t.requirementId)));
-    expect(assigned.has("r1")).toBe(true);
-    expect(assigned.has("r2")).toBe(true);
-  });
-
-  it("calculates total points", () => {
-    const reqs = [makeReq({ estimate: 5 })];
-    const result = planSprints(reqs);
-    expect(result.totalPoints).toBeGreaterThan(0);
-  });
-
-  it("handles empty list", () => {
-    const result = planSprints([]);
-    expect(result.sprints).toEqual([]);
-    expect(result.totalPoints).toBe(0);
-  });
-
-  it("includes sprint dates", () => {
-    const result = planSprints([makeReq()]);
-    expect(result.sprints[0].startDate < result.sprints[0].endDate).toBe(true);
-  });
-
-  it("prioritizes critical requirements", () => {
-    const reqs = [
-      makeReq({ id: "low1", priority: "low" }),
-      makeReq({ id: "critical1", priority: "critical" }),
-    ];
-    const result = planSprints(reqs);
-    const firstReqs = new Set(result.sprints[0]?.tasks.map((t) => t.requirementId));
-    expect(firstReqs.has("critical1")).toBe(true);
-  });
-});
-
-describe("calculateVelocity", () => {
-  it("returns 0 for no sprints", () => expect(calculateVelocity([])).toBe(0));
-
-  it("returns 0 when no sprints are completed", () => {
-    const sprints: any[] = [{
-      id: "s1", number: 1, name: "S1", startDate: "2024-01-01", endDate: "2024-01-14",
-      capacity: 20,
-      tasks: [{ id: "t1", requirementId: "r1", title: "t", description: "", status: "in-progress", estimate: 5, labels: [] }],
-    }];
-    expect(calculateVelocity(sprints)).toBe(0);
-  });
-
-  it("calculates velocity from completed sprints", () => {
-    const sprints: any[] = [
-      {
-        id: "s1", number: 1, name: "S1", startDate: "2024-01-01", endDate: "2024-01-14",
-        capacity: 20,
-        tasks: [{ id: "t1", requirementId: "r1", title: "t", description: "", status: "done", estimate: 8, labels: [] }],
-      },
-      {
-        id: "s2", number: 2, name: "S2", startDate: "2024-01-15", endDate: "2024-01-28",
-        capacity: 20,
-        tasks: [{ id: "t2", requirementId: "r2", title: "t", description: "", status: "done", estimate: 8, labels: [] }],
-      },
-    ];
-    expect(calculateVelocity(sprints)).toBe(8);
-  });
-});