pi-harness-runtime 0.10.43 → 1.1.1

package/packages/skill-registry/test/registry.test.ts

@@ -0,0 +1,508 @@
+/**
+ * Skill Registry Tests (RFC-0052)
+ */
+
+import { describe, it, expect, beforeEach } from "bun:test";
+import {
+	createSkillRegistry,
+	type InMemorySkillRegistry,
+	matchTrigger,
+	findBestMatch,
+	findAllMatches,
+	createKeywordTrigger,
+	createIntentTrigger,
+	createPatternTrigger,
+} from "../src/index.js";
+import type { Skill, SkillContext } from "../src/types.js";
+
+describe("SkillRegistry", () => {
+	let registry: InMemorySkillRegistry;
+
+	beforeEach(() => {
+		registry = createSkillRegistry(true);
+	});
+
+	describe("initialization", () => {
+		it("should load default skills", () => {
+			const skills = registry.list();
+			expect(skills.length).toBeGreaterThan(0);
+		});
+
+		it("should have introspection skill", () => {
+			const skill = registry.get("skill-registry-introspect");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Introspect Skill Registry");
+		});
+	});
+
+	describe("register and unregister", () => {
+		it("should register a new skill", () => {
+			const newSkill: Skill = {
+				id: "test-skill",
+				name: "Test Skill",
+				description: "A test skill",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["test"]),
+				handler: async () => ({ success: true, output: "test" }),
+				metadata: { tags: ["test"] },
+			};
+
+			registry.register(newSkill);
+
+			const skill = registry.get("test-skill");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Test Skill");
+		});
+
+		it("should not register deprecated skills", () => {
+			const deprecatedSkill: Skill = {
+				id: "deprecated-skill",
+				name: "Deprecated",
+				description: "Should not be registered",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["deprecated"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [], deprecated: true },
+			};
+
+			registry.register(deprecatedSkill);
+
+			const skill = registry.get("deprecated-skill");
+			expect(skill).toBeUndefined();
+		});
+
+		it("should unregister a skill", () => {
+			registry.unregister("skill-registry-introspect");
+
+			const skill = registry.get("skill-registry-introspect");
+			expect(skill).toBeUndefined();
+		});
+
+		it("should track events", () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const newSkill: Skill = {
+				id: "event-test",
+				name: "Event Test",
+				description: "Test event",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["event"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			registry.register(newSkill);
+
+			expect(events).toContainEqual({
+				type: "skill.registered",
+				skillId: "event-test",
+				name: "Event Test",
+			});
+		});
+	});
+
+	describe("find", () => {
+		it("should find skills by trigger type", () => {
+			// "list" appears in all trigger phrases: "list skills", "show skills", "what skills"
+			const skills = registry.find({ type: "keyword", value: "list" });
+			expect(skills.length).toBeGreaterThan(0);
+		});
+
+		it("should return empty for no match", () => {
+			const skills = registry.find({
+				type: "keyword",
+				value: "xyznonexistent",
+			});
+			expect(skills).toHaveLength(0);
+		});
+	});
+
+	describe("invoke", () => {
+		it("should invoke a skill", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			const result = await registry.invoke(
+				"skill-registry-introspect",
+				context,
+			);
+			expect(result.success).toBe(true);
+			expect(result.output).toContain("Registered Skills");
+		});
+
+		it("should return error for unknown skill", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invoke("unknown-skill", context);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("not found");
+		});
+
+		it("should track invoke events", async () => {
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			await registry.invoke("skill-registry-introspect", context);
+
+			const invokeEvents = events.filter((e) => e.type === "skill.invoked");
+			expect(invokeEvents.length).toBe(1);
+			expect(invokeEvents[0].skillId).toBe("skill-registry-introspect");
+			expect(invokeEvents[0].success).toBe(true);
+		});
+
+		it("should handle handler errors", async () => {
+			const errorSkill: Skill = {
+				id: "error-skill",
+				name: "Error Skill",
+				description: "Throws error",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["error"]),
+				handler: async () => {
+					throw new Error("Test error");
+				},
+				metadata: { tags: [] },
+			};
+
+			registry.register(errorSkill);
+
+			const events: any[] = [];
+			registry.onEvent((e) => events.push(e));
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invoke("error-skill", context);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("Test error");
+
+			const errorEvents = events.filter((e) => e.type === "skill.error");
+			expect(errorEvents.length).toBe(1);
+		});
+	});
+
+	describe("invokeBestMatch", () => {
+		it("should find and invoke best match", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: { registry },
+			};
+
+			// "list" appears in all trigger phrases
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "list" },
+				context,
+			);
+
+			expect(result.success).toBe(true);
+		});
+
+		it("should return error when no match", async () => {
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "xyznonexistent" },
+				context,
+			);
+
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("No matching skill");
+		});
+	});
+
+	describe("Capability Checking", () => {
+		it("should invoke skill when capabilities are available", async () => {
+			const capSkill: Skill = {
+				id: "cap-test",
+				name: "Cap Test",
+				description: "",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["captest"]),
+				handler: async () => ({ success: true, output: "ok" }),
+				metadata: { tags: [], requiresCapabilities: ["filesystem"] },
+			};
+			registry.register(capSkill);
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {
+					capabilityRegistry: { has: (cap: string) => cap === "filesystem" },
+				},
+			};
+
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "captest" },
+				context,
+			);
+			expect(result.success).toBe(true);
+		});
+
+		it("should fail when required capability is missing", async () => {
+			const capSkill: Skill = {
+				id: "cap-missing",
+				name: "Cap Missing",
+				description: "",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["capmiss"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [], requiresCapabilities: ["database"] },
+			};
+			registry.register(capSkill);
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {
+					capabilityRegistry: { has: (cap: string) => cap === "filesystem" },
+				},
+			};
+
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "capmiss" },
+				context,
+			);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("database");
+			expect(result.error).toContain("not available");
+		});
+
+		it("should fail gracefully when no capability registry", async () => {
+			const capSkill: Skill = {
+				id: "cap-no-registry",
+				name: "Cap No Registry",
+				description: "",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["capnoreg"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [], requiresCapabilities: ["expensive"] },
+			};
+			registry.register(capSkill);
+
+			const context: SkillContext = {
+				messages: [],
+				tools: [],
+				metadata: {},
+			};
+
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "capnoreg" },
+				context,
+			);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("no capability registry");
+		});
+	});
+
+	describe("Confidence Threshold", () => {
+		it("should respect trigger.confidence as min threshold", async () => {
+			// introspect skill keywords: ["list skills", "show skills", "what skills"]
+			// match score for "xyz" = 0 (no keywords match)
+			// minConfidence = 0.8 → should not match
+			const result = await registry.invokeBestMatch(
+				{ type: "keyword", value: "xyz", confidence: 0.8 },
+				{ messages: [], tools: [], metadata: {} },
+			);
+			expect(result.success).toBe(false);
+			expect(result.error).toContain("No matching skill");
+		});
+	});
+
+	describe("Extended Default Skills", () => {
+		it("should load at least 5 default skills", () => {
+			// introspect, help, status, context-compile, skill-install
+			const skills = registry.list();
+			expect(skills.length).toBeGreaterThanOrEqual(5);
+		});
+
+		it("should have context-compile skill", () => {
+			const skill = registry.get("skill-context-compile");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Context Compiler");
+		});
+
+		it("should have skill-install skill", () => {
+			const skill = registry.get("skill-install");
+			expect(skill).toBeDefined();
+			expect(skill!.name).toBe("Install Skill");
+		});
+
+		it("context-compile skill should analyze context", async () => {
+			const context: SkillContext = {
+				messages: [
+					{ role: "user", content: "hello" },
+					{ role: "assistant", content: "hi" },
+				],
+				tools: [{ name: "bash" }, { name: "read" }],
+				metadata: {},
+			};
+
+			const result = await registry.invoke("skill-context-compile", context);
+			expect(result.success).toBe(true);
+			expect(result.output).toContain("Context analysis");
+			expect(result.output).toContain("Messages: 2");
+			expect(result.output).toContain("Available tools: 2");
+		});
+
+		it("skill-install skill should provide guidance", async () => {
+			const result = await registry.invoke("skill-install", {
+				messages: [],
+				tools: [],
+				metadata: {},
+			});
+			expect(result.success).toBe(true);
+			expect(result.output).toContain("skills directory");
+		});
+	});
+});
+
+describe("Matching Functions", () => {
+	describe("matchTrigger", () => {
+		it("should match keyword trigger", () => {
+			const skill = {
+				id: "test",
+				name: "Test",
+				description: "",
+				version: "1.0.0",
+				trigger: createKeywordTrigger(["help", "assist"]),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			expect(matchTrigger(skill, "Can you help me?")).toBeGreaterThan(0);
+			expect(matchTrigger(skill, "I need assistance")).toBeGreaterThan(0);
+			expect(matchTrigger(skill, "Nothing relevant")).toBe(0);
+		});
+
+		it("should match pattern trigger", () => {
+			const skill = {
+				id: "test",
+				name: "Test",
+				description: "",
+				version: "1.0.0",
+				trigger: createPatternTrigger("fix\\s+\\w+"),
+				handler: async () => ({ success: true }),
+				metadata: { tags: [] },
+			};
+
+			expect(matchTrigger(skill, "fix bug")).toBe(1);
+			expect(matchTrigger(skill, "fix error")).toBe(1);
+			expect(matchTrigger(skill, "not relevant")).toBe(0);
+		});
+	});
+
+	describe("findBestMatch", () => {
+		it("should return highest scoring match", () => {
+			const skills = [
+				{
+					id: "low",
+					name: "Low",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+				{
+					id: "high",
+					name: "High",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test", "skill", "run"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const match = findBestMatch(skills, "run test skill");
+			// Both have score 1.0 (all keywords match), so either could be returned
+			expect(["high", "low"]).toContain(match?.id);
+		});
+
+		it("should respect min confidence", () => {
+			const skills = [
+				{
+					id: "low",
+					name: "Low",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["test"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const match = findBestMatch(skills, "xyz", 0.5);
+			expect(match).toBeUndefined();
+		});
+	});
+
+	describe("findAllMatches", () => {
+		it("should return all matches above threshold", () => {
+			const skills = [
+				{
+					id: "one",
+					name: "One",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["help"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+				{
+					id: "two",
+					name: "Two",
+					description: "",
+					version: "1.0.0",
+					trigger: createKeywordTrigger(["help", "me"]),
+					handler: async () => ({ success: true }),
+					metadata: { tags: [] },
+				},
+			];
+
+			const matches = findAllMatches(skills, "help me");
+			expect(matches.length).toBe(2);
+		});
+	});
+});
+
+describe("Trigger Creators", () => {
+	it("should create keyword trigger", () => {
+		const trigger = createKeywordTrigger(["one", "two"]);
+		expect(trigger.type).toBe("keyword");
+		expect(trigger.value).toEqual(["one", "two"]);
+	});
+
+	it("should create intent trigger", () => {
+		const trigger = createIntentTrigger(["intent1"]);
+		expect(trigger.type).toBe("intent");
+		expect(trigger.value).toEqual(["intent1"]);
+	});
+
+	it("should create pattern trigger", () => {
+		const trigger = createPatternTrigger("test\\d+");
+		expect(trigger.type).toBe("pattern");
+		expect(trigger.value).toBe("test\\d+");
+	});
+});

package/packages/sprint-planner/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@pi/sprint-planner",
+  "version": "0.10.30",
+  "type": "module",
+  "description": "Sprint planning engine for pi-harness",
+  "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/sprint-planner/test/planner.test.ts

@@ -0,0 +1,187 @@
+/**
+ * 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);
+  });
+});