gentle-pi 0.2.5 → 0.2.6

package/README.md

@@ -178,16 +178,35 @@ It scans common roots such as:
 
 ```text
 ./skills
+.opencode/skills
+.claude/skills
+.gemini/skills
+.cursor/skills
+.github/skills
+.codex/skills
+.qwen/skills
+.kiro/skills
+.openclaw/skills
 .pi/skills
 .agent/skills
 .agents/skills
-.claude/skills
-.gemini/skills
+.atl/skills
+~/.pi/agent/skills
+~/.config/agents/skills
+~/.agents/skills
+~/.kimi/skills
 ~/.config/opencode/skills
+~/.config/kilo/skills
 ~/.claude/skills
 ~/.gemini/skills
+~/.gemini/antigravity/skills
 ~/.cursor/skills
 ~/.copilot/skills
+~/.codex/skills
+~/.codeium/windsurf/skills
+~/.qwen/skills
+~/.kiro/skills
+~/.openclaw/skills
 ```
 
 Behavior:
@@ -196,7 +215,7 @@ Behavior:
 - the registry refreshes on session start;
 - `/skill-registry:refresh` forces regeneration;
 - a best-effort watcher refreshes when skill files change;
-- skills without `## Compact Rules` are still listed, but delegators should inject project/user compact rules into subagents whenever possible.
+- `## Compact Rules` wins when present; otherwise the registry extracts compact rules from `## Hard Rules`, `## Critical Rules`, `## Critical Patterns`, `## Voice Rules`, and `## Decision Gates` using bullets, numbered lists, or simple tables.
 
 Skill discovery is a guardrail, not a workflow router: it helps Pi load the right skill without forcing extra ceremony.
 
