@oh-my-pi/pi-coding-agent 8.1.0 → 8.2.0

package/src/extensibility/plugins/paths.ts

@@ -1,6 +1,6 @@
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { CONFIG_DIR_NAME, getConfigDirPaths } from "@oh-my-pi/pi-coding-agent/config";
+import * as os from "node:os";
+import * as path from "node:path";
+import { CONFIG_DIR_NAME, getConfigDirPaths } from "../../config";
 
 // =============================================================================
 // Plugin Directory Paths
@@ -8,27 +8,27 @@ import { CONFIG_DIR_NAME, getConfigDirPaths } from "@oh-my-pi/pi-coding-agent/co
 
 /** Root plugin directory: ~/.omp/plugins (not under agent/) */
 export function getPluginsDir(): string {
-	return join(homedir(), CONFIG_DIR_NAME, "plugins");
+	return path.join(os.homedir(), CONFIG_DIR_NAME, "plugins");
 }
 
 /** Where npm installs packages: ~/.omp/plugins/node_modules */
 export function getPluginsNodeModules(): string {
-	return join(getPluginsDir(), "node_modules");
+	return path.join(getPluginsDir(), "node_modules");
 }
 
 /** Plugin manifest: ~/.omp/plugins/package.json */
 export function getPluginsPackageJson(): string {
-	return join(getPluginsDir(), "package.json");
+	return path.join(getPluginsDir(), "package.json");
 }
 
 /** Plugin lock file: ~/.omp/plugins/omp-plugins.lock.json */
 export function getPluginsLockfile(): string {
-	return join(getPluginsDir(), "omp-plugins.lock.json");
+	return path.join(getPluginsDir(), "omp-plugins.lock.json");
 }
 
 /** Project-local plugin overrides: .omp/plugin-overrides.json (primary) */
 export function getProjectPluginOverrides(cwd: string): string {
-	return join(cwd, CONFIG_DIR_NAME, "plugin-overrides.json");
+	return path.join(cwd, CONFIG_DIR_NAME, "plugin-overrides.json");
 }
 
 /** All possible project plugin override paths (primary + legacy) */

package/src/extensibility/skills.ts

@@ -1,16 +1,12 @@
-import { readdirSync, readFileSync, statSync } from "node:fs";
-import { realpath } from "node:fs/promises";
-import { basename, join } from "node:path";
-import { skillCapability } from "@oh-my-pi/pi-coding-agent/capability/skill";
-import type { SourceMeta } from "@oh-my-pi/pi-coding-agent/capability/types";
-import type { SkillsSettings } from "@oh-my-pi/pi-coding-agent/config/settings-manager";
-import type {
-	Skill as CapabilitySkill,
-	SkillFrontmatter as ImportedSkillFrontmatter,
-} from "@oh-my-pi/pi-coding-agent/discovery";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import { logger } from "@oh-my-pi/pi-utils";
+import { skillCapability } from "../capability/skill";
+import type { SourceMeta } from "../capability/types";
+import type { SkillsSettings } from "../config/settings-manager";
+import type { Skill as CapabilitySkill, SkillFrontmatter as ImportedSkillFrontmatter } from "../discovery";
+import { loadCapability } from "../discovery";
+import { parseFrontmatter } from "../utils/frontmatter";
 
 // Re-export SkillFrontmatter for backward compatibility
 export type { ImportedSkillFrontmatter as SkillFrontmatter };
