pi-crew 0.9.26 → 0.9.28

package/scripts/check-all-skills.ts

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+
+/**
+ * Check All Skills Script
+ *
+ * Runs verify-skill.ts against all skills and produces a summary report.
+ *
+ * Usage:
+ *   node scripts/check-all-skills.ts
+ */
+
+import { spawnSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+
+interface SkillSummary {
+	name: string;
+	path: string;
+	status: "pass" | "fail" | "warning";
+	warnings: string[];
+	errors: string[];
+}
+
+interface Report {
+	total: number;
+	passed: number;
+	failed: number;
+	warningsOnly: number;
+	skills: SkillSummary[];
+	timestamp: string;
+}
+
+const SKILLS_DIR = path.join(process.cwd(), "skills");
+
+/**
+ * Get all skill directories
+ */
+function getSkillDirs(): string[] {
+	if (!fs.existsSync(SKILLS_DIR)) {
+		console.error("Skills directory not found: " + SKILLS_DIR);
+		return [];
+	}
+
+	const dirs: string[] = [];
+	const entries = fs.readdirSync(SKILLS_DIR, { withFileTypes: true });
+
+	for (const entry of entries) {
+		if (entry.isDirectory()) {
+			const skillPath = path.join(SKILLS_DIR, entry.name, "SKILL.md");
+			if (fs.existsSync(skillPath)) {
+				dirs.push(entry.name);
+			}
+		}
+	}
+
+	return dirs.sort();
+}
+
+/**
+ * Run verify-skill.ts for a single skill
+ */
+function verifySingleSkill(skillName: string): {
+	passed: boolean;
+	warnings: string[];
+	errors: string[];
+} {
+	const skillPath = path.join(SKILLS_DIR, skillName, "SKILL.md");
+
+	const result = spawnSync("node", ["scripts/verify-skill.ts", skillPath], {
+		cwd: process.cwd(),
+		encoding: "utf-8",
+	});
+
+	const output = result.stdout + result.stderr;
+	const warnings: string[] = [];
+	const errors: string[] = [];
+
+	// Parse output
+	const warningMatches = output.match(/[^\n]*⚠️[^\n]*/g);
+	const errorMatches = output.match(/[^\n]+FAIL[^\n]+/g);
+
+	if (warningMatches) {
+		warnings.push(...warningMatches.map((w) => w.trim()));
+	}
+	if (errorMatches) {
+		errors.push(...errorMatches.map((e) => e.trim()));
+	}
+
+	const passed = result.status === 0;
+
+	return { passed, warnings, errors };
+}
+
+/**
+ * Generate markdown report
+ */
+function generateMarkdownReport(report: Report): string {
+	const lines: string[] = [];
+
+	lines.push("# Skill Verification Report");
+	lines.push("");
+	lines.push("Generated: " + report.timestamp);
+	lines.push("");
+
+	// Summary table
+	lines.push("## Summary");
+	lines.push("");
+	lines.push("| Status | Count |");
+	lines.push("|--------|-------|");
+	lines.push("| PASS | " + report.passed + " |");
+	lines.push("| FAIL | " + report.failed + " |");
+	lines.push("| Warnings | " + report.warningsOnly + " |");
+	lines.push("| **Total** | **" + report.total + "** |");
+	lines.push("");
+
+	// Skill list by status
+	lines.push("## Skills by Status");
+	lines.push("");
+
+	// Passed skills
+	const passedSkills = report.skills.filter((s) => s.status === "pass");
+	if (passedSkills.length > 0) {
+		lines.push("### Passing Skills");
+		lines.push("");
+		for (const skill of passedSkills) {
+			lines.push("- " + skill.name);
+		}
+		lines.push("");
+	}
+
+	// Failed skills
+	const failedSkills = report.skills.filter((s) => s.status === "fail");
+	if (failedSkills.length > 0) {
+		lines.push("### Failing Skills");
+		lines.push("");
+		for (const skill of failedSkills) {
+			lines.push("- **" + skill.name + "**");
+			for (const error of skill.errors) {
+				lines.push("  - " + error);
+			}
+		}
+		lines.push("");
+	}
+
+	// Warning skills
+	const warningSkills = report.skills.filter((s) => s.status === "warning");
+	if (warningSkills.length > 0) {
+		lines.push("### Skills with Warnings");
+		lines.push("");
+		for (const skill of warningSkills) {
+			lines.push("- **" + skill.name + "**");
+			for (const warning of skill.warnings) {
+				lines.push("  - " + warning);
+			}
+		}
+		lines.push("");
+	}
+
+	// Recommendations
+	lines.push("## Recommendations");
+	lines.push("");
+	if (failedSkills.length > 0) {
+		lines.push("1. Fix " + failedSkills.length + " failing skills to have proper RED/GREEN gates");
+		lines.push("2. Add trigger sections (When to Activate) if missing");
+		lines.push("3. Add anti-patterns sections to prevent common mistakes");
+		lines.push("");
+	}
+	if (warningSkills.length > 0) {
+		lines.push("4. Review " + warningSkills.length + " skills with warnings for improvements");
+	}
+
+	return lines.join("\n");
+}
+
+/**
+ * Generate JSON report
+ */
+function generateJsonReport(report: Report): string {
+	return JSON.stringify(report, null, 2);
+}
+
+/**
+ * Main entry point
+ */
+async function main() {
+	console.log("Checking all skills...\n");
+
+	const skillNames = getSkillDirs();
+	console.log("Found " + skillNames.length + " skills\n");
+
+	const report: Report = {
+		total: skillNames.length,
+		passed: 0,
+		failed: 0,
+		warningsOnly: 0,
+		skills: [],
+		timestamp: new Date().toISOString(),
+	};
+
+	for (const skillName of skillNames) {
+		process.stdout.write(".");
+
+		const result = verifySingleSkill(skillName);
+
+		let status: "pass" | "fail" | "warning" = "pass";
+		if (!result.passed && result.errors.length > 0) {
+			status = "fail";
+			report.failed++;
+		} else if (result.warnings.length > 0) {
+			status = "warning";
+			report.warningsOnly++;
+		} else {
+			report.passed++;
+		}
+
+		report.skills.push({
+			name: skillName,
+			path: path.join("skills", skillName, "SKILL.md"),
+			status,
+			warnings: result.warnings,
+			errors: result.errors,
+		});
+	}
+
+	console.log("\n\n");
+
+	// Print summary
+	console.log("=== Skill Verification Summary ===");
+	console.log("Total: " + report.total);
+	console.log("Passed: " + report.passed);
+	console.log("Failed: " + report.failed);
+	console.log("Warnings only: " + report.warningsOnly);
+	console.log("");
+
+	// List failed skills
+	if (report.failed > 0) {
+		console.log("Failing skills:");
+		for (const skill of report.skills.filter((s) => s.status === "fail")) {
+			console.log("  - " + skill.name);
+			for (const error of skill.errors) {
+				console.log("    " + error);
+			}
+		}
+		console.log("");
+	}
+
+	// List skills with warnings
+	if (report.warningsOnly > 0) {
+		console.log("Skills with warnings:");
+		for (const skill of report.skills.filter((s) => s.status === "warning")) {
+			console.log("  - " + skill.name);
+			for (const warning of skill.warnings) {
+				console.log("    " + warning);
+			}
+		}
+		console.log("");
+	}
+
+	// Write reports
+	const reportDir = path.join(process.cwd(), "reports");
+	if (!fs.existsSync(reportDir)) {
+		fs.mkdirSync(reportDir, { recursive: true });
+	}
+
+	const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+	const mdReportPath = path.join(reportDir, "skill-verification-" + timestamp + ".md");
+	const jsonReportPath = path.join(reportDir, "skill-verification-" + timestamp + ".json");
+	const latestMdPath = path.join(reportDir, "skill-verification-latest.md");
+	const latestJsonPath = path.join(reportDir, "skill-verification-latest.json");
+
+	fs.writeFileSync(mdReportPath, generateMarkdownReport(report));
+	fs.writeFileSync(jsonReportPath, generateJsonReport(report));
+	fs.writeFileSync(latestMdPath, generateMarkdownReport(report));
+	fs.writeFileSync(latestJsonPath, generateJsonReport(report));
+
+	console.log("Reports written to:");
+	console.log("  - " + mdReportPath);
+	console.log("  - " + jsonReportPath);
+	console.log("  - " + latestMdPath + " (latest)");
+	console.log("  - " + latestJsonPath + " (latest)");
+
+	// Exit with appropriate code
+	if (report.failed > 0) {
+		process.exit(1);
+	} else if (report.warningsOnly > 0) {
+		process.exit(2);
+	}
+	process.exit(0);
+}
+
+main().catch((err) => {
+	console.error("Fatal error:", err);
+	process.exit(1);
+});

package/scripts/check-bundle-staleness.mjs

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+/**
+ * CI gate: detect stale dist/index.mjs vs src/.
+ *
+ * Compares the newest mtime in src/ against dist/index.mjs mtime. If
+ * src/ is newer, the bundle is stale (someone edited source without
+ * rebuilding). Exits non-zero in that case.
+ *
+ * Why: in v0.9.17 the entrypoint prefers the bundle (with strip-types
+ * fallback). Stale bundles silently run old code — see Phase 5 H2
+ * investigation (2026-07-01) for the regression risk.
+ *
+ * Skips if dist/index.mjs does not exist (the strip-types fallback path
+ * is fine and the build:bundle automation will produce it).
+ *
+ * Exits:
+ *   0 — dist is fresh OR absent
+ *   1 — dist is stale (run `npm run build:bundle`)
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+
+const distPath = "dist/index.mjs";
+if (!existsSync(distPath)) {
+	console.log("[check-bundle-staleness] dist/index.mjs absent — strip-types fallback will be used. OK.");
+	process.exit(0);
+}
+
+const distMtimeMs = statSync(distPath).mtimeMs;
+
+// `git ls-files -o -- src` lists untracked files in src/. We want every
+// tracked file's mtime plus the newest untracked one. Cheap heuristic:
+// use `find` style by asking git for the full list, then statSync each.
+let trackedFiles;
+try {
+	trackedFiles = execSync(`git ls-files src`, { encoding: "utf-8" })
+		.split("\n")
+		.filter(Boolean);
+} catch {
+	// Not a git repo (e.g. npm pack test) — skip.
+	console.log("[check-bundle-staleness] not a git repo; skipping staleness check.");
+	process.exit(0);
+}
+
+let newestMtimeMs = 0;
+let newestFile = "";
+for (const f of trackedFiles) {
+	try {
+		const mt = statSync(f).mtimeMs;
+		if (mt > newestMtimeMs) {
+			newestMtimeMs = mt;
+			newestFile = f;
+		}
+	} catch {
+		// File listed but missing on disk — ignore.
+	}
+}
+
+// Add untracked .ts files in src/ (devs editing a new file)
+try {
+	const untracked = execSync(`git ls-files -o --exclude-standard src`, { encoding: "utf-8" })
+		.split("\n")
+		.filter(Boolean);
+	for (const f of untracked) {
+		if (!f.endsWith(".ts")) continue;
+		try {
+			const mt = statSync(f).mtimeMs;
+			if (mt > newestMtimeMs) {
+				newestMtimeMs = mt;
+				newestFile = f;
+			}
+		} catch {
+			// ignore
+		}
+	}
+} catch {
+	// git may fail; ignore
+}
+
+if (newestMtimeMs === 0) {
+	console.log("[check-bundle-staleness] no src/*.ts files found; skipping.");
+	process.exit(0);
+}
+
+if (newestMtimeMs > distMtimeMs) {
+	console.error(
+		`[check-bundle-staleness] FAIL: dist/index.mjs is stale.\n` +
+			`  Newest src file: ${newestFile} (mtime=${newestMtimeMs.toFixed(0)})\n` +
+			`  dist/index.mjs mtime: ${distMtimeMs.toFixed(0)}\n` +
+			`  → run \`npm run build:bundle\` to refresh.`,
+	);
+	process.exit(1);
+}
+
+const ageSec = (distMtimeMs - newestMtimeMs) / 1000;
+console.log(`[check-bundle-staleness] OK: dist/index.mjs is ${ageSec.toFixed(1)}s newer than newest src/ file.`);

package/scripts/check-conflict-markers.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * CI gate: detect unresolved git merge conflict markers in source.
+ *
+ * Scans tracked source files for `<<<<<<<`, `=======` (lone), and
+ * `>>>>>>>` patterns that indicate a botched merge. Fails CI if any
+ * are found so they can't reach the bundle (which esbuild would
+ * choke on with a parse error).
+ *
+ * History: 2026-07-01 CI #28498831579 (Ubuntu) failed because
+ * src/runtime/child-pi.ts and src/extension/pi-api.ts shipped with
+ * unresolved conflict markers left over from earlier stash/pop cycles
+ * during Phase 2-5 implementation. The esbuild transformer in the
+ * test runner hit `Expected identifier but found "<<"` at
+ * src/runtime/child-pi.ts:1073 — a syntax error caused by the markers.
+ *
+ * Scope:
+ *   - Tracks files in src/, test/, scripts/, workflows/, teams/,
+ *     agents/, themes/ — anywhere a conflict would land.
+ *   - Excludes test/unit/conflict-detect.test.ts which INTENTIONALLY
+ *     contains `<<<<<<< HEAD` etc. as test fixtures (test the
+     detector itself).
+ *   - Detects both conflict-style (`<<<<<<<`, `=======`, `>>>>>>>`)
+ *     and diff3-style (`|||||||`) markers.
+ *
+ * Exits:
+ *   0 — clean (no markers found, or only allowed locations)
+ *   1 — markers found (with file:line listing)
+ */
+
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const MARKER_PATTERNS = [
+	/^<<<<<<< /m, // ours/incoming/conflict markers
+	/^=======$/m, // conflict separator (lone, not bash =======)
+	/^>>>>>>> /m, // theirs/outgoing markers
+	/^\|\|\|\|\|\|\| /m, // diff3 base marker
+];
+
+const SCAN_PATHS = ["src/", "test/", "scripts/", "workflows/", "teams/", "agents/", "themes/"];
+const EXCLUDE_FILES = new Set([
+	// Intentionally contains conflict markers as test fixtures.
+	"test/unit/conflict-detect.test.ts",
+]);
+
+function listTrackedFiles() {
+	try {
+		const all = execSync("git ls-files", { encoding: "utf-8" });
+		return all
+			.split("\n")
+			.filter(Boolean)
+			.filter((f) => SCAN_PATHS.some((p) => f.startsWith(p) || f === p.replace(/\/$/, "")))
+			.filter((f) => !EXCLUDE_FILES.has(f));
+	} catch {
+		console.error("[conflict-markers] not a git repo; skipping check.");
+		process.exit(0);
+	}
+}
+
+const files = listTrackedFiles();
+const offenders = [];
+
+for (const file of files) {
+	let content;
+	try {
+		content = readFileSync(file, "utf-8");
+	} catch {
+		// File listed but unreadable — skip silently.
+		continue;
+	}
+	const lines = content.split(/\r?\n/);
+	for (let i = 0; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (MARKER_PATTERNS.some((re) => re.test(line))) {
+			offenders.push({ file, line: i + 1, text: line });
+		}
+	}
+}
+
+if (offenders.length === 0) {
+	console.log(`[conflict-markers] OK: scanned ${files.length} files, no markers found.`);
+	process.exit(0);
+}
+
+console.error(`[conflict-markers] FAIL: ${offenders.length} conflict marker(s) found.`);
+for (const o of offenders) {
+	console.error(`  ${o.file}:${o.line}: ${o.text.trim().slice(0, 80)}`);
+}
+console.error("\nResolve with: git checkout --ours|--theirs or git add ... after manual edit.");
+process.exit(1);

package/scripts/check-lazy-imports.mjs

@@ -0,0 +1,28 @@
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+const out = execSync(
+	`git grep -nE "await import\\(" -- "src/**/*.ts"`,
+	{ encoding: "utf-8" },
+);
+
+const bad = [];
+const fileCache = new Map();
+
+for (const line of out.split("\n").filter(Boolean)) {
+	if (line.includes("// LAZY:")) continue;
+	const m = line.match(/^([^:]+):(\d+):/);
+	if (!m) continue;
+	const [, file, lineNum] = m;
+	if (!fileCache.has(file)) fileCache.set(file, readFileSync(file, "utf-8").split(/\r?\n/));
+	const lines = fileCache.get(file);
+	const prevLine = lines[Number(lineNum) - 2] ?? "";
+	if (!prevLine.includes("// LAZY:")) bad.push(line);
+}
+
+if (bad.length > 0) {
+	console.error("Dynamic imports without `// LAZY:` marker:\n" + bad.join("\n"));
+	process.exit(1);
+}
+
+console.log("All dynamic imports have `// LAZY:` marker.");

package/scripts/install-crew-vibes-font.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+/**
+ * Installs the bundled crew-vibes.ttf (PUA glyphs U+E700..U+E70A) into the
+ * user fonts directory so the crew-vibes speed + capacity figures render
+ * instead of tofu boxes. Cross-platform mirror of pi-speeed's install-font.
+ *
+ *   macOS   ~/Library/Fonts/crew-vibes.ttf
+ *   Linux   ~/.local/share/fonts/crew-vibes.ttf  (+ fc-cache -f)
+ *   Windows %LOCALAPPDATA%\Microsoft\Windows\Fonts\crew-vibes.ttf (per-user)
+ *
+ * Invoked by the npm `postinstall` hook and by `npm run install:crew-font`.
+ * Best-effort: never fails the install.
+ */
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const source = join(__dirname, "..", "assets", "crew-vibes.ttf");
+const FONT_NAME = "crew-vibes.ttf";
+
+function log(message) {
+	console.log(`[pi-crew] ${message}`);
+}
+
+function installFont() {
+	if (!existsSync(source)) {
+		log(`crew-vibes font missing: ${source}`);
+		return;
+	}
+
+	const os = platform();
+	let targetDir;
+
+	if (os === "darwin") {
+		targetDir = join(homedir(), "Library", "Fonts");
+	} else if (os === "linux") {
+		targetDir = join(homedir(), ".local", "share", "fonts");
+	} else if (os === "win32") {
+		const localAppData = process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local");
+		targetDir = join(localAppData, "Microsoft", "Windows", "Fonts");
+	} else {
+		log(`Skipping font install on unsupported platform: ${os}`);
+		return;
+	}
+
+	mkdirSync(targetDir, { recursive: true });
+	const target = join(targetDir, FONT_NAME);
+	copyFileSync(source, target);
+	log(`Installed crew-vibes font to ${target}`);
+
+	if (os === "linux") {
+		// Refresh fontconfig cache so newly installed font is immediately
+		// available to all terminals.  -fv for verbose + forced rebuild.
+		const result = spawnSync("fc-cache", ["-fv", targetDir], { stdio: "ignore" });
+		if (result.status === 0) log("Refreshed font cache (fc-cache -fv)");
+		else log("fontconfig fc-cache not available; restart terminal if font is not visible");
+
+		// Verify font is actually indexed by fontconfig
+		const verify = spawnSync("fc-match", [":charset=E700"], { encoding: "utf8" });
+		if (verify.stdout && verify.stdout.includes(FONT_NAME)) {
+			log("Font verified: fc-match U+E700 -> crew-vibes.ttf");
+		} else {
+			log("WARNING: fc-match did not resolve U+E700 to crew-vibes.ttf");
+			log("  Run: fc-cache -fv " + targetDir);
+			log("  Then restart your terminal.");
+		}
+	}
+
+	if (os === "win32") {
+		// Register the per-user font in HKCU so Windows Terminal and other
+		// apps pick it up for PUA glyph fallback. Copying alone is not enough.
+		const regValue = "Crew Vibes (TrueType)";
+		const regResult = spawnSync("reg", ["add", "HKCU\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", "/v", regValue, "/t", "REG_SZ", "/d", target, "/f"], { stdio: "ignore" });
+		if (regResult.status === 0) log("Registered crew-vibes font in Windows registry (HKCU)");
+		else log("Windows registry registration skipped (reg.exe unavailable); glyphs may not render until font is installed via Settings");
+	}
+
+	if (os === "darwin" || os === "win32") {
+		log("Restart your terminal (or select a Crew-Vibes-capable font) if glyphs still show as boxes");
+	}
+}
+
+try {
+	installFont();
+} catch (error) {
+	log(`Font install failed: ${error instanceof Error ? error.message : String(error)}`);
+	process.exitCode = 0;
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * Cross-platform postinstall orchestrator.
+ *
+ *   1. Build the ESM bundle (best-effort; on failure we log a fallback and
+ *      let Pi fall back to strip-types loading).
+ *   2. Install the bundled crew-vibes.ttf into the user fonts directory so
+ *      the crew-vibes speed/capacity PUA glyphs render.
+ *
+ * Replaces the old `postinstall` shell chain so the font install runs on
+ * every platform without relying on shell-specific chaining (`;`/`&&`).
+ */
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = join(__dirname, "..");
+
+function run(scriptRel) {
+	const abs = join(root, scriptRel);
+	if (!existsSync(abs)) return 1;
+	const result = spawnSync(process.execPath, [abs], { stdio: "inherit" });
+	return result.status ?? 1;
+}
+
+function main() {
+	try {
+		// Dev clones ship scripts/build-bundle.mjs and devDeps (esbuild) so the
+		// bundle rebuilds; published packages omit both and rely on committed
+		// dist/index.mjs, so this best-effort build simply no-ops.
+		const bundleStatus = run("scripts/build-bundle.mjs");
+		if (bundleStatus !== 0) {
+			console.warn(
+				"[pi-crew] postinstall: bundle build skipped or failed; using committed dist/ (or strip-types fallback). Run npm run build:bundle to retry.",
+			);
+		}
+		// Font install is best-effort and must never fail the install.
+		run("scripts/install-crew-vibes-font.mjs");
+	} catch (err) {
+		// Postinstall must NEVER fail the install (SEC-M2).
+		console.warn("[pi-crew] postinstall: best-effort step failed:", err instanceof Error ? err.message : err);
+	}
+}
+
+main();