@a-canary/pi-director 0.1.0

package/templates/NEXT.md

@@ -0,0 +1,35 @@
+# NEXT.md — Recommended Actions
+
+Generated: {date}
+Priority ladder: UX Quality > Security > Scale > Efficiency
+
+## Sources Analyzed
+- Sessions: {count} ({date range})
+- Corrections: {count}
+- Source files: {count}
+- Log sources: {count}
+- CHOICES.md: {count} choices ({fulfilled}✓ {partial}◐ {not_started}✗)
+
+---
+
+## Priority 1: {title}
+Category: {category} | Impact: {high/med/low} | Effort: {small/med/large} | Score: {N}/27
+Evidence: {what data supports this}
+Action: {specific steps}
+Supports: {CHOICES.md IDs affected}
+
+## Priority 2: {title}
+Category: {category} | Impact: {high/med/low} | Effort: {small/med/large} | Score: {N}/27
+Evidence: {what data supports this}
+Action: {specific steps}
+Supports: {CHOICES.md IDs affected}
+
+<!-- Continue for top 10 recommendations -->
+
+---
+
+## Deferred
+<!-- Items from previous NEXT.md not yet addressed -->
+
+## Dismissed
+<!-- Items explicitly dismissed by user, with reason -->

package/test/agents.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, readdirSync } from "fs";
+import { join } from "path";
+
+const AGENTS_DIR = join(__dirname, "..", "agents");
+const VALID_TIERS = ["strategic", "tactical", "operational", "scout"];
+
+function parseAgent(filename: string) {
+	const raw = readFileSync(join(AGENTS_DIR, filename), "utf-8");
+	const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+	if (!match) return null;
+
+	const frontmatter: Record<string, string> = {};
+	for (const line of match[1].split("\n")) {
+		const idx = line.indexOf(":");
+		if (idx > 0) {
+			frontmatter[line.slice(0, idx).trim()] = line.slice(idx + 1).trim();
+		}
+	}
+	return { frontmatter, body: match[2].trim() };
+}
+
+describe("Agent definitions", () => {
+	const files = readdirSync(AGENTS_DIR).filter(f => f.endsWith(".md") && f !== "README.md");
+
+	it("should have at least 6 agent files", () => {
+		expect(files.length).toBeGreaterThanOrEqual(6);
+	});
+
+	for (const file of files) {
+		describe(file, () => {
+			const agent = parseAgent(file);
+
+			it("should parse frontmatter", () => {
+				expect(agent).not.toBeNull();
+			});
+
+			it("should have a name", () => {
+				expect(agent!.frontmatter.name).toBeTruthy();
+			});
+
+			it("should have a description", () => {
+				expect(agent!.frontmatter.description).toBeTruthy();
+			});
+
+			it("should use a model tier group, not a hardcoded model", () => {
+				const model = agent!.frontmatter.model;
+				expect(VALID_TIERS).toContain(model);
+			});
+
+			it("should have tools defined (or be a thinking-only critic)", () => {
+				const isCritic = agent!.frontmatter.name === "critic";
+				if (!isCritic) {
+					expect(agent!.frontmatter.tools).toBeTruthy();
+				}
+			});
+
+			it("should have a body with instructions", () => {
+				expect(agent!.body.length).toBeGreaterThan(50);
+			});
+		});
+	}
+});

package/test/next-template.test.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+const TEMPLATE = join(__dirname, "..", "templates", "NEXT.md");
+
+describe("NEXT.md template", () => {
+	it("should exist", () => {
+		expect(existsSync(TEMPLATE)).toBe(true);
+	});
+
+	it("should have title", () => {
+		const content = readFileSync(TEMPLATE, "utf-8");
+		expect(content).toContain("# NEXT.md");
+	});
+
+	it("should reference priority ladder", () => {
+		const content = readFileSync(TEMPLATE, "utf-8");
+		expect(content).toContain("UX Quality > Security > Scale > Efficiency");
+	});
+
+	it("should have priority items with required fields", () => {
+		const content = readFileSync(TEMPLATE, "utf-8");
+		expect(content).toContain("Category:");
+		expect(content).toContain("Impact:");
+		expect(content).toContain("Effort:");
+		expect(content).toContain("Evidence:");
+		expect(content).toContain("Action:");
+	});
+
+	it("should have Sources Analyzed section", () => {
+		const content = readFileSync(TEMPLATE, "utf-8");
+		expect(content).toContain("## Sources Analyzed");
+	});
+
+	it("should have Deferred and Dismissed sections", () => {
+		const content = readFileSync(TEMPLATE, "utf-8");
+		expect(content).toContain("## Deferred");
+		expect(content).toContain("## Dismissed");
+	});
+});

