@zaganjade/pi-multi-skill 1.0.0 → 1.3.1

package/src/completions.ts

@@ -0,0 +1,184 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { AutocompleteItem } from "@earendil-works/pi-tui";
+import {
+	assessBundleAvailability,
+	formatBundleCoverage,
+} from "./bundle-status.ts";
+import { expandSkillNames } from "./bundles.ts";
+import { enrichSkill } from "./metadata.ts";
+import type { SkillBundle, SkillInfo } from "./types.ts";
+
+function resolveSkillNamesForCompletion(
+	skillPart: string,
+	bundles: Map<string, SkillBundle>,
+): string[] {
+	const raw = skillPart
+		.split(",")
+		.map((s) => s.trim())
+		.filter((s) => s.length > 0);
+	if (raw.length === 0) return [];
+	return expandSkillNames(raw, bundles).skills;
+}
+
+function collectEmbeddedCommands(
+	skillNames: string[],
+	allSkills: SkillInfo[],
+): Map<string, string> {
+	const byName = new Map(allSkills.map((s) => [s.name, s]));
+	const commands = new Map<string, string>();
+
+	for (const name of skillNames) {
+		const skill = byName.get(name);
+		if (!skill) continue;
+		const enriched = enrichSkill(skill);
+		for (const cmd of enriched.metadata.commands) {
+			if (!commands.has(cmd)) {
+				commands.set(cmd, enriched.name);
+			}
+		}
+	}
+
+	return commands;
+}
+
+function completeSkillNames(
+	prefix: string,
+	allSkills: SkillInfo[],
+	bundles: Map<string, SkillBundle>,
+): AutocompleteItem[] {
+	const parts = prefix.split(",");
+	const currentPart = parts[parts.length - 1].trim();
+	const alreadySelected = parts
+		.slice(0, -1)
+		.map((s) => s.trim())
+		.filter((s) => s.length > 0);
+
+	const items: AutocompleteItem[] = [];
+
+	if (currentPart.startsWith("@") || currentPart === "") {
+		const bundleQuery = currentPart.startsWith("@")
+			? currentPart.slice(1)
+			: "";
+		for (const [name, bundle] of bundles) {
+			if (bundleQuery && !name.startsWith(bundleQuery)) continue;
+			if (alreadySelected.includes(`@${name}`)) continue;
+			const status = assessBundleAvailability(name, bundle, allSkills);
+			const prefixValue =
+				alreadySelected.length > 0
+					? `${parts.slice(0, -1).join(",")},@${name}`
+					: `@${name}`;
+			const coverage = formatBundleCoverage(status);
+			const req =
+				status.coverage === 0 && bundle.requires
+					? ` · needs ${bundle.requires}`
+					: "";
+			items.push({
+				value: prefixValue,
+				label: `@${name}`,
+				description: `${bundle.description} (${coverage})${req}`,
+			});
+		}
+	}
+
+	const remaining = allSkills.filter(
+		(s) => !alreadySelected.includes(s.name),
+	);
+	let candidates: SkillInfo[] = [];
+	if (currentPart && !currentPart.startsWith("@")) {
+		candidates = remaining.filter((s) => s.name.startsWith(currentPart));
+	} else if (!currentPart.startsWith("@")) {
+		candidates = remaining;
+	}
+
+	const needsComma = alreadySelected.length > 0;
+	for (const s of candidates) {
+		items.push({
+			value: needsComma
+				? `${parts.slice(0, -1).join(",")},${s.name}`
+				: s.name,
+			label: alreadySelected.length > 0 ? `  ${s.name}` : s.name,
+			description: s.description || undefined,
+		});
+	}
+
+	return items.sort((a, b) => {
+		const aReady = a.description?.includes("0/") ? 1 : 0;
+		const bReady = b.description?.includes("0/") ? 1 : 0;
+		if (aReady !== bReady) return aReady - bReady;
+		return a.label.localeCompare(b.label);
+	});
+}
+
+function completeEmbeddedCommands(
+	skillPart: string,
+	commandPrefix: string,
+	allSkills: SkillInfo[],
+	bundles: Map<string, SkillBundle>,
+	pi: ExtensionAPI,
+): AutocompleteItem[] {
+	const skillNames = resolveSkillNamesForCompletion(skillPart, bundles);
+	const fromSkills = collectEmbeddedCommands(skillNames, allSkills);
+	const query = commandPrefix.trim();
+	const normalizedQuery = query.startsWith("/") ? query : `/${query}`;
+
+	const items: AutocompleteItem[] = [];
+	const seen = new Set<string>();
+
+	for (const [cmd, sourceSkill] of fromSkills) {
+		if (normalizedQuery && !cmd.startsWith(normalizedQuery)) continue;
+		if (seen.has(cmd)) continue;
+		seen.add(cmd);
+		items.push({
+			value: `${skillPart} ${cmd}`,
+			label: cmd,
+			description: `from ${sourceSkill}`,
+		});
+	}
+
+	for (const cmd of pi.getCommands()) {
+		const slashName = cmd.name.startsWith("skill:")
+			? null
+			: `/${cmd.name}`;
+		if (!slashName) continue;
+		if (normalizedQuery && !slashName.startsWith(normalizedQuery)) continue;
+		if (seen.has(slashName)) continue;
+		seen.add(slashName);
+		items.push({
+			value: `${skillPart} ${slashName}`,
+			label: slashName,
+			description: cmd.description || cmd.source,
+		});
+	}
+
+	return items.sort((a, b) => a.label.localeCompare(b.label));
+}
+
+export function getSkillsArgumentCompletions(
+	prefix: string,
+	allSkills: SkillInfo[],
+	bundles: Map<string, SkillBundle>,
+	pi: ExtensionAPI,
+): AutocompleteItem[] | null {
+	const spaceIndex = prefix.indexOf(" ");
+	if (spaceIndex === -1) {
+		const items = completeSkillNames(prefix, allSkills, bundles);
+		return items.length > 0 ? items : null;
+	}
+
+	const skillPart = prefix.slice(0, spaceIndex);
+	const rest = prefix.slice(spaceIndex + 1);
+
+	// Embedded command phase: "/skills skill /command args"
+	if (rest.startsWith("/") || rest.length === 0) {
+		const items = completeEmbeddedCommands(
+			skillPart,
+			rest,
+			allSkills,
+			bundles,
+			pi,
+		);
+		return items.length > 0 ? items : null;
+	}
+
+	return null;
+}

