@kmiyh/pi-skills-menu 1.0.1

package/src/delete-skill.ts

@@ -0,0 +1,20 @@
+import { rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { SkillEntry } from "./types.js";
+
+export function isDeletableSkill(skill: SkillEntry): boolean {
+	return skill.origin === "top-level" && (skill.scope === "project" || skill.scope === "user");
+}
+
+export async function deleteSkill(ctx: ExtensionContext, skill: SkillEntry): Promise<boolean> {
+	if (!isDeletableSkill(skill)) {
+		ctx.ui.notify("Only your own project and global skills can be deleted", "warning");
+		return false;
+	}
+
+	const targetPath = dirname(skill.path);
+	await rm(targetPath, { recursive: true, force: true });
+	ctx.ui.notify(`Deleted skill: ${skill.name}`, "info");
+	return true;
+}

package/src/extension-scope.ts

@@ -0,0 +1,31 @@
+import { fileURLToPath } from "node:url";
+import { resolve, sep } from "node:path";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import type { ExtensionInstallScope } from "./types.js";
+
+function normalizeDir(path: string): string {
+	const normalized = resolve(path);
+	return normalized.endsWith(sep) ? normalized : normalized + sep;
+}
+
+function isWithin(path: string, parent: string): boolean {
+	const normalizedPath = normalizeDir(path);
+	const normalizedParent = normalizeDir(parent);
+	return normalizedPath.startsWith(normalizedParent);
+}
+
+export function detectExtensionInstallScope(cwd: string): ExtensionInstallScope {
+	const extensionFile = fileURLToPath(import.meta.url);
+	const agentDir = getAgentDir();
+	const projectPiDir = resolve(cwd, ".pi");
+
+	if (isWithin(extensionFile, projectPiDir)) {
+		return "project";
+	}
+
+	if (isWithin(extensionFile, agentDir)) {
+		return "global";
+	}
+
+	return "global";
+}

package/src/index.ts

@@ -0,0 +1,215 @@
+import type { ExtensionAPI, ExtensionContext, InputEventResult } from "@mariozechner/pi-coding-agent";
+import { createSkillFromAnswers } from "./create-skill.js";
+import { deleteSkill } from "./delete-skill.js";
+import { detectExtensionInstallScope } from "./extension-scope.js";
+import { expandSkillMarkers, hasSkillMarker, insertSkillMarker, removeIncompleteSkillMarkerLines } from "./markers.js";
+import { loadSkillRegistry } from "./skill-registry.js";
+import { ensureSkillCommandsHidden } from "./settings-toggle.js";
+import type { ExtensionInstallScope, SkillRegistry } from "./types.js";
+import { showSkillPreview } from "./ui/skill-preview.js";
+import { showSkillsSelector } from "./ui/skills-selector.js";
+
+const EMPTY_REGISTRY: SkillRegistry = {
+	skills: [],
+	byName: new Map(),
+};
+
+export default function skillsMenuExtension(pi: ExtensionAPI) {
+	let registry: SkillRegistry = EMPTY_REGISTRY;
+	let currentCwd: string | undefined;
+	let installScope: ExtensionInstallScope | undefined;
+	let hideChecked = false;
+	let pendingReload = false;
+	let terminalInputUnsubscribe: (() => void) | undefined;
+	let cleanupTimer: ReturnType<typeof setTimeout> | undefined;
+
+	async function refreshRegistry(cwd: string): Promise<SkillRegistry> {
+		registry = await loadSkillRegistry(cwd);
+		currentCwd = cwd;
+		return registry;
+	}
+
+	async function maybeHideBuiltinSkillCommands(ctx: ExtensionContext): Promise<boolean> {
+		if (hideChecked && currentCwd === ctx.cwd) {
+			return false;
+		}
+
+		installScope = detectExtensionInstallScope(ctx.cwd);
+		hideChecked = true;
+		const result = await ensureSkillCommandsHidden(installScope, ctx.cwd);
+		if (!result.changed) {
+			return false;
+		}
+
+		pendingReload = true;
+		const reload = (ctx as ExtensionContext & { reload?: () => Promise<void> }).reload;
+		if (typeof reload === "function") {
+			await reload.call(ctx);
+			return true;
+		}
+
+		return false;
+	}
+
+	function scheduleIncompleteMarkerCleanup(ctx: ExtensionContext): void {
+		if (!ctx.hasUI) {
+			return;
+		}
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+		}
+		cleanupTimer = setTimeout(() => {
+			const currentText = ctx.ui.getEditorText();
+			const sanitized = removeIncompleteSkillMarkerLines(currentText, registry);
+			if (sanitized.changed) {
+				ctx.ui.setEditorText(sanitized.text);
+			}
+		}, 0);
+	}
+
+	async function prepareSession(ctx: ExtensionContext): Promise<boolean> {
+		const reloaded = await maybeHideBuiltinSkillCommands(ctx);
+		if (reloaded) {
+			return true;
+		}
+
+		try {
+			await refreshRegistry(ctx.cwd);
+		} catch (error) {
+			registry = EMPTY_REGISTRY;
+			console.error("skills-menu: failed to load skills registry", error);
+		}
+
+		terminalInputUnsubscribe?.();
+		if (ctx.hasUI) {
+			terminalInputUnsubscribe = ctx.ui.onTerminalInput(() => {
+				scheduleIncompleteMarkerCleanup(ctx);
+				return undefined;
+			});
+		}
+
+		return false;
+	}
+
+	pi.registerCommand("skills", {
+		description: "Browse and insert available skills",
+		handler: async (_args, ctx) => {
+			if (pendingReload) {
+				pendingReload = false;
+				await ctx.reload();
+				return;
+			}
+
+			if (!ctx.hasUI) {
+				ctx.ui.notify("/skills requires interactive mode", "warning");
+				return;
+			}
+
+			let selectorIndex = 0;
+			let selectorQuery = "";
+			while (true) {
+				try {
+					await refreshRegistry(ctx.cwd);
+				} catch (error) {
+					console.error("skills-menu: failed to refresh skills registry", error);
+					ctx.ui.notify("Failed to load skills list", "error");
+					return;
+				}
+
+				const selection = await showSkillsSelector(ctx, registry, selectorIndex, selectorQuery);
+				if (!selection) {
+					return;
+				}
+				selectorIndex = selection.selectedIndex;
+				selectorQuery = selection.query;
+
+				if (selection.type === "create") {
+					const createdSkill = await createSkillFromAnswers(ctx, selection.answers, {
+						thinkingLevel: pi.getThinkingLevel(),
+					});
+					if (!createdSkill) {
+						continue;
+					}
+					await refreshRegistry(ctx.cwd);
+					const createdSkillIndex = registry.skills.findIndex((skill) => skill.path === createdSkill.path);
+					selectorIndex = createdSkillIndex >= 0 ? createdSkillIndex + 1 : 0;
+					selectorQuery = "";
+					continue;
+				}
+
+				if (selection.type === "preview") {
+					await showSkillPreview(ctx, selection.skill);
+					continue;
+				}
+
+				if (selection.type === "delete") {
+					const confirmed = await ctx.ui.confirm(
+						"Delete skill",
+						`Delete ${selection.skill.name}? This removes the skill from disk and cannot be undone.`,
+					);
+					if (!confirmed) {
+						continue;
+					}
+					try {
+						await deleteSkill(ctx, selection.skill);
+						selectorIndex = Math.max(0, selectorIndex - 1);
+					} catch (error) {
+						console.error("skills-menu: failed to delete skill", error);
+						ctx.ui.notify("Failed to delete skill", "error");
+					}
+					continue;
+				}
+
+				insertSkillMarker(ctx, selection.skill);
+				return;
+			}
+		},
+	});
+
+	pi.on("session_start", async (_event, ctx) => {
+		await prepareSession(ctx);
+	});
+
+	pi.on("session_shutdown", async () => {
+		terminalInputUnsubscribe?.();
+		terminalInputUnsubscribe = undefined;
+		if (cleanupTimer) {
+			clearTimeout(cleanupTimer);
+			cleanupTimer = undefined;
+		}
+	});
+
+	pi.on("input", async (event, ctx): Promise<InputEventResult | void> => {
+		if (event.source === "extension") {
+			return { action: "continue" };
+		}
+
+		if (!hasSkillMarker(event.text)) {
+			return { action: "continue" };
+		}
+
+		if (!currentCwd || currentCwd !== ctx.cwd || registry.skills.length === 0) {
+			try {
+				await refreshRegistry(ctx.cwd);
+			} catch (error) {
+				console.error("skills-menu: failed to refresh skills registry for input transform", error);
+				return { action: "continue" };
+			}
+		}
+
+		const expanded = expandSkillMarkers(event.text, registry);
+		if (!expanded.changed) {
+			return { action: "continue" };
+		}
+
+		if (!expanded.insertedSkill && expanded.text.trim().length === 0) {
+			ctx.ui.notify("Incomplete skill marker removed", "info");
+			return { action: "handled" };
+		}
+
+		return {
+			action: "transform",
+			text: expanded.text,
+		};
+	});
+}