@@ -45,17 +41,16 @@ export interface LoadSkillsFromDirOptions {
 /**
  * Load skills from a directory recursively.
  * Skills are directories containing a SKILL.md file with frontmatter including a description.
- * @deprecated Use loadSync("skills") from discovery API instead
  */
-export function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkillsResult {
+export async function loadSkillsFromDir(options: LoadSkillsFromDirOptions): Promise<LoadSkillsResult> {
 	const skills: Skill[] = [];
 	const warnings: SkillWarning[] = [];
 	const seenPaths = new Set<string>();
 
-	function addSkill(skillFile: string, skillDir: string, dirName: string) {
+	async function addSkill(skillFile: string, skillDir: string, dirName: string): Promise<void> {
 		if (seenPaths.has(skillFile)) return;
 		try {
-			const content = readFileSync(skillFile, "utf-8");
+			const content = await fs.readFile(skillFile, "utf-8");
 			const { frontmatter } = parseFrontmatter(content, { source: skillFile });
 			const name = (frontmatter.name as string) || dirName;
 			const description = frontmatter.description as string;
@@ -75,26 +70,30 @@ export function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkills
 		}
 	}
 
-	function scanDir(dir: string) {
+	async function scanDir(dir: string): Promise<void> {
 		try {
-			const entries = readdirSync(dir, { withFileTypes: true });
+			// First check if this directory itself is a skill
+			const selfSkillFile = path.join(dir, "SKILL.md");
+			try {
+				const s = await fs.stat(selfSkillFile);
+				if (s.isFile()) {
+					await addSkill(selfSkillFile, dir, path.basename(dir));
+					// This directory is a skill, don't recurse
+					return;
+				}
+			} catch {
+				// No SKILL.md in this directory
+			}
+
+			// Recurse into subdirectories
+			const entries = await fs.readdir(dir, { withFileTypes: true });
+
 			for (const entry of entries) {
 				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
-				const fullPath = join(dir, entry.name);
+				const fullPath = path.join(dir, entry.name);
 				if (entry.isDirectory()) {
-					const skillFile = join(fullPath, "SKILL.md");
-					try {
-						const stat = statSync(skillFile);
-						if (stat.isFile()) {
-							addSkill(skillFile, fullPath, entry.name);
-						}
-					} catch {
-						// No SKILL.md in this directory
-					}
-					scanDir(fullPath);
-				} else if (entry.isFile() && entry.name === "SKILL.md") {
-					addSkill(fullPath, dir, basename(dir));
+					await scanDir(fullPath);
 				}
 			}
 		} catch (err) {
@@ -102,7 +101,7 @@ export function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkills
 		}
 	}
 
-	scanDir(options.dir);
+	await scanDir(options.dir);
 
 	return { skills, warnings };
 }
@@ -111,15 +110,15 @@ export function loadSkillsFromDir(options: LoadSkillsFromDirOptions): LoadSkills
  * Scan a directory for SKILL.md files recursively.
  * Used internally by loadSkills for custom directories.
  */
-function scanDirectoryForSkills(dir: string): LoadSkillsResult {
+async function scanDirectoryForSkills(dir: string): Promise<LoadSkillsResult> {
 	const skills: Skill[] = [];
 	const warnings: SkillWarning[] = [];
 	const seenPaths = new Set<string>();
 
-	function addSkill(skillFile: string, skillDir: string, dirName: string) {
+	async function addSkill(skillFile: string, skillDir: string, dirName: string): Promise<void> {
 		if (seenPaths.has(skillFile)) return;
 		try {
-			const content = readFileSync(skillFile, "utf-8");
+			const content = await fs.readFile(skillFile, "utf-8");
 			const { frontmatter } = parseFrontmatter(content, { source: skillFile });
 			const name = (frontmatter.name as string) || dirName;
 			const description = frontmatter.description as string;
@@ -139,26 +138,30 @@ function scanDirectoryForSkills(dir: string): LoadSkillsResult {
 		}
 	}
 
-	function scanDir(currentDir: string) {
+	async function scanDir(currentDir: string): Promise<void> {
 		try {
-			const entries = readdirSync(currentDir, { withFileTypes: true });
+			// First check if this directory itself is a skill
+			const selfSkillFile = path.join(currentDir, "SKILL.md");
+			try {
+				const s = await fs.stat(selfSkillFile);
+				if (s.isFile()) {
+					await addSkill(selfSkillFile, currentDir, path.basename(currentDir));
+					// This directory is a skill, don't recurse
+					return;
+				}
+			} catch {
+				// No SKILL.md in this directory
+			}
+
+			// Recurse into subdirectories
+			const entries = await fs.readdir(currentDir, { withFileTypes: true });
+
 			for (const entry of entries) {
 				if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
 
-				const fullPath = join(currentDir, entry.name);
+				const fullPath = path.join(currentDir, entry.name);
 				if (entry.isDirectory()) {
-					const skillFile = join(fullPath, "SKILL.md");
-					try {
-						const stat = statSync(skillFile);
-						if (stat.isFile()) {
-							addSkill(skillFile, fullPath, entry.name);
-						}
-					} catch {
-						// No SKILL.md in this directory
-					}
-					scanDir(fullPath);
-				} else if (entry.isFile() && entry.name === "SKILL.md") {
-					addSkill(fullPath, currentDir, basename(currentDir));
+					await scanDir(fullPath);
 				}
 			}
 		} catch (err) {
@@ -166,7 +169,7 @@ function scanDirectoryForSkills(dir: string): LoadSkillsResult {
 		}
 	}
 
-	scanDir(dir);
+	await scanDir(dir);
 
 	return { skills, warnings };
 }
@@ -221,17 +224,17 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	// Check if skill name matches any of the include patterns
 	function matchesIncludePatterns(name: string): boolean {
 		if (includeSkills.length === 0) return true;
-		return includeSkills.some((pattern) => new Bun.Glob(pattern).match(name));
+		return includeSkills.some(pattern => new Bun.Glob(pattern).match(name));
 	}
 
 	// Check if skill name matches any of the ignore patterns
 	function matchesIgnorePatterns(name: string): boolean {
 		if (ignoredSkills.length === 0) return false;
-		return ignoredSkills.some((pattern) => new Bun.Glob(pattern).match(name));
+		return ignoredSkills.some(pattern => new Bun.Glob(pattern).match(name));
 	}
 
 	// Filter skills by source and patterns first
-	const filteredSkills = result.items.filter((capSkill) => {
+	const filteredSkills = result.items.filter(capSkill => {
 		if (!isSourceEnabled(capSkill._source)) return false;
 		if (matchesIgnorePatterns(capSkill.name)) return false;
 		if (!matchesIncludePatterns(capSkill.name)) return false;
@@ -240,9 +243,9 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 
 	// Batch resolve all real paths in parallel
 	const realPaths = await Promise.all(
-		filteredSkills.map(async (capSkill) => {
+		filteredSkills.map(async capSkill => {
 			try {
-				return await realpath(capSkill.path);
+				return await fs.realpath(capSkill.path);
 			} catch {
 				return capSkill.path;
 			}
@@ -282,8 +285,8 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 
 	// Process custom directories - scan directly without using full provider system
 	const allCustomSkills: Array<{ skill: Skill; path: string }> = [];
-	for (const dir of customDirectories) {
-		const customSkills = scanDirectoryForSkills(dir);
+	const customScanResults = await Promise.all(customDirectories.map(dir => scanDirectoryForSkills(dir)));
+	for (const customSkills of customScanResults) {
 		for (const s of customSkills.skills) {
 			if (matchesIgnorePatterns(s.name)) continue;
 			if (!matchesIncludePatterns(s.name)) continue;
@@ -306,7 +309,7 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 	const customRealPaths = await Promise.all(
 		allCustomSkills.map(async ({ path }) => {
 			try {
-				return await realpath(path);
+				return await fs.realpath(path);
 			} catch {
 				return path;
 			}
@@ -332,6 +335,6 @@ export async function loadSkills(options: LoadSkillsOptions = {}): Promise<LoadS
 
 	return {
 		skills: Array.from(skillMap.values()),
-		warnings: [...result.warnings.map((w) => ({ skillPath: "", message: w })), ...collisionWarnings],
+		warnings: [...result.warnings.map(w => ({ skillPath: "", message: w })), ...collisionWarnings],
 	};
 }

package/src/extensibility/slash-commands.ts

@@ -1,9 +1,9 @@
-import { slashCommandCapability } from "@oh-my-pi/pi-coding-agent/capability/slash-command";
-import { renderPromptTemplate } from "@oh-my-pi/pi-coding-agent/config/prompt-templates";
-import type { SlashCommand } from "@oh-my-pi/pi-coding-agent/discovery";
-import { loadCapability } from "@oh-my-pi/pi-coding-agent/discovery";
-import { EMBEDDED_COMMAND_TEMPLATES } from "@oh-my-pi/pi-coding-agent/task/commands";
-import { parseFrontmatter } from "@oh-my-pi/pi-coding-agent/utils/frontmatter";
+import { slashCommandCapability } from "../capability/slash-command";
+import { renderPromptTemplate } from "../config/prompt-templates";
+import type { SlashCommand } from "../discovery";
+import { loadCapability } from "../discovery";
+import { EMBEDDED_COMMAND_TEMPLATES } from "../task/commands";
+import { parseFrontmatter } from "../utils/frontmatter";
 
 /**
  * Represents a custom slash command loaded from a file
@@ -29,7 +29,7 @@ function parseCommandTemplate(
 	// Get description from frontmatter or first non-empty line
 	let description = frontmatterDesc;
 	if (!description) {
-		const firstLine = body.split("\n").find((line) => line.trim());
+		const firstLine = body.split("\n").find(line => line.trim());
 		if (firstLine) {
 			description = firstLine.slice(0, 60);
 			if (firstLine.length > 60) description += "...";
@@ -114,7 +114,7 @@ export interface LoadSlashCommandsOptions {
 export async function loadSlashCommands(options: LoadSlashCommandsOptions = {}): Promise<FileSlashCommand[]> {
 	const result = await loadCapability<SlashCommand>(slashCommandCapability.id, { cwd: options.cwd });
 
-	const fileCommands: FileSlashCommand[] = result.items.map((cmd) => {
+	const fileCommands: FileSlashCommand[] = result.items.map(cmd => {
 		const { description, body } = parseCommandTemplate(cmd.content, {
 			source: cmd.path ?? `slash-command:${cmd.name}`,
 			level: cmd.level === "native" ? "fatal" : "warn",
@@ -133,7 +133,7 @@ export async function loadSlashCommands(options: LoadSlashCommandsOptions = {}):
 		};
 	});
 
-	const seenNames = new Set(fileCommands.map((cmd) => cmd.name));
+	const seenNames = new Set(fileCommands.map(cmd => cmd.name));
 	for (const cmd of EMBEDDED_SLASH_COMMANDS) {
 		const name = cmd.name.replace(/\.md$/, "");
 		if (seenNames.has(name)) continue;
@@ -165,7 +165,7 @@ export function expandSlashCommand(text: string, fileCommands: FileSlashCommand[
 	const commandName = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
 	const argsString = spaceIndex === -1 ? "" : text.slice(spaceIndex + 1);
 
-	const fileCommand = fileCommands.find((cmd) => cmd.name === commandName);
+	const fileCommand = fileCommands.find(cmd => cmd.name === commandName);
 	if (fileCommand) {
 		const args = parseCommandArgs(argsString);
 		const argsText = args.join(" ");

package/src/index.ts

@@ -3,52 +3,6 @@
 // TypeBox helper for string enums (convenience for custom tools)
 // Re-export from pi-ai which uses the correct enum-based schema format
 export { StringEnum } from "@oh-my-pi/pi-ai";
-export type { FileDiagnosticsResult } from "@oh-my-pi/pi-coding-agent/lsp";
-// UI components for extensions
-export {
-	ArminComponent,
-	AssistantMessageComponent,
-	BashExecutionComponent,
-	BorderedLoader,
-	BranchSummaryMessageComponent,
-	CompactionSummaryMessageComponent,
-	CustomEditor,
-	CustomMessageComponent,
-	DynamicBorder,
-	FooterComponent,
-	HookEditorComponent as ExtensionEditorComponent,
-	HookInputComponent as ExtensionInputComponent,
-	HookSelectorComponent as ExtensionSelectorComponent,
-	LoginDialogComponent,
-	ModelSelectorComponent,
-	OAuthSelectorComponent,
-	type RenderDiffOptions,
-	renderDiff,
-	SessionSelectorComponent,
-	type SettingsCallbacks,
-	SettingsSelectorComponent,
-	ShowImagesSelectorComponent,
-	ThemeSelectorComponent,
-	ThinkingSelectorComponent,
-	ToolExecutionComponent,
-	type ToolExecutionOptions,
-	TreeSelectorComponent,
-	truncateToVisualLines,
-	UserMessageComponent,
-	UserMessageSelectorComponent,
-	type VisualTruncateResult,
-} from "@oh-my-pi/pi-coding-agent/modes/components";
-// Theme utilities for custom tools
-export {
-	getLanguageFromPath,
-	getMarkdownTheme,
-	getSelectListTheme,
-	getSettingsListTheme,
-	highlightCode,
-	initTheme,
-	Theme,
-	type ThemeColor,
-} from "@oh-my-pi/pi-coding-agent/modes/theme/theme";
 // Re-export TUI components for custom tool rendering
 export { Container, Markdown, Spacer, Text } from "@oh-my-pi/pi-tui";
 // Logging
@@ -150,6 +104,7 @@ export {
 } from "./extensibility/skills";
 // Slash commands
 export { type FileSlashCommand, loadSlashCommands as discoverSlashCommands } from "./extensibility/slash-commands";
+export type { FileDiagnosticsResult } from "./lsp";
 // Main entry point
 export { main } from "./main";
 // Run modes for programmatic SDK usage
@@ -163,6 +118,51 @@ export {
 	runPrintMode,
 	runRpcMode,
 } from "./modes";
+// UI components for extensions
+export {
+	ArminComponent,
+	AssistantMessageComponent,
+	BashExecutionComponent,
+	BorderedLoader,
+	BranchSummaryMessageComponent,
+	CompactionSummaryMessageComponent,
+	CustomEditor,
+	CustomMessageComponent,
+	DynamicBorder,
+	FooterComponent,
+	HookEditorComponent as ExtensionEditorComponent,
+	HookInputComponent as ExtensionInputComponent,
+	HookSelectorComponent as ExtensionSelectorComponent,
+	LoginDialogComponent,
+	ModelSelectorComponent,
+	OAuthSelectorComponent,
+	type RenderDiffOptions,
+	renderDiff,
+	SessionSelectorComponent,
+	type SettingsCallbacks,
+	SettingsSelectorComponent,
+	ShowImagesSelectorComponent,
+	ThemeSelectorComponent,
+	ThinkingSelectorComponent,
+	ToolExecutionComponent,
+	type ToolExecutionOptions,
+	TreeSelectorComponent,
+	truncateToVisualLines,
+	UserMessageComponent,
+	UserMessageSelectorComponent,
+	type VisualTruncateResult,
+} from "./modes/components";
+// Theme utilities for custom tools
+export {
+	getLanguageFromPath,
+	getMarkdownTheme,
+	getSelectListTheme,
+	getSettingsListTheme,
+	highlightCode,
+	initTheme,
+	Theme,
+	type ThemeColor,
+} from "./modes/theme/theme";
 // SDK for programmatic usage
 export {
 	// Factory

package/src/internal-urls/agent-protocol.ts

@@ -8,9 +8,9 @@
  * - agent://<id>/<path> - JSON extraction via path form
  * - agent://<id>?q=<query> - JSON extraction via query form
  */
-
-import * as fs from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import { applyQuery, pathToQuery } from "./json-query";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
@@ -25,10 +25,10 @@ export interface AgentProtocolOptions {
 /**
  * List available output IDs in artifacts directory.
  */
-function listAvailableOutputs(artifactsDir: string): string[] {
+async function listAvailableOutputs(artifactsDir: string): Promise<string[]> {
 	try {
-		const files = fs.readdirSync(artifactsDir);
-		return files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
+		const files = await fs.readdir(artifactsDir);
+		return files.filter(f => f.endsWith(".md")).map(f => f.replace(".md", ""));
 	} catch {
 		return [];
 	}
@@ -51,8 +51,13 @@ export class AgentProtocolHandler implements ProtocolHandler {
 			throw new Error("No session - agent outputs unavailable");
 		}
 
-		if (!fs.existsSync(artifactsDir)) {
-			throw new Error("No artifacts directory found");
+		try {
+			await fs.stat(artifactsDir);
+		} catch (err) {
+			if (isEnoent(err)) {
+				throw new Error("No artifacts directory found");
+			}
+			throw err;
 		}
 
 		// Extract output ID from host
@@ -73,10 +78,15 @@ export class AgentProtocolHandler implements ProtocolHandler {
 
 		// Load the output file
 		const outputPath = path.join(artifactsDir, `${outputId}.md`);
-		if (!fs.existsSync(outputPath)) {
-			const available = listAvailableOutputs(artifactsDir);
-			const availableStr = available.length > 0 ? available.join(", ") : "none";
-			throw new Error(`Not found: ${outputId}\nAvailable: ${availableStr}`);
+		try {
+			await fs.stat(outputPath);
+		} catch (err) {
+			if (isEnoent(err)) {
+				const available = await listAvailableOutputs(artifactsDir);
+				const availableStr = available.length > 0 ? available.join(", ") : "none";
+				throw new Error(`Not found: ${outputId}\nAvailable: ${availableStr}`);
+			}
+			throw err;
 		}
 
 		const rawContent = await Bun.file(outputPath).text();

package/src/internal-urls/artifact-protocol.ts

@@ -9,9 +9,9 @@
  *
  * Pagination is handled by the read tool via offset/limit parameters.
  */
-
-import * as fs from "node:fs";
+import * as fs from "node:fs/promises";
 import * as path from "node:path";
+import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
 export interface ArtifactProtocolOptions {
@@ -24,12 +24,12 @@ export interface ArtifactProtocolOptions {
 /**
  * List available artifact IDs in the directory.
  */
-function listAvailableArtifacts(artifactsDir: string): string[] {
+async function listAvailableArtifacts(artifactsDir: string): Promise<string[]> {
 	try {
-		const files = fs.readdirSync(artifactsDir);
+		const files = await fs.readdir(artifactsDir);
 		return files
-			.filter((f) => /^\d+\./.test(f))
-			.map((f) => f.split(".")[0])
+			.filter(f => /^\d+\./.test(f))
+			.map(f => f.split(".")[0])
 			.sort((a, b) => Number(a) - Number(b));
 	} catch {
 		return [];
@@ -64,17 +64,21 @@ export class ArtifactProtocolHandler implements ProtocolHandler {
 			throw new Error(`artifact:// ID must be numeric, got: ${id}`);
 		}
 
-		// Check directory exists
-		if (!fs.existsSync(artifactsDir)) {
-			throw new Error("No artifacts directory found");
+		// Check directory exists and find file matching ID prefix
+		let files: string[];
+		try {
+			files = await fs.readdir(artifactsDir);
+		} catch (err) {
+			if (isEnoent(err)) {
+				throw new Error("No artifacts directory found");
+			}
+			throw err;
 		}
 
-		// Find file matching ID prefix
-		const files = fs.readdirSync(artifactsDir);
-		const match = files.find((f) => f.startsWith(`${id}.`));
+		const match = files.find(f => f.startsWith(`${id}.`));
 
 		if (!match) {
-			const available = listAvailableArtifacts(artifactsDir);
+			const available = await listAvailableArtifacts(artifactsDir);
 			const availableStr = available.length > 0 ? available.join(", ") : "none";
 			throw new Error(`Artifact ${id} not found. Available: ${availableStr}`);
 		}

package/src/internal-urls/router.ts

@@ -1,7 +1,6 @@
 /**
  * Internal URL router for resolving agent:// and skill:// URLs.
  */
-
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
 /**
@@ -59,7 +58,7 @@ export class InternalUrlRouter {
 
 		if (!handler) {
 			const available = Array.from(this.handlers.keys())
-				.map((s) => `${s}://`)
+				.map(s => `${s}://`)
 				.join(", ");
 			throw new Error(`Unknown protocol: ${scheme}://\nSupported: ${available || "none"}`);
 		}

package/src/internal-urls/rule-protocol.ts

@@ -6,8 +6,7 @@
  * URL forms:
  * - rule://<name> - Reads rule content
  */
-
-import type { Rule } from "@oh-my-pi/pi-coding-agent/capability/rule";
+import type { Rule } from "../capability/rule";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
 export interface RuleProtocolOptions {
@@ -37,9 +36,9 @@ export class RuleProtocolHandler implements ProtocolHandler {
 		}
 
 		// Find the rule
-		const rule = rules.find((r) => r.name === ruleName);
+		const rule = rules.find(r => r.name === ruleName);
 		if (!rule) {
-			const available = rules.map((r) => r.name);
+			const available = rules.map(r => r.name);
 			const availableStr = available.length > 0 ? available.join(", ") : "none";
 			throw new Error(`Unknown rule: ${ruleName}\nAvailable: ${availableStr}`);
 		}

package/src/internal-urls/skill-protocol.ts

@@ -7,9 +7,8 @@
  * - skill://<name> - Reads SKILL.md
  * - skill://<name>/<path> - Reads relative path within skill's baseDir
  */
-
 import * as path from "node:path";
-import type { Skill } from "@oh-my-pi/pi-coding-agent/extensibility/skills";
+import type { Skill } from "../extensibility/skills";
 import type { InternalResource, InternalUrl, ProtocolHandler } from "./types";
 
 export interface SkillProtocolOptions {
@@ -62,9 +61,9 @@ export class SkillProtocolHandler implements ProtocolHandler {
 		}
 
 		// Find the skill
-		const skill = skills.find((s) => s.name === skillName);
+		const skill = skills.find(s => s.name === skillName);
 		if (!skill) {
-			const available = skills.map((s) => s.name);
+			const available = skills.map(s => s.name);
 			const availableStr = available.length > 0 ? available.join(", ") : "none";
 			throw new Error(`Unknown skill: ${skillName}\nAvailable: ${availableStr}`);
 		}