package/src/conflicts.ts

@@ -0,0 +1,26 @@
+import type { EnrichedSkillInfo } from "./types.ts";
+
+/** Drop lower-priority skills that conflict with an earlier skill in the sorted list. */
+export function resolveSkillConflicts(
+	skills: EnrichedSkillInfo[],
+): { skills: EnrichedSkillInfo[]; warnings: string[] } {
+	const kept: EnrichedSkillInfo[] = [];
+	const warnings: string[] = [];
+	const keptNames = new Set<string>();
+
+	for (const skill of skills) {
+		const conflictsWithKept = skill.metadata.conflictsWith.filter((name) =>
+			keptNames.has(name),
+		);
+		if (conflictsWithKept.length > 0) {
+			warnings.push(
+				`Skipped ${skill.name} (conflicts with ${conflictsWithKept.join(", ")})`,
+			);
+			continue;
+		}
+		kept.push(skill);
+		keptNames.add(skill.name);
+	}
+
+	return { skills: kept, warnings };
+}

package/src/discover.ts

@@ -0,0 +1,161 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import {
+	getAgentDir,
+	loadSkills,
+	loadSkillsFromDir,
+	type ExtensionAPI,
+} from "@earendil-works/pi-coding-agent";
+import { truncateDescription } from "./metadata.ts";
+import type { SkillInfo } from "./types.ts";
+
+function readSettingsSkillPaths(): string[] {
+	try {
+		const raw = readFileSync(join(getAgentDir(), "settings.json"), "utf-8");
+		const parsed = JSON.parse(raw) as { skills?: string[] };
+		return Array.isArray(parsed.skills) ? parsed.skills : [];
+	} catch {
+		return [];
+	}
+}
+
+function fromPiCommands(pi: ExtensionAPI): Map<string, SkillInfo> {
+	const map = new Map<string, SkillInfo>();
+	for (const cmd of pi.getCommands()) {
+		if (cmd.source !== "skill") continue;
+		const name = cmd.name.startsWith("skill:")
+			? cmd.name.slice(6)
+			: cmd.name;
+		map.set(name, {
+			name,
+			description: truncateDescription(cmd.description || ""),
+			filePath: cmd.sourceInfo.path,
+			baseDir: cmd.sourceInfo.baseDir || dirname(cmd.sourceInfo.path),
+		});
+	}
+	return map;
+}
+
+/** Claude Code plugin cache — superpowers and other plugin skills not in pi settings. */
+function discoverClaudePluginSkills(): SkillInfo[] {
+	const cacheRoot = join(homedir(), ".claude", "plugins", "cache");
+	if (!existsSync(cacheRoot)) return [];
+
+	const byName = new Map<string, SkillInfo>();
+	try {
+		for (const pluginEntry of readdirSync(cacheRoot, { withFileTypes: true })) {
+			if (!pluginEntry.isDirectory()) continue;
+			const pluginRoot = join(cacheRoot, pluginEntry.name);
+			for (const versionEntry of readdirSync(pluginRoot, {
+				withFileTypes: true,
+			})) {
+				if (!versionEntry.isDirectory()) continue;
+				const skillsDir = join(pluginRoot, versionEntry.name, "skills");
+				if (!existsSync(skillsDir)) continue;
+				const result = loadSkillsFromDir({
+					dir: skillsDir,
+					source: "claude-plugin",
+				});
+				for (const skill of result.skills) {
+					byName.set(skill.name, {
+						name: skill.name,
+						description: truncateDescription(skill.description || ""),
+						filePath: skill.filePath,
+						baseDir: skill.baseDir,
+					});
+				}
+			}
+		}
+	} catch {
+		// Non-fatal
+	}
+	return [...byName.values()];
+}
+
+function discoverCursorSkills(): SkillInfo[] {
+	const dir = join(homedir(), ".cursor", "skills-cursor");
+	if (!existsSync(dir)) return [];
+	try {
+		return loadSkillsFromDir({ dir, source: "cursor" }).skills.map((skill) => ({
+			name: skill.name,
+			description: truncateDescription(skill.description || ""),
+			filePath: skill.filePath,
+			baseDir: skill.baseDir,
+		}));
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Discover skills from every source pi and Claude Code use:
+ * getCommands(), settings skill paths, defaults, plugin cache, cursor skills.
+ */
+export function discoverAllSkills(
+	pi: ExtensionAPI,
+	cwd: string,
+): SkillInfo[] {
+	const map = fromPiCommands(pi);
+
+	const loaded = loadSkills({
+		cwd,
+		agentDir: getAgentDir(),
+		skillPaths: readSettingsSkillPaths(),
+		includeDefaults: true,
+	});
+	for (const skill of loaded.skills) {
+		if (!map.has(skill.name)) {
+			map.set(skill.name, {
+				name: skill.name,
+				description: truncateDescription(skill.description || ""),
+				filePath: skill.filePath,
+				baseDir: skill.baseDir,
+			});
+		}
+	}
+
+	for (const skill of [
+		...discoverClaudePluginSkills(),
+		...discoverCursorSkills(),
+	]) {
+		if (!map.has(skill.name)) map.set(skill.name, skill);
+	}
+
+	return [...map.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/** Resolve a skill by name when it was requested but missing from the primary index. */
+export function resolveSkillByName(
+	name: string,
+	known: Map<string, SkillInfo>,
+): SkillInfo | undefined {
+	if (known.has(name)) return known.get(name);
+
+	for (const skill of discoverClaudePluginSkills()) {
+		if (skill.name === name) return skill;
+	}
+	for (const skill of discoverCursorSkills()) {
+		if (skill.name === name) return skill;
+	}
+
+	const dirs = [
+		join(getAgentDir(), "skills"),
+		join(cwd, ".pi", "skills"),
+	];
+	for (const dir of dirs) {
+		for (const candidate of [
+			join(dir, name, "SKILL.md"),
+			join(dir, `${name}.md`),
+		]) {
+			if (!existsSync(candidate)) continue;
+			return {
+				name,
+				description: "",
+				filePath: candidate,
+				baseDir: dirname(candidate),
+			};
+		}
+	}
+	return undefined;
+}