package/src/markers.ts

@@ -0,0 +1,123 @@
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { SkillEntry, SkillRegistry } from "./types.js";
+
+export const SKILL_MARKER_PREFIX = "[skill] ";
+const SKILL_MARKER_FRAGMENTS = ["[skill]", "[skill", "[skil", "[ski", "[sk", "skill]"];
+
+export function buildSkillMarker(skillName: string): string {
+	return `${SKILL_MARKER_PREFIX}${skillName}`;
+}
+
+export function insertSkillMarker(ctx: ExtensionContext, skill: SkillEntry): void {
+	ctx.ui.pasteToEditor(`${buildSkillMarker(skill.name)}\n`);
+}
+
+function getMarkedSkillName(line: string): string | null {
+	const trimmed = line.trim();
+	if (!trimmed.startsWith(SKILL_MARKER_PREFIX)) return null;
+	const name = trimmed.slice(SKILL_MARKER_PREFIX.length).trim();
+	return name.length > 0 ? name : null;
+}
+
+function isPotentialSkillMarkerLine(line: string): boolean {
+	const trimmed = line.trim().toLowerCase();
+	return SKILL_MARKER_FRAGMENTS.some((fragment) => trimmed.startsWith(fragment));
+}
+
+function isCompleteSkillMarkerLine(line: string, registry: SkillRegistry): boolean {
+	const trimmed = line.trim();
+	const skillName = getMarkedSkillName(trimmed);
+	if (!skillName) return false;
+	return trimmed === buildSkillMarker(skillName) && registry.byName.has(skillName);
+}
+
+export function removeIncompleteSkillMarkerLines(
+	text: string,
+	registry: SkillRegistry,
+): { changed: boolean; text: string } {
+	const lines = text.split(/\r?\n/);
+	let changed = false;
+	const keptLines = lines.filter((line) => {
+		if (isCompleteSkillMarkerLine(line, registry)) {
+			return true;
+		}
+		if (line.trim().startsWith(SKILL_MARKER_PREFIX) || isPotentialSkillMarkerLine(line)) {
+			changed = true;
+			return false;
+		}
+		return true;
+	});
+
+	return {
+		changed,
+		text: keptLines.join("\n"),
+	};
+}
+
+function buildSingleSkillBlock(skill: SkillEntry): string {
+	const relativeHint = skill.baseDir ? `References are relative to ${skill.baseDir}.\n\n` : "";
+	return `<skill name="${skill.name}" location="${skill.path}">\n${relativeHint}${skill.content}\n</skill>`;
+}
+
+function buildMultiSkillBlock(skills: SkillEntry[]): string {
+	const combinedName = skills.map((skill) => skill.name).join(", ");
+	const combinedContent = skills
+		.map((skill) => {
+			const relativeHint = skill.baseDir ? `References are relative to ${skill.baseDir}.\n\n` : "";
+			return `## ${skill.name}\n\n${relativeHint}${skill.content}`;
+		})
+		.join("\n\n---\n\n");
+	return `<skill name="${combinedName}" location="multiple">\n${combinedContent}\n</skill>`;
+}
+
+export function hasSkillMarker(text: string): boolean {
+	return text
+		.split(/\r?\n/)
+		.some((line) => line.includes(SKILL_MARKER_PREFIX) || isPotentialSkillMarkerLine(line));
+}
+
+export function expandSkillMarkers(
+	text: string,
+	registry: SkillRegistry,
+): { changed: boolean; text: string; insertedSkill: boolean } {
+	const lines = text.split(/\r?\n/);
+	const selectedSkills: SkillEntry[] = [];
+	const remainingLines: string[] = [];
+	let changed = false;
+
+	for (const line of lines) {
+		const skillName = getMarkedSkillName(line);
+		if (skillName) {
+			const skill = registry.byName.get(skillName);
+			changed = true;
+			if (skill) {
+				selectedSkills.push(skill);
+			}
+			continue;
+		}
+
+		if (isPotentialSkillMarkerLine(line)) {
+			changed = true;
+			continue;
+		}
+
+		remainingLines.push(line);
+	}
+
+	if (selectedSkills.length === 0) {
+		return {
+			changed,
+			text: changed ? remainingLines.join("\n").trim() : text,
+			insertedSkill: false,
+		};
+	}
+
+	const skillBlock = selectedSkills.length === 1 ? buildSingleSkillBlock(selectedSkills[0]!) : buildMultiSkillBlock(selectedSkills);
+	const userText = remainingLines.join("\n").trim();
+
+	return {
+		changed: true,
+		text: userText ? `${skillBlock}\n\n${userText}` : skillBlock,
+		insertedSkill: true,
+	};
+}

