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

package/src/extensibility/plugins/loader.ts

@@ -143,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] : [];
 }
 
 /**
@@ -196,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));
 		}
 	}
 
@@ -215,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));
 				}
 			}
 		}
@@ -225,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

@@ -205,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;
@@ -490,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();
@@ -521,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,
@@ -744,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 {
@@ -760,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}`,
@@ -844,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;
 	}