@oh-my-pi/pi-coding-agent 16.0.0 → 16.0.2

package/src/extensibility/plugins/loader.ts

@@ -9,6 +9,7 @@ import * as path from "node:path";
 import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, isEnoent } from "@oh-my-pi/pi-utils";
 import { getConfigDirPaths } from "../../config";
 import { installLegacyPiSpecifierShim } from "./legacy-pi-compat";
+import { normalizePluginRuntimeConfig } from "./runtime-config";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
 installLegacyPiSpecifierShim();
@@ -28,9 +29,9 @@ installLegacyPiSpecifierShim();
 async function loadRuntimeConfig(home?: string): Promise<PluginRuntimeConfig> {
 	const lockPath = getPluginsLockfile(home);
 	try {
-		return await Bun.file(lockPath).json();
+		return normalizePluginRuntimeConfig(await Bun.file(lockPath).json());
 	} catch (err) {
-		if (isEnoent(err)) return { plugins: {}, settings: {} };
+		if (isEnoent(err)) return normalizePluginRuntimeConfig({});
 		throw err;
 	}
 }
@@ -142,29 +143,161 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 // Path Resolution
 // =============================================================================
 
-const MANIFEST_ENTRY_INDEX_NAMES = ["index.ts", "index.js", "index.mjs", "index.cjs"];
+const MANIFEST_ENTRY_MODULE_EXTENSIONS = [".ts", ".js", ".mjs", ".cjs"];
+const MANIFEST_ENTRY_INDEX_NAMES = MANIFEST_ENTRY_MODULE_EXTENSIONS.map(ext => `index${ext}`);
+
+/** `.d.ts` / `.d.mts` / `.d.cts` TypeScript declaration files — never loadable as modules. */
+const DECLARATION_FILE_RE = /\.d\.[mc]?ts$/;
+
+/** A loadable module file: a .ts/.js/.mjs/.cjs that is not a declaration file. */
+function isModuleFile(name: string): boolean {
+	return MANIFEST_ENTRY_MODULE_EXTENSIONS.includes(path.extname(name)) && !DECLARATION_FILE_RE.test(name);
+}
+
+/** First `index.{ts,js,mjs,cjs}` inside `dir`, or null when none exists. */
+function findDirectoryIndex(dir: string): string | null {
+	for (const name of MANIFEST_ENTRY_INDEX_NAMES) {
+		const candidate = path.join(dir, name);
+		if (fs.existsSync(candidate)) return candidate;
+	}
+	return null;
+}
+
+interface DeclaredManifestEntries {
+	/** True when the directory's package.json declares a non-empty `omp`/`pi` `extensions` array. */
+	declared: boolean;
+	/** Resolved, existing module files for the declared entries (may be empty when declared files are missing). */
+	files: string[];
+}
+
+/**
+ * Read the extension entries declared by `dir`'s own package.json `omp`/`pi`
+ * manifest. `declared` distinguishes "a manifest explicitly lists extensions"
+ * (authoritative — callers must not fall back to index/scan, so a missing
+ * declared file surfaces as a missing entry instead of silently loading a stale
+ * index) from "no manifest / no extensions field" (callers fall back to
+ * convention). Mirrors the manifest branch of the configured-directory (`-e`)
+ * scanner: a declared entry that is a file resolves to itself; one that is a
+ * directory resolves to its direct index.{ts,js,mjs,cjs}.
+ */
+function readDeclaredManifestEntries(dir: string): DeclaredManifestEntries {
+	let raw: string;
+	try {
+		raw = fs.readFileSync(path.join(dir, "package.json"), "utf8");
+	} catch {
+		return { declared: false, files: [] };
+	}
+	let pkg: { omp?: { extensions?: unknown }; pi?: { extensions?: unknown } };
+	try {
+		pkg = JSON.parse(raw) as { omp?: { extensions?: unknown }; pi?: { extensions?: unknown } };
+	} catch {
+		return { declared: false, files: [] };
+	}
+	const declared = (pkg.omp ?? pkg.pi)?.extensions;
+	if (!Array.isArray(declared) || declared.length === 0) {
+		return { declared: false, files: [] };
+	}
+	const files: string[] = [];
+	for (const entry of declared) {
+		if (typeof entry !== "string") continue;
+		const candidate = path.resolve(dir, entry);
+		let candidateStats: fs.Stats;
+		try {
+			candidateStats = fs.statSync(candidate);
+		} catch {
+			continue;
+		}
+		if (candidateStats.isDirectory()) {
+			const index = findDirectoryIndex(candidate);
+			if (index) files.push(index);
+		} else {
+			files.push(candidate);
+		}
+	}
+	return { declared: true, files };
+}
 
 /**
- * Resolve a plugin manifest entry to a concrete loadable file path. Returns the
- * file path itself when the entry points at a file, the matching index file when
- * the entry points at a directory containing index.{ts,js,mjs,cjs}, and null
- * when no entry exists at the joined path.
+ * Resolve a directory to its loadable extension module files, mirroring the
+ * configured-directory (`-e`) scanner in extensions/loader.ts:
+ *   1. the directory's own package.json `omp`/`pi` `extensions` entries —
+ *      authoritative: a manifest that lists extensions suppresses the index/scan
+ *      fallback, so a missing declared file is reported rather than silently
+ *      replaced by a decoy index
+ *   2. a direct index.{ts,js,mjs,cjs}
+ *   3. one level of children: each direct *.{ts,js,mjs,cjs} file plus each
+ *      sub-directory resolved by the same precedence (manifest, then index)
  */