package/src/settings-toggle.ts

@@ -0,0 +1,40 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import type { ExtensionInstallScope } from "./types.js";
+
+export interface SkillCommandSettingResult {
+	changed: boolean;
+	path: string;
+}
+
+export function getSettingsPath(scope: ExtensionInstallScope, cwd: string): string {
+	return scope === "global" ? join(getAgentDir(), "settings.json") : resolve(cwd, ".pi", "settings.json");
+}
+
+async function readSettings(path: string): Promise<Record<string, unknown>> {
+	try {
+		const content = await readFile(path, "utf8");
+		const parsed = JSON.parse(content);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+	} catch (error) {
+		if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+			return {};
+		}
+		throw error;
+	}
+}
+
+export async function ensureSkillCommandsHidden(scope: ExtensionInstallScope, cwd: string): Promise<SkillCommandSettingResult> {
+	const path = getSettingsPath(scope, cwd);
+	const settings = await readSettings(path);
+
+	if (settings.enableSkillCommands === false) {
+		return { changed: false, path };
+	}
+
+	settings.enableSkillCommands = false;
+	await mkdir(dirname(path), { recursive: true });
+	await writeFile(path, JSON.stringify(settings, null, 2) + "\n", "utf8");
+	return { changed: true, path };
+}

package/src/skill-parser.ts

