@xynogen/pix-welcome 0.1.2 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-welcome",
-	"version": "0.1.2",
+	"version": "0.1.4",
 	"description": "Pi extension — welcome banner with startup health checks",
 	"type": "module",
 	"main": "src/index.ts",

package/src/welcome.test.ts

@@ -1,12 +1,17 @@
 import { describe, expect, it } from "bun:test";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import {
 	type CheckResult,
+	countSkillsInDirs,
 	LABEL_WIDTH,
 	LOGO_ROWS,
 	PI_IGNORE_RULES,
 	renderCheck,
 	shortCwd,
 	statusIcon,
+	summariseSkills,
 	summariseTools,
 	type Theme,
 } from "./welcome.ts";
@@ -117,6 +122,86 @@ describe("summariseTools", () => {
 	});
 });
 
+describe("summariseSkills", () => {
+	it("warns when no skills loaded", () => {
+		const r = summariseSkills([]);
+		expect(r.status).toBe("warn");
+		expect(r.detail).toBe("none loaded");
+	});
+
+	it("reports count when all skills are auto-invocable", () => {
+		const r = summariseSkills([{}, {}, {}]);
+		expect(r.status).toBe("ok");
+		expect(r.detail).toBe("3 loaded");
+	});
+
+	it("notes manual skills in detail", () => {
+		const r = summariseSkills([{}, { disableModelInvocation: true }, {}]);
+		expect(r.status).toBe("ok");
+		expect(r.detail).toBe("3 loaded (+1 manual)");
+	});
+
+	it("marks all-manual as manual", () => {
+		const r = summariseSkills([
+			{ disableModelInvocation: true },
+			{ disableModelInvocation: true },
+		]);
+		expect(r.status).toBe("ok");
+		expect(r.detail).toBe("2 loaded (manual)");
+	});
+});
+
+describe("countSkillsInDirs", () => {
+	it("returns 0 for nonexistent dirs", () => {
+		expect(countSkillsInDirs(["/nonexistent/path/xyz"])).toBe(0);
+	});
+
+	it("counts flat .md files", () => {
+		const dir = mkdtempSync(join(tmpdir(), "pix-skills-"));
+		try {
+			writeFileSync(
+				join(dir, "commit.md"),
+				"---\nname: commit\ndescription: test\n---\n",
+			);
+			writeFileSync(
+				join(dir, "debug.md"),
+				"---\nname: debug\ndescription: test\n---\n",
+			);
+			expect(countSkillsInDirs([dir])).toBe(2);
+		} finally {
+			rmSync(dir, { recursive: true });
+		}
+	});
+
+	it("counts subdir SKILL.md layout", () => {
+		const dir = mkdtempSync(join(tmpdir(), "pix-skills-"));
+		try {
+			mkdirSync(join(dir, "my-skill"));
+			writeFileSync(
+				join(dir, "my-skill", "SKILL.md"),
+				"---\nname: my-skill\ndescription: test\n---\n",
+			);
+			expect(countSkillsInDirs([dir])).toBe(1);
+		} finally {
+			rmSync(dir, { recursive: true });
+		}
+	});
+
+	it("deduplicates across dirs", () => {
+		const dir = mkdtempSync(join(tmpdir(), "pix-skills-"));
+		try {
+			writeFileSync(
+				join(dir, "foo.md"),
+				"---\nname: foo\ndescription: test\n---\n",
+			);
+			// same dir twice — should still count 1
+			expect(countSkillsInDirs([dir, dir])).toBe(1);
+		} finally {
+			rmSync(dir, { recursive: true });
+		}
+	});
+});
+
 describe("PI_IGNORE_RULES", () => {
 	it("includes both rules", () => {
 		expect(PI_IGNORE_RULES).toEqual([".pi/", ".pi-lens/"]);

package/src/welcome.ts

@@ -27,6 +27,9 @@
  *   ✓ Ignore  up to date
  */
 
+import { existsSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 import type {
 	ExtensionAPI,
 	ExtensionContext,
@@ -170,6 +173,116 @@ async function checkPiIgnore(
 	}
 }
 
+interface SkillInfo {
+	disableModelInvocation?: boolean;
+}
+
+/**
+ * Discover all `skills/` directories from:
+ *   1. The pi-agent npm extensions dir (walks one scope level deep)
+ *   2. ~/.pi/agent/skills (user-level)
+ *   3. Any extra dirs passed by the caller
+ *
+ * Mirrors how pi's resource-loader collects skillPaths from resources_discover.
+ * Does NOT depend on before_agent_start — safe to call at session_start.
+ */
+export function discoverSkillDirs(extraDirs: string[] = []): string[] {
+	const npmDir = join(homedir(), ".pi", "agent", "npm", "node_modules");
+	const found: string[] = [];
+
+	// Walk npm extensions dir: flat packages + scoped (@scope/pkg)
+	if (existsSync(npmDir)) {
+		try {
+			for (const pkg of readdirSync(npmDir, { withFileTypes: true })) {
+				if (!pkg.isDirectory() && !pkg.isSymbolicLink()) continue;
+				if (pkg.name.startsWith("@")) {
+					// scoped: walk one level deeper
+					const scopeDir = join(npmDir, pkg.name);
+					try {
+						for (const sub of readdirSync(scopeDir, { withFileTypes: true })) {
+							if (!sub.isDirectory() && !sub.isSymbolicLink()) continue;
+							const skillsDir = join(scopeDir, sub.name, "skills");
+							if (existsSync(skillsDir)) found.push(skillsDir);
+						}
+					} catch {
+						/* skip */
+					}
+				} else {
+					const skillsDir = join(npmDir, pkg.name, "skills");
+					if (existsSync(skillsDir)) found.push(skillsDir);
+				}
+			}
+		} catch {
+			/* skip */
+		}
+	}
+
+	// User-level skills dir
+	const userSkills = join(homedir(), ".pi", "agent", "skills");
+	if (existsSync(userSkills)) found.push(userSkills);
+
+	found.push(...extraDirs);
+	return found;
+}
+
+/**
+ * Count skills in an explicit list of skill directories.
+ * Deduplicates by resolved real path to avoid double-counting symlinked packages.
+ */
+export function countSkillsInDirs(dirs: string[]): number {
+	let total = 0;
+	const seen = new Set<string>();
+
+	const add = (p: string) => {
+		const real = (() => {
+			try {
+				return resolve(p);
+			} catch {
+				return p;
+			}
+		})();
+		if (seen.has(real)) return;
+		seen.add(real);
+		total++;
+	};
+
+	for (const dir of dirs) {
+		if (!existsSync(dir)) continue;
+		try {
+			for (const entry of readdirSync(dir, { withFileTypes: true })) {
+				if (entry.isDirectory()) {
+					const skillMd = join(dir, entry.name, "SKILL.md");
+					if (existsSync(skillMd)) add(skillMd);
+				} else if (entry.isFile() && entry.name.endsWith(".md")) {
+					add(join(dir, entry.name));
+				}
+			}
+		} catch {
+			/* skip */
+		}
+	}
+	return total;
+}
+
+/** Count skills across all auto-discovered + extra dirs. */
+export function countSkillsFromDirs(extraDirs: string[] = []): number {
+	return countSkillsInDirs(discoverSkillDirs(extraDirs));
+}
+
+export function summariseSkills(skills: SkillInfo[]): CheckResult {
+	const total = skills.length;
+	if (total === 0)
+		return { label: "Skills", status: "warn", detail: "none loaded" };
+	const manual = skills.filter((s) => s.disableModelInvocation).length;
+	const detail =
+		manual === total
+			? `${total} loaded (manual)`
+			: manual > 0
+				? `${total} loaded (+${manual} manual)`
+				: `${total} loaded`;
+	return { label: "Skills", status: "ok", detail };
+}
+
 interface ToolInfo {
 	sourceInfo?: { source?: string };
 }
@@ -285,6 +398,7 @@ function buildCheckLines(theme: Theme, checks: CheckResult[]): string[] {
 export default function (pi: ExtensionAPI) {
 	let dismissed = false;
 	let requestRender: (() => void) | null = null;
+	let _updateSkills: ((r: CheckResult) => void) | null = null;
 
 	const dismiss = (ctx: ExtensionContext) => {
 		if (dismissed) return;
@@ -306,6 +420,7 @@ export default function (pi: ExtensionAPI) {
 			{ label: "Auth", status: "pending" },
 			{ label: "Models", status: "pending" },
 			{ label: "Tools", status: "pending" },
+			{ label: "Skills", status: "pending" },
 			{ label: "Ignore", status: "pending" },
 		];
 
@@ -344,20 +459,35 @@ export default function (pi: ExtensionAPI) {
 			requestRender?.();
 		};
 
+		// Expose skills updater so the before_agent_start handler can refine the count.
+		_updateSkills = (r: CheckResult) => update(4, r);
+
 		void checkPiVersion(pi).then((r) => update(0, r));
-		void checkPiIgnore(pi, ctx.cwd).then((r) => update(4, r));
+		void checkPiIgnore(pi, ctx.cwd).then((r) => update(5, r));
 		// auth already filled synchronously above; no async needed
 
 		// Tools register during session_start (incl. other extensions); read on
 		// next tick so dynamically registered tools are counted.
-		setTimeout(
-			() =>
-				update(
-					3,
-					checkTools(pi as unknown as { getActiveTools?: () => ToolInfo[] }),
-				),
-			0,
-		);
+		// Skills: scan dirs immediately — no need to wait for before_agent_start.
+		setTimeout(() => {
+			update(
+				3,
+				checkTools(pi as unknown as { getActiveTools?: () => ToolInfo[] }),
+			);
+			update(4, {
+				label: "Skills",
+				status: "ok",
+				detail: `${countSkillsFromDirs()} loaded`,
+			});
+		}, 0);
+	});
+
+	// before_agent_start fires after resources_discover — use the authoritative
+	// skills list from systemPromptOptions to refine the count, then dismiss.
+	pi.on("before_agent_start", (event, ctx) => {
+		const skills = event.systemPromptOptions?.skills ?? [];
+		if (skills.length > 0) _updateSkills?.(summariseSkills(skills));
+		dismiss(ctx);
 	});
 
 	pi.on("turn_start", (_event, ctx) => {