package/test/package.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+const ROOT = join(__dirname, "..");
+
+describe("Package configuration", () => {
+	const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8"));
+
+	it("should be named @a-canary/pi-director", () => {
+		expect(pkg.name).toBe("@a-canary/pi-director");
+	});
+
+	it("should have author a-canary", () => {
+		expect(pkg.author?.name || pkg.author).toContain("a-canary");
+	});
+
+	it("should have pi-package keyword", () => {
+		expect(pkg.keywords).toContain("pi-package");
+	});
+
+	it("should declare pi.skills pointing to real directory", () => {
+		expect(pkg.pi?.skills).toBeTruthy();
+		for (const dir of pkg.pi.skills) {
+			expect(existsSync(join(ROOT, dir))).toBe(true);
+		}
+	});
+
+	it("should declare pi.agents pointing to real directory", () => {
+		expect(pkg.pi?.agents).toBeTruthy();
+		for (const dir of pkg.pi.agents) {
+			expect(existsSync(join(ROOT, dir))).toBe(true);
+		}
+	});
+
+	it("should declare pi.extensions pointing to real directory", () => {
+		expect(pkg.pi?.extensions).toBeTruthy();
+		for (const dir of pkg.pi.extensions) {
+			expect(existsSync(join(ROOT, dir))).toBe(true);
+		}
+	});
+
+	it("should have pi-choose-wisely as peer dependency", () => {
+		expect(pkg.peerDependencies["@a-canary/pi-choose-wisely"]).toBeTruthy();
+	});
+
+	it("should have pi-upskill as peer dependency", () => {
+		expect(pkg.peerDependencies["@a-canary/pi-upskill"]).toBeTruthy();
+	});
+
+	describe("Required files", () => {
+		const required = ["CHOICES.md", "PLAN.md", "README.md"];
+		for (const file of required) {
+			it(`should have ${file}`, () => {
+				expect(existsSync(join(ROOT, file))).toBe(true);
+			});
+		}
+	});
+});

package/test/skills.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+
+const SKILLS_DIR = join(__dirname, "..", "skills");
+const REQUIRED_SKILLS = ["next", "build", "choose"];
+
+describe("Skill definitions", () => {
+	for (const skill of REQUIRED_SKILLS) {
+		describe(`/${skill}`, () => {
+			const skillPath = join(SKILLS_DIR, skill, "SKILL.md");
+
+			it("should have SKILL.md", () => {
+				expect(existsSync(skillPath)).toBe(true);
+			});
+
+			it("should have When to Use section", () => {
+				const content = readFileSync(skillPath, "utf-8");
+				expect(content).toContain("## When to Use");
+			});
+
+			it("should have Process section", () => {
+				const content = readFileSync(skillPath, "utf-8");
+				expect(content).toContain("## Process");
+			});
+		});
+	}
+
+	describe("/next lib modules", () => {
+		const modules = ["session-scanner", "code-scanner", "choice-scanner", "log-scanner", "ranker"];
+		for (const mod of modules) {
+			it(`should have ${mod}.md`, () => {
+				expect(existsSync(join(SKILLS_DIR, "next", "lib", `${mod}.md`))).toBe(true);
+			});
+		}
+	});
+
+	describe("/build lib modules", () => {
+		const modules = ["phase-loop", "hard-stops", "regression-check"];
+		for (const mod of modules) {
+			it(`should have ${mod}.md`, () => {
+				expect(existsSync(join(SKILLS_DIR, "build", "lib", `${mod}.md`))).toBe(true);
+			});
+		}
+	});
+
+	describe("/choose lib modules", () => {
+		it("should have pipeline.md", () => {
+			expect(existsSync(join(SKILLS_DIR, "choose", "lib", "pipeline.md"))).toBe(true);
+		});
+	});
+});