@@ -0,0 +1,31 @@
+import { readFileSync } from "node:fs";
+import { parseFrontmatter, stripFrontmatter } from "@mariozechner/pi-coding-agent";
+import type { SkillEntry } from "./types.js";
+
+interface SkillFrontmatter {
+	name?: unknown;
+	description?: unknown;
+	[key: string]: unknown;
+}
+
+export function parseSkillFile(path: string): Pick<SkillEntry, "name" | "description" | "content" | "frontmatter"> | null {
+	try {
+		const raw = readFileSync(path, "utf8");
+		const { frontmatter } = parseFrontmatter<SkillFrontmatter>(raw);
+		const name = typeof frontmatter.name === "string" ? frontmatter.name.trim() : "";
+		const description = typeof frontmatter.description === "string" ? frontmatter.description.trim() : "";
+
+		if (!name || !description) {
+			return null;
+		}
+
+		return {
+			name,
+			description,
+			content: stripFrontmatter(raw).trim(),
+			frontmatter: Object.fromEntries(Object.entries(frontmatter).filter(([, value]) => value !== undefined)),
+		};
+	} catch {
+		return null;
+	}
+}

package/src/skill-registry.ts

@@ -0,0 +1,69 @@
+import { DefaultPackageManager, getAgentDir, SettingsManager, type ResolvedResource } from "@mariozechner/pi-coding-agent";
+import { parseSkillFile } from "./skill-parser.js";
+import type { SkillEntry, SkillRegistry } from "./types.js";
+
+function compareSkills(a: SkillEntry, b: SkillEntry): number {
+	const scopeRank = (scope: SkillEntry["scope"]) => {
+		switch (scope) {
+			case "project":
+				return 0;
+			case "user":
+				return 1;
+			default:
+				return 2;
+		}
+	};
+
+	const rankDiff = scopeRank(a.scope) - scopeRank(b.scope);
+	if (rankDiff !== 0) return rankDiff;
+
+	if (a.origin !== b.origin) {
+		return a.origin === "top-level" ? -1 : 1;
+	}
+
+	return a.name.localeCompare(b.name);
+}
+
+function toSkillEntry(resource: ResolvedResource): SkillEntry | null {
+	if (!resource.enabled) return null;
+
+	const parsed = parseSkillFile(resource.path);
+	if (!parsed) return null;
+
+	return {
+		name: parsed.name,
+		description: parsed.description,
+		content: parsed.content,
+		frontmatter: parsed.frontmatter,
+		path: resource.path,
+		scope: resource.metadata.scope,
+		origin: resource.metadata.origin,
+		source: resource.metadata.source,
+		baseDir: resource.metadata.baseDir,
+	};
+}
+
+export async function loadSkillRegistry(cwd: string): Promise<SkillRegistry> {
+	const settingsManager = SettingsManager.create(cwd, getAgentDir());
+	const packageManager = new DefaultPackageManager({
+		cwd,
+		agentDir: getAgentDir(),
+		settingsManager,
+	});
+	const resolved = await packageManager.resolve();
+
+	const byName = new Map<string, SkillEntry>();
+	for (const resource of resolved.skills) {
+		const entry = toSkillEntry(resource);
+		if (!entry) continue;
+		if (!byName.has(entry.name)) {
+			byName.set(entry.name, entry);
+		}
+	}
+
+	const skills = Array.from(byName.values()).sort(compareSkills);
+	return {
+		skills,
+		byName: new Map(skills.map((skill) => [skill.name, skill])),
+	};
+}

package/src/types.ts

@@ -0,0 +1,18 @@
+export type ExtensionInstallScope = "global" | "project";
+
+export interface SkillEntry {
+	name: string;
+	description: string;
+	path: string;
+	content: string;
+	frontmatter?: Record<string, unknown>;
+	scope: "user" | "project" | "temporary";
+	origin: "package" | "top-level";
+	source: string;
+	baseDir?: string;
+}
+
+export interface SkillRegistry {
+	skills: SkillEntry[];
+	byName: Map<string, SkillEntry>;
+}