@@ -331,6 +350,7 @@ pi install .
 Validate before publishing:
 
 ```bash
+pnpm test
 bun build extensions/skill-registry.ts --target=node --format=esm --outfile=/tmp/skill-registry.js
 node --experimental-strip-types --check extensions/gentle-ai.ts
 node --experimental-strip-types --check extensions/sdd-init.ts

package/extensions/skill-registry.ts

@@ -10,7 +10,7 @@ import {
 	writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
-import { basename, join, relative } from "node:path";
+import { basename, join, normalize, relative, sep } from "node:path";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 const REGISTRY_REL_PATH = ".atl/skill-registry.md";
@@ -20,7 +20,7 @@ const EXCLUDE_NAMES = new Set(["_shared", "skill-registry"]);
 const EXCLUDE_PREFIXES = ["sdd-"];
 const ATL_IGNORE_ENTRY = ".atl/";
 const WATCH_DEBOUNCE_MS = 500;
-const REGISTRY_SCHEMA_VERSION = 3;
+const REGISTRY_SCHEMA_VERSION = 4;
 const LEGACY_PROJECT_REGISTRY_REL_PATH = ".pi/extensions/skill-registry.ts";
 const LEGACY_PROJECT_REGISTRY_DISABLED_REL_PATH =
 	".pi/extensions/skill-registry.ts.disabled";
@@ -36,23 +36,39 @@ function userSkillDirs(): string[] {
 	const home = homedir();
 	return [
 		join(home, ".pi/agent/skills"),
+		join(home, ".config/agents/skills"),
 		join(home, ".agents/skills"),
+		join(home, ".kimi/skills"),
 		join(home, ".config/opencode/skills"),
+		join(home, ".config/kilo/skills"),
 		join(home, ".claude/skills"),
 		join(home, ".gemini/skills"),
+		join(home, ".gemini/antigravity/skills"),
 		join(home, ".cursor/skills"),
 		join(home, ".copilot/skills"),
+		join(home, ".codex/skills"),
+		join(home, ".codeium/windsurf/skills"),
+		join(home, ".qwen/skills"),
+		join(home, ".kiro/skills"),
+		join(home, ".openclaw/skills"),
 	];
 }
 
 function projectSkillDirs(cwd: string): string[] {
 	return [
 		join(cwd, "skills"),
+		join(cwd, ".opencode/skills"),
+		join(cwd, ".claude/skills"),
+		join(cwd, ".gemini/skills"),
+		join(cwd, ".cursor/skills"),
+		join(cwd, ".github/skills"),
+		join(cwd, ".codex/skills"),
+		join(cwd, ".qwen/skills"),
+		join(cwd, ".kiro/skills"),
+		join(cwd, ".openclaw/skills"),
 		join(cwd, ".pi/skills"),
 		join(cwd, ".agent/skills"),
 		join(cwd, ".agents/skills"),
-		join(cwd, ".claude/skills"),
-		join(cwd, ".gemini/skills"),
 		join(cwd, ".atl/skills"),
 	];
 }
@@ -78,7 +94,7 @@ function findSkillFiles(root: string): string[] {
 			}
 		}
 	}
-	return out;
+	return out.sort();
 }
 
 function parseFrontmatter(source: string): { name?: string; description?: string; body: string } {
@@ -102,24 +118,76 @@ function parseFrontmatter(source: string): { name?: string; description?: string
 	return { ...out, body };
 }
 
+const FALLBACK_RULE_HEADINGS = ["Hard Rules", "Critical Rules", "Critical Patterns", "Voice Rules", "Decision Gates"];
+const MAX_EXTRACTED_RULE_COUNT = 15;
+
 function extractCompactRulesSection(body: string): string[] {
-	const lines = body.split("\n");
+	const compactRules = extractRulesFromHeadings(body, ["Compact Rules"]);
+	if (compactRules.length > 0) return compactRules;
+	return extractRulesFromHeadings(body, FALLBACK_RULE_HEADINGS);
+}
+
+function extractRulesFromHeadings(body: string, headings: string[]): string[] {
+	const wanted = new Set(headings.map(normalizeHeading));
 	let inSection = false;
 	const rules: string[] = [];
-	for (const raw of lines) {
+	for (const raw of body.split("\n")) {
 		const line = raw.trimEnd();
-		if (/^##\s+Compact Rules\s*$/i.test(line)) {
-			inSection = true;
+		const heading = line.match(/^##\s+(.+?)\s*$/);
+		if (heading) {
+			inSection = wanted.has(normalizeHeading(heading[1]));
 			continue;
 		}
 		if (!inSection) continue;
-		if (/^##\s+/.test(line)) break;
-		const m = line.match(/^-\s+(.+)$/);
-		if (m) rules.push(m[1].trim());
+		if (/^##\s+/.test(line)) {
+			inSection = false;
+			continue;
+		}
+		const rule = extractRuleLine(line);
+		if (rule) {
+			rules.push(rule);
+			if (rules.length >= MAX_EXTRACTED_RULE_COUNT) return rules;
+		}
 	}
 	return rules;
 }
 
+function extractRuleLine(line: string): string | undefined {
+	const trimmed = line.trim();
+	if (!trimmed) return undefined;
+	const bullet = trimmed.match(/^-\s+(.+)$/);
+	if (bullet) return bullet[1].trim();
+	const ordered = trimmed.match(/^\d+[.)]\s+(.+)$/);
+	if (ordered) return ordered[1].trim();
+	if (trimmed.startsWith("|") && trimmed.endsWith("|")) return extractRuleTableRow(trimmed);
+	return undefined;
+}
+
+function extractRuleTableRow(line: string): string | undefined {
+	const cells = line
+		.slice(1, -1)
+		.split("|")
+		.map((cell) => cell.trim());
+	if (cells.length < 2) return undefined;
+	if (isTableSeparator(cells) || isTableHeader(cells) || !cells[0] || !cells[1]) return undefined;
+	return `${cells[0]}: ${cells[1]}`;
+}
+
+function isTableSeparator(cells: string[]): boolean {
+	return cells.every((cell) => cell.replace(/[\s:-]/g, "") === "");
+}
+
+function isTableHeader(cells: string[]): boolean {
+	if (cells.length < 2) return false;
+	const first = normalizeHeading(cells[0]);
+	const second = normalizeHeading(cells[1]);
+	return (first === "rule" && second === "requirement") || (first === "target" && second === "test pattern");
+}
+
+function normalizeHeading(heading: string): string {
+	return heading.trim().toLowerCase();
+}
+
 function deriveSkillName(file: string, frontmatterName: string | undefined): string {
 	if (frontmatterName) return frontmatterName;
 	return basename(join(file, ".."));
@@ -130,13 +198,19 @@ function isExcluded(name: string): boolean {
 	return EXCLUDE_PREFIXES.some((p) => name.startsWith(p));
 }
 
+function comparablePath(path: string): string {
+	const clean = normalize(path);
+	return clean.length > 1 ? clean.replace(/[\\/]+$/, "") : clean;
+}
+
 function uniqueExistingDirs(dirs: string[]): string[] {
 	const seen = new Set<string>();
 	const out: string[] = [];
 	for (const dir of dirs) {
-		if (seen.has(dir) || !existsSync(dir)) continue;
-		seen.add(dir);
-		out.push(dir);
+		const clean = comparablePath(dir);
+		if (seen.has(clean) || !existsSync(clean)) continue;
+		seen.add(clean);
+		out.push(clean);
 	}
 	return out;
 }
@@ -155,7 +229,7 @@ function loadSkill(file: string): SkillEntry | undefined {
 	return {
 		name,
 		path: file,
-		description: fm.description ?? "",
+		description: extractTriggerDescription(fm.description ?? ""),
 		rules:
 			rules.length > 0
 				? rules
@@ -163,8 +237,14 @@ function loadSkill(file: string): SkillEntry | undefined {
 	};
 }
 
+function extractTriggerDescription(description: string): string {
+	const match = description.match(/\bTrigger:\s*(.+)$/i);
+	return match ? match[1].trim() : description;
+}
+
 function dedupeBySkillName(entries: SkillEntry[], cwd: string): SkillEntry[] {
-	const projectPrefix = cwd.endsWith("/") ? cwd : `${cwd}/`;
+	const cleanCwd = comparablePath(cwd);
+	const projectPrefix = cleanCwd.endsWith(sep) ? cleanCwd : `${cleanCwd}${sep}`;
 	const buckets = new Map<string, SkillEntry[]>();
 	for (const entry of entries) {
 		const list = buckets.get(entry.name) ?? [];
@@ -173,7 +253,7 @@ function dedupeBySkillName(entries: SkillEntry[], cwd: string): SkillEntry[] {
 	}
 	const out: SkillEntry[] = [];
 	for (const [, list] of buckets) {
-		const projectScoped = list.find((e) => e.path.startsWith(projectPrefix));
+		const projectScoped = list.find((e) => comparablePath(e.path).startsWith(projectPrefix));
 		out.push(projectScoped ?? list[0]);
 	}
 	return out.sort((a, b) => a.name.localeCompare(b.name));
@@ -298,7 +378,7 @@ function quarantineLegacyProjectRegistry(cwd: string): boolean {
 
 function regenerateRegistry(cwd: string, force: boolean): RegenResult {
 	const existingDirs = uniqueExistingDirs([...projectSkillDirs(cwd), ...userSkillDirs()]);
-	const files = existingDirs.flatMap(findSkillFiles).sort();
+	const files = existingDirs.flatMap(findSkillFiles);
 	const cachePath = join(cwd, CACHE_REL_PATH);
 	const registryPath = join(cwd, REGISTRY_REL_PATH);
 	const fp = fingerprint(files);
@@ -357,6 +437,15 @@ function startSkillRegistryWatcher(cwd: string, notify: (message: string) => voi
 	}
 }
 
+export const __testing = {
+	projectSkillDirs,
+	userSkillDirs,
+	extractCompactRulesSection,
+	extractTriggerDescription,
+	uniqueExistingDirs,
+	dedupeBySkillName,
+};
+
 export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gentle-pi",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "description": "Turn Pi into el Gentleman: a senior-architect development harness with SDD/OpenSpec, subagents, strict TDD evidence, review guardrails, and skill discovery.",
   "license": "MIT",
   "type": "module",
@@ -28,11 +28,13 @@
     "prompts/",
     "skills/",
     "scripts/",
+    "tests/",
     "README.md"
   ],
   "scripts": {
-    "prepack": "node scripts/verify-package-files.mjs",
-    "prepublishOnly": "node scripts/verify-package-files.mjs"
+    "test": "node --experimental-strip-types --test tests/*.test.ts",
+    "prepack": "pnpm test && node scripts/verify-package-files.mjs",
+    "prepublishOnly": "pnpm test && node scripts/verify-package-files.mjs"
   },
   "pi": {
     "image": "https://cdn.jsdelivr.net/npm/gentle-pi/assets/gentle-logo-only.png",

package/tests/skill-registry.test.ts

@@ -0,0 +1,114 @@
+import assert from "node:assert/strict";
+import { mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { __testing } from "../extensions/skill-registry.ts";
+
+test("project skill dirs include supported workspace roots", () => {
+	const cwd = "/repo";
+	const dirs = __testing.projectSkillDirs(cwd);
+	for (const want of [
+		"skills",
+		".opencode/skills",
+		".claude/skills",
+		".gemini/skills",
+		".cursor/skills",
+		".github/skills",
+		".codex/skills",
+		".qwen/skills",
+		".kiro/skills",
+		".openclaw/skills",
+		".pi/skills",
+		".agent/skills",
+		".agents/skills",
+		".atl/skills",
+	]) {
+		assert.ok(dirs.includes(join(cwd, want)), `missing ${want}`);
+	}
+});
+
+test("Compact Rules are preferred over fallback sections", () => {
+	const rules = __testing.extractCompactRulesSection(`## Compact Rules
+
+- Explicit compact rule.
+
+## Hard Rules
+
+- Hard rule should not be copied.
+`);
+
+	assert.deepEqual(rules, ["Explicit compact rule."]);
+});
+
+test("LLM-first and legacy sections extract bullets, ordered lists, and tables", () => {
+	const rules = __testing.extractCompactRulesSection(`## Hard Rules
+
+- Prefer focused tests.
+
+## Critical Rules
+
+1. Link an approved issue.
+2. Keep PRs within review budget.
+
+## Voice Rules
+
+| Rule | Requirement |
+|------|-------------|
+| Be warm | Sound like a teammate. |
+
+## Decision Gates
+
+| Target | Test pattern |
+|---|---|
+| File operations | Use t.TempDir(). |
+`);
+
+	assert.deepEqual(rules, [
+		"Prefer focused tests.",
+		"Link an approved issue.",
+		"Keep PRs within review budget.",
+		"Be warm: Sound like a teammate.",
+		"File operations: Use t.TempDir().",
+	]);
+});
+
+test("description trigger text is extracted when present", () => {
+	assert.equal(
+		__testing.extractTriggerDescription("Write comments. Trigger: PR feedback, issue replies."),
+		"PR feedback, issue replies.",
+	);
+	assert.equal(__testing.extractTriggerDescription("No explicit trigger."), "No explicit trigger.");
+});
+
+test("fallback extraction is capped at 15 rules", () => {
+	const body = `## Hard Rules
+
+${Array.from({ length: 16 }, (_, i) => `- Rule ${String(i + 1).padStart(2, "0")}.`).join("\n")}
+`;
+	const rules = __testing.extractCompactRulesSection(body);
+
+	assert.equal(rules.length, 15);
+	assert.equal(rules.at(-1), "Rule 15.");
+});
+
+test("project-scoped duplicate wins over user duplicate", () => {
+	const cwd = join(tmpdir(), `gentle-pi-registry-${Date.now()}`);
+	const projectPath = join(cwd, ".opencode/skills/dup/SKILL.md");
+	const userPath = join(cwd + "-home", ".config/opencode/skills/dup/SKILL.md");
+	const entries = [
+		{ name: "dup", path: userPath, description: "user", rules: ["User rule."] },
+		{ name: "dup", path: projectPath, description: "project", rules: ["Project rule."] },
+	];
+
+	const [chosen] = __testing.dedupeBySkillName(entries, cwd);
+	assert.equal(chosen.path, projectPath);
+});
+
+test("uniqueExistingDirs normalizes duplicates and ignores missing roots", () => {
+	const root = join(tmpdir(), `gentle-pi-existing-${Date.now()}`);
+	const existing = join(root, "skills");
+	mkdirSync(existing, { recursive: true });
+
+	assert.deepEqual(__testing.uniqueExistingDirs([existing, join(root, "skills/"), join(root, "missing")]), [existing]);
+});