-function resolveManifestEntryFile(joined: string): string | null {
+function resolveDirectoryEntries(dir: string): string[] {
+	const manifest = readDeclaredManifestEntries(dir);
+	if (manifest.declared) return manifest.files;
+
+	const directIndex = findDirectoryIndex(dir);
+	if (directIndex) return [directIndex];
+
+	let children: string[];
+	try {
+		children = fs.readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const resolved: string[] = [];
+	for (const child of children.sort()) {
+		const childPath = path.join(dir, child);
+		let childStats: fs.Stats;
+		try {
+			// statSync follows symlinks, matching the configured-dir loader.
+			childStats = fs.statSync(childPath);
+		} catch {
+			continue;
+		}
+		if (childStats.isDirectory()) {
+			const childManifest = readDeclaredManifestEntries(childPath);
+			if (childManifest.declared) {
+				resolved.push(...childManifest.files);
+			} else {
+				const index = findDirectoryIndex(childPath);
+				if (index) resolved.push(index);
+			}
+		} else if (isModuleFile(child)) {
+			resolved.push(childPath);
+		}
+	}
+	return resolved;
+}
+
+/**
+ * Resolve a plugin manifest entry to the loadable module files it names:
+ * - a file entry → that file
+ * - a directory:
+ *   - when `expandDirectory` (the `extensions` key), resolved by
+ *     {@link resolveDirectoryEntries} — its own package.json `omp`/`pi`
+ *     `extensions`, then a direct index, then a one-level scan of
+ *     sub-extensions — matching the pi `extensions/<name>/index.ts` convention
+ *     and OMP's configured-directory (`-e`) extension loader
+ *   - otherwise (tools/hooks/commands) only a direct index.{ts,js,mjs,cjs}.
+ *     The sub-extension scan and the `omp`/`pi` `extensions` manifest are
+ *     extensions-specific and must not hijack a non-extension directory entry
+ *     (e.g. a `tools: "."` entry must still resolve `./index.ts`).
+ *
+ * Returns an empty array when nothing loadable exists at `joined`, letting
+ * callers flag a missing entry instead of silently dropping it.
+ */
+function resolveManifestEntryFiles(joined: string, expandDirectory: boolean): string[] {
 	let stats: fs.Stats;
 	try {
 		stats = fs.statSync(joined);
 	} catch {
-		return null;
+		return [];
 	}
-	if (stats.isDirectory()) {
-		for (const name of MANIFEST_ENTRY_INDEX_NAMES) {
-			const candidate = path.join(joined, name);
-			if (fs.existsSync(candidate)) return candidate;
-		}
-		return null;
+	if (!stats.isDirectory()) {
+		return [joined];
+	}
+	if (expandDirectory) {
+		return resolveDirectoryEntries(joined);
 	}
-	return joined;
+	const index = findDirectoryIndex(joined);
+	return index ? [index] : [];
 }
 
 /**
@@ -195,16 +328,17 @@ export function resolvePluginManifestEntries(
 	const declared: Array<{ entry: string; resolvedPath: string | null }> = [];
 	const manifest = plugin.manifest;
 
-	const resolveEntry = (entry: string): { entry: string; resolvedPath: string | null } => ({
-		entry,
-		resolvedPath: resolveManifestEntryFile(path.join(plugin.path, entry)),
-	});
+	const expandDirectory = key === "extensions";
+	const resolveEntry = (entry: string): Array<{ entry: string; resolvedPath: string | null }> => {
+		const files = resolveManifestEntryFiles(path.join(plugin.path, entry), expandDirectory);
+		return files.length > 0 ? files.map(resolvedPath => ({ entry, resolvedPath })) : [{ entry, resolvedPath: null }];
+	};
 
 	const base = manifest[key];
 	if (base) {
 		const entries = Array.isArray(base) ? base : [base];
 		for (const entry of entries) {
-			declared.push(resolveEntry(entry));
+			declared.push(...resolveEntry(entry));
 		}
 	}
 
@@ -214,7 +348,7 @@ export function resolvePluginManifestEntries(
 			if (!enabledSet.has(featName)) continue;
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					declared.push(resolveEntry(entry));
+					declared.push(...resolveEntry(entry));
 				}
 			}
 		}
@@ -224,7 +358,7 @@ export function resolvePluginManifestEntries(
 			if (!feat.default) continue;
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					declared.push(resolveEntry(entry));
+					declared.push(...resolveEntry(entry));
 				}
 			}
 		}

package/src/extensibility/plugins/manager.ts

@@ -15,6 +15,7 @@ import { type GitSource, parseGitUrl } from "./git-url";
 import { installLegacyPiSpecifierShim, loadLegacyPiModule } from "./legacy-pi-compat";
 import { resolvePluginManifestEntries } from "./loader";
 import { extractPackageName, parsePluginSpec } from "./parser";
+import { normalizePluginRuntimeConfig } from "./runtime-config";
 import type {
 	DoctorCheck,
 	DoctorOptions,
@@ -124,11 +125,11 @@ export class PluginManager {
 	async #loadRuntimeConfig(): Promise<PluginRuntimeConfig> {
 		const lockPath = getPluginsLockfile();
 		try {
-			return await Bun.file(lockPath).json();
+			return normalizePluginRuntimeConfig(await Bun.file(lockPath).json());
 		} catch (err) {
-			if (isEnoent(err)) return { plugins: {}, settings: {} };
+			if (isEnoent(err)) return normalizePluginRuntimeConfig({});
 			logger.warn("Failed to load plugin runtime config", { path: lockPath, error: String(err) });
-			return { plugins: {}, settings: {} };
+			return normalizePluginRuntimeConfig({});
 		}
 	}
 
@@ -204,6 +205,17 @@ export class PluginManager {
 		}
 	}
 
+	#collectInstalledNames(deps: Record<string, string>, config: PluginRuntimeConfig): Set<string> {
+		const installedNames = new Set<string>();
+		for (const name of Object.keys(deps)) {
+			installedNames.add(name);
+		}
+		for (const name of Object.keys(config.plugins)) {
+			installedNames.add(name);
+		}
+		return installedNames;
+	}
+
 	async #snapshotInstalledPackage(actualName: string | undefined): Promise<PluginPackageSnapshot | null> {
 		if (!actualName) {
 			return null;
@@ -489,21 +501,22 @@ export class PluginManager {
 	 */
 	async list(): Promise<InstalledPlugin[]> {
 		const pkgJsonPath = getPluginsPackageJson();
-		let pkg: { dependencies?: Record<string, string> };
+		let deps: Record<string, string> = {};
 		try {
-			pkg = await Bun.file(pkgJsonPath).json();
+			const pkg: { dependencies?: Record<string, string> } = await Bun.file(pkgJsonPath).json();
+			deps = pkg.dependencies ?? {};
 		} catch (err) {
-			if (isEnoent(err)) return [];
-			throw err;
+			if (!isEnoent(err)) throw err;
 		}
 
-		const deps = pkg.dependencies || {};
 		const projectOverrides = await this.#loadProjectOverrides();
 		const config = await this.#ensureConfigLoaded();
 		const plugins: InstalledPlugin[] = [];
+		const installedNames = this.#collectInstalledNames(deps, config);
 
-		for (const [name] of Object.entries(deps)) {
-			const pluginPkgPath = path.join(getPluginsNodeModules(), name, "package.json");
+		for (const name of installedNames) {
+			const pluginPath = path.join(getPluginsNodeModules(), name);
+			const pluginPkgPath = path.join(pluginPath, "package.json");
 			let pluginPkg: { version: string; omp?: PluginManifest; pi?: PluginManifest };
 			try {
 				pluginPkg = await Bun.file(pluginPkgPath).json();
@@ -520,14 +533,13 @@ export class PluginManager {
 				enabled: true,
 			};
 
-			// Apply project overrides
 			const isDisabledInProject = projectOverrides.disabled?.includes(name) ?? false;
 			const projectFeatures = projectOverrides.features?.[name];
 
 			plugins.push({
 				name,
 				version: pluginPkg.version,
-				path: path.join(getPluginsNodeModules(), name),
+				path: pluginPath,
 				manifest,
 				enabledFeatures: projectFeatures ?? runtimeState.enabledFeatures,
 				enabled: runtimeState.enabled && !isDisabledInProject,
@@ -743,15 +755,14 @@ export class PluginManager {
 			message: hasNodeModules ? "Found" : "Missing (run npm install in plugins dir)",
 		});
 
-		if (!hasPkgJson) {
-			return checks;
-		}
 		const deps = pkg.dependencies || {};
 		const config = await this.#ensureConfigLoaded();
+		const installedNames = this.#collectInstalledNames(deps, config);
 
-		for (const [name] of Object.entries(deps)) {
+		for (const name of installedNames) {
 			const pluginPath = path.join(nodeModulesPath, name);
 			const pluginPkgPath = path.join(pluginPath, "package.json");
+			const fromDependencies = name in deps;
 
 			let pluginPkg: { version: string; description?: string; omp?: PluginManifest; pi?: PluginManifest };
 			try {
@@ -759,13 +770,23 @@ export class PluginManager {
 			} catch (err) {
 				if (isEnoent(err)) {
 					if (!fs.existsSync(pluginPath)) {
-						const fixed = options.fix ? await this.#fixMissingPlugin() : false;
-						checks.push({
-							name: `plugin:${name}`,
-							status: "error",
-							message: "Missing from node_modules",
-							fixed,
-						});
+						if (fromDependencies) {
+							const fixed = options.fix ? await this.#fixMissingPlugin() : false;
+							checks.push({
+								name: `plugin:${name}`,
+								status: "error",
+								message: "Missing from node_modules",
+								fixed,
+							});
+						} else {
+							const fixed = options.fix ? await this.#removeOrphanedConfig(name) : false;
+							checks.push({
+								name: `orphan:${name}`,
+								status: "warning",
+								message: "Plugin in config but not installed",
+								fixed,
+							});
+						}
 					} else {
 						checks.push({
 							name: `plugin:${name}`,
@@ -843,19 +864,6 @@ export class PluginManager {
 			}
 		}
 
-		// Check for orphaned runtime config entries
-		for (const name of Object.keys(config.plugins)) {
-			if (!(name in deps)) {
-				const fixed = options.fix ? await this.#removeOrphanedConfig(name) : false;
-				checks.push({
-					name: `orphan:${name}`,
-					status: "warning",
-					message: "Plugin in config but not installed",
-					fixed,
-				});
-			}
-		}
-
 		return checks;
 	}
 

package/src/extensibility/plugins/marketplace/fetcher.ts

@@ -192,8 +192,33 @@ export function parseMarketplaceCatalog(content: string, filePath: string): Mark
 
 // ── fetchMarketplace ──────────────────────────────────────────────────
 
-/** Relative path from a marketplace root to its catalog file. */
-const CATALOG_RELATIVE_PATH = path.join(".claude-plugin", "marketplace.json");
+/**
+ * Catalog paths tried in priority order: omp-namespaced override first, then
+ * the Claude Code-compatible fallback so existing marketplaces keep loading.
+ */
+const CATALOG_RELATIVE_PATHS: readonly string[] = [
+	path.join(".omp-plugin", "marketplace.json"),
+	path.join(".claude-plugin", "marketplace.json"),
+];
+
+async function readMarketplaceCatalog(root: string): Promise<{ catalogPath: string; content: string }> {
+	const tried: string[] = [];
+	for (const rel of CATALOG_RELATIVE_PATHS) {
+		const catalogPath = path.join(root, rel);
+		tried.push(catalogPath);
+		try {
+			const content = await Bun.file(catalogPath).text();
+			return { catalogPath, content };
+		} catch (err) {
+			if (isEnoent(err)) continue;
+			throw err;
+		}
+	}
+	throw new Error(
+		`Marketplace catalog not found at ${tried.map(p => `"${p}"`).join(" or ")}. ` +
+			`Ensure the directory exists and contains one of: ${CATALOG_RELATIVE_PATHS.join(", ")}.`,
+	);
+}
 
 /**
  * Expand a `~/...` path to an absolute path using os.homedir().
@@ -220,21 +245,7 @@ export async function fetchMarketplace(source: string, cacheDir: string): Promis
 
 	if (type === "local") {
 		const resolved = path.resolve(expandHome(source));
-		const catalogPath = path.join(resolved, CATALOG_RELATIVE_PATH);
-
-		let content: string;
-		try {
-			content = await Bun.file(catalogPath).text();
-		} catch (err) {
-			if (isEnoent(err)) {
-				throw new Error(
-					`Marketplace catalog not found at "${catalogPath}". ` +
-						`Ensure the directory exists and contains a .claude-plugin/marketplace.json file.`,
-				);
-			}
-			throw err;
-		}
-
+		const { catalogPath, content } = await readMarketplaceCatalog(resolved);
 		const catalog = parseMarketplaceCatalog(content, catalogPath);
 		return { catalog };
 	}
@@ -280,27 +291,14 @@ async function cloneAndReadCatalog(url: string, cacheDir: string): Promise<Fetch
 	logger.debug(`[marketplace] cloning ${url} → ${tmpDir}`);
 	await git.clone(url, tmpDir);
 
-	const catalogPath = path.join(tmpDir, CATALOG_RELATIVE_PATH);
-	let content: string;
 	try {
-		content = await Bun.file(catalogPath).text();
-	} catch (err) {
-		await fs.rm(tmpDir, { recursive: true, force: true });
-		if (isEnoent(err)) {
-			throw new Error(`Cloned repository has no marketplace catalog at ${CATALOG_RELATIVE_PATH}`);
-		}
-		throw err;
-	}
-
-	let catalog: MarketplaceCatalog;
-	try {
-		catalog = parseMarketplaceCatalog(content, catalogPath);
+		const { catalogPath, content } = await readMarketplaceCatalog(tmpDir);
+		const catalog = parseMarketplaceCatalog(content, catalogPath);
+		return { catalog, clonePath: tmpDir };
 	} catch (err) {
 		await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
-		throw err;
+		throw new Error(`Cloned repository ${url}: ${(err as Error).message}`, { cause: err });
 	}
-
-	return { catalog, clonePath: tmpDir };
 }
 
 /**

package/src/extensibility/plugins/runtime-config.ts

@@ -0,0 +1,9 @@
+import type { PluginRuntimeConfig } from "./types";
+
+/** Normalizes persisted plugin runtime config across legacy lockfile shapes. */
+export function normalizePluginRuntimeConfig(config: Partial<PluginRuntimeConfig>): PluginRuntimeConfig {
+	return {
+		plugins: config.plugins ?? {},
+		settings: config.settings ?? {},
+	};
+}