@oh-my-pi/cli 0.1.0 → 0.2.0

package/src/commands/install.ts

@@ -1,24 +1,58 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { cp, mkdir, readFile, rm } from "node:fs/promises";
 import { basename, join, resolve } from "node:path";
 import { createInterface } from "node:readline";
-import chalk from "chalk";
-import { type Conflict, detectConflicts, formatConflicts } from "../conflicts.js";
+import { type Conflict, detectConflicts, detectIntraPluginDuplicates, formatConflicts } from "@omp/conflicts";
+import { updateLockFile } from "@omp/lockfile";
 import {
 	getInstalledPlugins,
 	initGlobalPlugins,
+	initProjectPlugins,
 	loadPluginsJson,
 	type PluginPackageJson,
 	readPluginPackageJson,
 	savePluginsJson,
-} from "../manifest.js";
-import { npmInfo, npmInstall } from "../npm.js";
-import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES, PROJECT_PLUGINS_JSON } from "../paths.js";
-import { createPluginSymlinks } from "../symlinks.js";
+} from "@omp/manifest";
+import { npmInfo, npmInstall } from "@omp/npm";
+import {
+	NODE_MODULES_DIR,
+	PI_CONFIG_DIR,
+	PLUGINS_DIR,
+	PROJECT_NODE_MODULES,
+	PROJECT_PI_DIR,
+	resolveScope,
+} from "@omp/paths";
+import { createPluginSymlinks } from "@omp/symlinks";
+import chalk from "chalk";
+
+/**
+ * Process omp dependencies recursively with cycle detection.
+ * Creates symlinks for dependencies that have omp.install entries.
+ */
+async function processOmpDependencies(pkgJson: PluginPackageJson, isGlobal: boolean, seen: Set<string>): Promise<void> {
+	if (!pkgJson.dependencies) return;
+
+	for (const depName of Object.keys(pkgJson.dependencies)) {
+		if (seen.has(depName)) {
+			console.log(chalk.yellow(`  Skipping circular dependency: ${depName}`));
+			continue;
+		}
+		seen.add(depName);
+
+		const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+		if (depPkgJson?.omp?.install) {
+			console.log(chalk.dim(`  Processing dependency: ${depName}`));
+			await createPluginSymlinks(depName, depPkgJson, isGlobal);
+			// Recurse into this dependency's dependencies
+			await processOmpDependencies(depPkgJson, isGlobal, seen);
+		}
+	}
+}
 
 export interface InstallOptions {
 	global?: boolean;
+	local?: boolean;
 	save?: boolean;
 	saveDev?: boolean;
 	force?: boolean;
@@ -93,7 +127,7 @@ function isLocalPath(spec: string): boolean {
  * omp install [pkg...]
  */
 export async function installPlugin(packages?: string[], options: InstallOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false; // Default to global
+	const isGlobal = resolveScope(options);
 	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
 	const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
 
@@ -101,24 +135,29 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 	if (isGlobal) {
 		await initGlobalPlugins();
 	} else {
-		// Ensure project .pi directory exists
-		await mkdir(prefix, { recursive: true });
-		// Initialize plugins.json if it doesn't exist
-		if (!existsSync(PROJECT_PLUGINS_JSON)) {
-			await savePluginsJson({ plugins: {} }, false);
-		}
+		// Initialize project .pi directory with both plugins.json and package.json
+		await initProjectPlugins();
 	}
 
 	// If no packages specified, install from plugins.json
 	if (!packages || packages.length === 0) {
 		const pluginsJson = await loadPluginsJson(isGlobal);
-		packages = Object.entries(pluginsJson.plugins).map(([name, version]) => `${name}@${version}`);
+		// Prefer locked versions for reproducible installs
+		const lockFile = await import("@omp/lockfile").then((m) => m.loadLockFile(isGlobal));
+		packages = await Promise.all(
+			Object.entries(pluginsJson.plugins).map(async ([name, version]) => {
+				// Use locked version if available for reproducibility
+				const lockedVersion = lockFile?.packages[name]?.version;
+				return `${name}@${lockedVersion || version}`;
+			}),
+		);
 
 		if (packages.length === 0) {
 			console.log(chalk.yellow("No plugins to install."));
 			console.log(
 				chalk.dim(isGlobal ? "Add plugins with: omp install <package>" : "Add plugins to .pi/plugins.json"),
 			);
+			process.exitCode = 1;
 			return;
 		}
 
@@ -143,24 +182,90 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 		const { name, version } = parsePackageSpec(spec);
 		const pkgSpec = version === "latest" ? name : `${name}@${version}`;
 
+		// Track installation state for rollback
+		let npmInstallSucceeded = false;
+		let createdSymlinks: string[] = [];
+		let resolvedVersion = version;
+
 		try {
 			console.log(chalk.blue(`\nInstalling ${pkgSpec}...`));
 
-			// 1. Resolve version from npm registry
+			// 1. Resolve version and fetch package metadata from npm registry
+			// npm info includes omp field if present in package.json
 			const info = await npmInfo(pkgSpec);
 			if (!info) {
 				console.log(chalk.red(`  ✗ Package not found: ${name}`));
+				process.exitCode = 1;
 				results.push({ name, version, success: false, error: "Package not found" });
 				continue;
 			}
+			resolvedVersion = info.version;
+
+			// 2. Check for conflicts BEFORE npm install using registry metadata
+			const skipDestinations = new Set<string>();
+			const preInstallPkgJson = info.omp?.install ? { name: info.name, version: info.version, omp: info.omp } : null;
+
+			if (preInstallPkgJson) {
+				// Check for intra-plugin duplicates first
+				const intraDupes = detectIntraPluginDuplicates(preInstallPkgJson);
+				if (intraDupes.length > 0) {
+					console.log(chalk.red(`  ✗ Plugin has duplicate destinations:`));
+					for (const dupe of intraDupes) {
+						console.log(chalk.red(`    ${dupe.dest} ← ${dupe.sources.join(", ")}`));
+					}
+					process.exitCode = 1;
+					results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
+					continue;
+				}
 
-			// 2. Check for conflicts before installing
-			// We need to fetch the package.json to check omp.install
-			// For now, we'll check after npm install and rollback if needed
+				const preInstallConflicts = detectConflicts(name, preInstallPkgJson, existingPlugins);
+
+				if (preInstallConflicts.length > 0 && !options.force) {
+					// Check for non-interactive terminal (CI environments)
+					if (!process.stdout.isTTY || !process.stdin.isTTY) {
+						console.log(chalk.red("Conflicts detected in non-interactive mode. Use --force to override."));
+						for (const conflict of preInstallConflicts) {
+							console.log(chalk.yellow(`  ⚠ ${formatConflicts([conflict])[0]}`));
+						}
+						process.exitCode = 1;
+						results.push({
+							name,
+							version: info.version,
+							success: false,
+							error: "Conflicts in non-interactive mode",
+						});
+						continue;
+					}
+
+					// Handle conflicts BEFORE downloading the package
+					let abort = false;
+					for (const conflict of preInstallConflicts) {
+						const choice = await promptConflictResolution(conflict);
+						if (choice === null) {
+							abort = true;
+							break;
+						}
+						// choice is 0-indexed: 0 = first plugin (existing), last index = new plugin
+						const newPluginIndex = conflict.plugins.length - 1;
+						if (choice !== newPluginIndex) {
+							// User chose an existing plugin, skip this destination
+							skipDestinations.add(conflict.dest);
+						}
+					}
 
-			// 3. npm install
+					if (abort) {
+						console.log(chalk.yellow(`  Aborted due to conflicts (before download)`));
+						process.exitCode = 1;
+						results.push({ name, version: info.version, success: false, error: "Conflicts" });
+						continue;
+					}
+				}
+			}
+
+			// 3. npm install - only reached if no conflicts or user resolved them
 			console.log(chalk.dim(`  Fetching from npm...`));
 			await npmInstall([pkgSpec], prefix, { save: options.save || isGlobal });
+			npmInstallSucceeded = true;
 
 			// 4. Read package.json from installed package
 			const pkgJson = await readPluginPackageJson(name, isGlobal);
@@ -170,55 +275,133 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 				continue;
 			}
 
-			// 5. Check for conflicts
-			const conflicts = detectConflicts(name, pkgJson, existingPlugins);
-
-			if (conflicts.length > 0 && !options.force) {
-				// Handle conflicts
-				let abort = false;
-				for (const conflict of conflicts) {
-					const choice = await promptConflictResolution(conflict);
-					if (choice === null) {
-						abort = true;
-						break;
+			// 5. Re-check conflicts with full package.json if we didn't check pre-install
+			// This handles edge cases where omp field wasn't in registry metadata
+			if (!preInstallPkgJson) {
+				// Check for intra-plugin duplicates first
+				const intraDupes = detectIntraPluginDuplicates(pkgJson);
+				if (intraDupes.length > 0) {
+					console.log(chalk.red(`  ✗ Plugin has duplicate destinations:`));
+					for (const dupe of intraDupes) {
+						console.log(chalk.red(`    ${dupe.dest} ← ${dupe.sources.join(", ")}`));
 					}
-					// If user chose the new plugin, we continue
-					// If user chose existing plugin, we skip this destination
-					// For now, simplify: if not aborted, force overwrite
-				}
-
-				if (abort) {
-					console.log(chalk.yellow(`  Aborted due to conflicts`));
 					// Rollback: uninstall the package
-					execSync(`npm uninstall --prefix ${prefix} ${name}`, { stdio: "pipe" });
-					results.push({ name, version: info.version, success: false, error: "Conflicts" });
+					execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+					process.exitCode = 1;
+					results.push({ name, version: info.version, success: false, error: "Duplicate destinations in plugin" });
 					continue;
 				}
-			}
 
-			// 6. Create symlinks for omp.install entries
-			const _symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal);
+				const conflicts = detectConflicts(name, pkgJson, existingPlugins);
+
+				if (conflicts.length > 0 && !options.force) {
+					// Check for non-interactive terminal (CI environments)
+					if (!process.stdout.isTTY || !process.stdin.isTTY) {
+						console.log(chalk.red("Conflicts detected in non-interactive mode. Use --force to override."));
+						for (const conflict of conflicts) {
+							console.log(chalk.yellow(`  ⚠ ${formatConflicts([conflict])[0]}`));
+						}
+						// Rollback: uninstall the package
+						execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+						process.exitCode = 1;
+						results.push({
+							name,
+							version: info.version,
+							success: false,
+							error: "Conflicts in non-interactive mode",
+						});
+						continue;
+					}
+
+					let abort = false;
+					for (const conflict of conflicts) {
+						const choice = await promptConflictResolution(conflict);
+						if (choice === null) {
+							abort = true;
+							break;
+						}
+						const newPluginIndex = conflict.plugins.length - 1;
+						if (choice !== newPluginIndex) {
+							skipDestinations.add(conflict.dest);
+						}
+					}
 
-			// 7. Process dependencies with omp field
-			if (pkgJson.dependencies) {
-				for (const depName of Object.keys(pkgJson.dependencies)) {
-					const depPkgJson = await readPluginPackageJson(depName, isGlobal);
-					if (depPkgJson?.omp?.install) {
-						console.log(chalk.dim(`  Processing dependency: ${depName}`));
-						await createPluginSymlinks(depName, depPkgJson, isGlobal);
+					if (abort) {
+						console.log(chalk.yellow(`  Aborted due to conflicts`));
+						// Rollback: uninstall the package
+						execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+						process.exitCode = 1;
+						results.push({ name, version: info.version, success: false, error: "Conflicts" });
+						continue;
 					}
 				}
 			}
 
+			// 6. Create symlinks for omp.install entries (skip destinations user assigned to existing plugins)
+			const symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal, true, skipDestinations);
+			createdSymlinks = symlinkResult.created;
+
+			// 7. Process dependencies with omp field (with cycle detection)
+			await processOmpDependencies(pkgJson, isGlobal, new Set([name]));
+
+			// 8. Update manifest if --save or --save-dev was passed
+			// For global mode, npm --save already updates package.json dependencies
+			// but we need to handle devDependencies manually
+			// For project-local mode, we must manually update plugins.json
+			if (options.save || options.saveDev) {
+				const pluginsJson = await loadPluginsJson(isGlobal);
+				if (options.saveDev) {
+					// Save to devDependencies
+					if (!pluginsJson.devDependencies) {
+						pluginsJson.devDependencies = {};
+					}
+					pluginsJson.devDependencies[name] = info.version;
+					// Remove from plugins if it was there
+					delete pluginsJson.plugins[name];
+				} else if (!isGlobal) {
+					// Save to plugins (project-local mode only - npm handles global)
+					pluginsJson.plugins[name] = info.version;
+				}
+				await savePluginsJson(pluginsJson, isGlobal);
+			}
+
 			// Add to installed plugins map for subsequent conflict detection
 			existingPlugins.set(name, pkgJson);
 
+			// Update lock file with exact version
+			await updateLockFile(name, info.version, isGlobal);
+
 			console.log(chalk.green(`✓ Installed ${name}@${info.version}`));
 			results.push({ name, version: info.version, success: true });
 		} catch (err) {
 			const errorMsg = (err as Error).message;
 			console.log(chalk.red(`  ✗ Failed to install ${name}: ${errorMsg}`));
-			results.push({ name, version, success: false, error: errorMsg });
+
+			// Rollback: remove any symlinks that were created
+			if (createdSymlinks.length > 0) {
+				console.log(chalk.dim("  Rolling back symlinks..."));
+				const baseDir = isGlobal ? PI_CONFIG_DIR : PROJECT_PI_DIR;
+				for (const dest of createdSymlinks) {
+					try {
+						await rm(join(baseDir, dest), { force: true, recursive: true });
+					} catch {
+						// Ignore cleanup errors
+					}
+				}
+			}
+
+			// Rollback: uninstall npm package if it was installed
+			if (npmInstallSucceeded) {
+				console.log(chalk.dim("  Rolling back npm install..."));
+				try {
+					execFileSync("npm", ["uninstall", "--prefix", prefix, name], { stdio: "pipe" });
+				} catch {
+					// Ignore cleanup errors
+				}
+			}
+
+			process.exitCode = 1;
+			results.push({ name, version: resolvedVersion, success: false, error: errorMsg });
 		}
 	}
 
@@ -232,6 +415,7 @@ export async function installPlugin(packages?: string[], options: InstallOptions
 	}
 	if (failed.length > 0) {
 		console.log(chalk.red(`✗ Failed to install ${failed.length} plugin(s)`));
+		process.exitCode = 1;
 	}
 
 	if (options.json) {
@@ -255,6 +439,7 @@ async function installLocalPlugin(
 
 	if (!existsSync(localPath)) {
 		console.log(chalk.red(`Error: Path does not exist: ${localPath}`));
+		process.exitCode = 1;
 		return { name: basename(localPath), version: "local", success: false, error: "Path not found" };
 	}
 
@@ -295,6 +480,22 @@ async function installLocalPlugin(
 		const pluginName = pkgJson.name;
 		const pluginDir = join(nodeModules, pluginName);
 
+		// Check for intra-plugin duplicates
+		const intraDupes = detectIntraPluginDuplicates(pkgJson);
+		if (intraDupes.length > 0) {
+			console.log(chalk.red(`\nError: Plugin has duplicate destinations:`));
+			for (const dupe of intraDupes) {
+				console.log(chalk.red(`  ${dupe.dest} ← ${dupe.sources.join(", ")}`));
+			}
+			process.exitCode = 1;
+			return {
+				name: pluginName,
+				version: pkgJson.version,
+				success: false,
+				error: "Duplicate destinations in plugin",
+			};
+		}
+
 		console.log(chalk.blue(`\nInstalling ${pluginName} from ${localPath}...`));
 
 		// Create node_modules directory
@@ -311,17 +512,30 @@ async function installLocalPlugin(
 
 		// Update plugins.json/package.json
 		const pluginsJson = await loadPluginsJson(isGlobal);
-		pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		if (_options.saveDev) {
+			if (!pluginsJson.devDependencies) {
+				pluginsJson.devDependencies = {};
+			}
+			pluginsJson.devDependencies[pluginName] = `file:${localPath}`;
+			// Remove from plugins if it was there
+			delete pluginsJson.plugins[pluginName];
+		} else {
+			pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		}
 		await savePluginsJson(pluginsJson, isGlobal);
 
 		// Create symlinks
 		await createPluginSymlinks(pluginName, pkgJson, isGlobal);
 
+		// Update lock file for local plugin
+		await updateLockFile(pluginName, pkgJson.version, isGlobal);
+
 		console.log(chalk.green(`✓ Installed ${pluginName}@${pkgJson.version}`));
 		return { name: pluginName, version: pkgJson.version, success: true };
 	} catch (err) {
 		const errorMsg = (err as Error).message;
 		console.log(chalk.red(`  ✗ Failed: ${errorMsg}`));
+		process.exitCode = 1;
 		return { name: basename(localPath), version: "local", success: false, error: errorMsg };
 	}
 }

package/src/commands/link.ts

@@ -1,14 +1,32 @@
 import { existsSync } from "node:fs";
-import { mkdir, readFile, rm, symlink } from "node:fs/promises";
+import { mkdir, readFile, rm, symlink, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import { loadPluginsJson, type PluginPackageJson, savePluginsJson } from "@omp/manifest";
+import { NODE_MODULES_DIR, PROJECT_NODE_MODULES, resolveScope } from "@omp/paths";
+import { createPluginSymlinks } from "@omp/symlinks";
 import chalk from "chalk";
-import { loadPluginsJson, type PluginPackageJson, savePluginsJson } from "../manifest.js";
-import { NODE_MODULES_DIR, PROJECT_NODE_MODULES } from "../paths.js";
-import { createPluginSymlinks } from "../symlinks.js";
+
+async function confirmCreate(path: string): Promise<boolean> {
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		console.log(chalk.dim("  Non-interactive mode: auto-creating package.json"));
+		return true;
+	}
+
+	const rl = createInterface({ input: process.stdin, output: process.stdout });
+	return new Promise((resolve) => {
+		rl.question(chalk.yellow(`  Create minimal package.json at ${path}? [Y/n] `), (answer) => {
+			rl.close();
+			resolve(answer.toLowerCase() !== "n");
+		});
+	});
+}
 
 export interface LinkOptions {
 	name?: string;
 	global?: boolean;
+	local?: boolean;
+	force?: boolean;
 }
 
 /**
@@ -16,7 +34,7 @@ export interface LinkOptions {
  * Creates a symlink in node_modules pointing to the local directory
  */
 export async function linkPlugin(localPath: string, options: LinkOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 	const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
 
 	// Expand ~ to home directory
@@ -28,6 +46,7 @@ export async function linkPlugin(localPath: string, options: LinkOptions = {}):
 	// Verify the path exists
 	if (!existsSync(localPath)) {
 		console.log(chalk.red(`Error: Path does not exist: ${localPath}`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -50,13 +69,29 @@ export async function linkPlugin(localPath: string, options: LinkOptions = {}):
 				install: ompJson.install,
 			},
 		};
+
+		// Persist the conversion to package.json
+		console.log(chalk.dim("  Converting omp.json to package.json..."));
+		await writeFile(localPkgJsonPath, JSON.stringify(pkgJson, null, 2));
 	} else {
+		// Create minimal package.json so npm operations work correctly
+		console.log(chalk.yellow("  No package.json found in target directory."));
+		const shouldCreate = await confirmCreate(localPkgJsonPath);
+		if (!shouldCreate) {
+			console.log(chalk.yellow("  Aborted: package.json required for linking"));
+			process.exitCode = 1;
+			return;
+		}
 		pkgJson = {
 			name: options.name || basename(localPath),
 			version: "0.0.0-dev",
 			keywords: ["omp-plugin"],
+			omp: {
+				install: [],
+			},
 		};
-		console.log(chalk.yellow("  Warning: No package.json or omp.json found"));
+		console.log(chalk.dim("  Creating minimal package.json..."));
+		await writeFile(localPkgJsonPath, JSON.stringify(pkgJson, null, 2));
 	}
 
 	const pluginName = options.name || pkgJson.name;
@@ -65,9 +100,24 @@ export async function linkPlugin(localPath: string, options: LinkOptions = {}):
 	// Check if already installed
 	const pluginsJson = await loadPluginsJson(isGlobal);
 	if (pluginsJson.plugins[pluginName]) {
-		console.log(chalk.yellow(`Plugin "${pluginName}" is already installed.`));
-		console.log(chalk.dim("Use omp uninstall first, or specify a different name with -n"));
-		return;
+		const existingSpec = pluginsJson.plugins[pluginName];
+		const isLinked = existingSpec.startsWith("file:");
+
+		if (isLinked) {
+			console.log(chalk.yellow(`Plugin "${pluginName}" is already linked.`));
+			console.log(chalk.dim(`  Current link: ${existingSpec}`));
+			console.log(chalk.dim("  Re-linking..."));
+			// Continue with the linking process (will overwrite)
+		} else if (options.force) {
+			console.log(chalk.yellow(`Plugin "${pluginName}" is installed from npm. Overwriting with link...`));
+			// Continue with the linking process (will overwrite)
+		} else {
+			console.log(chalk.yellow(`Plugin "${pluginName}" is already installed from npm.`));
+			console.log(chalk.dim("Use omp uninstall first, or specify a different name with -n"));
+			console.log(chalk.dim("Or use --force to overwrite the npm installation"));
+			process.exitCode = 1;
+			return;
+		}
 	}
 
 	try {
@@ -100,6 +150,7 @@ export async function linkPlugin(localPath: string, options: LinkOptions = {}):
 		console.log(chalk.dim("  Changes to the source will be reflected immediately"));
 	} catch (err) {
 		console.log(chalk.red(`Error linking plugin: ${(err as Error).message}`));
+		process.exitCode = 1;
 		// Cleanup on failure
 		try {
 			await rm(pluginDir, { force: true });

package/src/commands/list.ts

@@ -1,8 +1,10 @@
+import { loadPluginsJson, readPluginPackageJson } from "@omp/manifest";
+import { resolveScope } from "@omp/paths";
 import chalk from "chalk";
-import { loadPluginsJson, readPluginPackageJson } from "../manifest.js";
 
 export interface ListOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -10,13 +12,14 @@ export interface ListOptions {
  * List all installed plugins
  */
 export async function listPlugins(options: ListOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 	const pluginsJson = await loadPluginsJson(isGlobal);
 	const pluginNames = Object.keys(pluginsJson.plugins);
 
 	if (pluginNames.length === 0) {
 		console.log(chalk.yellow("No plugins installed."));
 		console.log(chalk.dim("Install one with: omp install <package>"));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -44,13 +47,15 @@ export async function listPlugins(options: ListOptions = {}): Promise<void> {
 		const specifier = pluginsJson.plugins[name];
 		const isLocal = specifier.startsWith("file:");
 		const disabled = pluginsJson.disabled?.includes(name);
+		const isMissing = !pkgJson;
 
-		const version = pkgJson?.version ? chalk.dim(` v${pkgJson.version}`) : "";
+		const version = pkgJson?.version ? chalk.dim(` v${pkgJson.version}`) : chalk.dim(` (${specifier})`);
 		const localBadge = isLocal ? chalk.cyan(" (local)") : "";
 		const disabledBadge = disabled ? chalk.yellow(" (disabled)") : "";
-		const icon = disabled ? chalk.gray("○") : chalk.green("◆");
+		const missingBadge = isMissing ? chalk.red(" (missing)") : "";
+		const icon = disabled ? chalk.gray("○") : isMissing ? chalk.red("✗") : chalk.green("◆");
 
-		console.log(`${icon} ${chalk.bold(name)}${version}${localBadge}${disabledBadge}`);
+		console.log(`${icon} ${chalk.bold(name)}${version}${localBadge}${disabledBadge}${missingBadge}`);
 
 		if (pkgJson?.description) {
 			console.log(chalk.dim(`    ${pkgJson.description}`));

package/src/commands/outdated.ts

@@ -1,10 +1,11 @@
+import { loadPluginsJson } from "@omp/manifest";
+import { npmOutdated } from "@omp/npm";
+import { PLUGINS_DIR, resolveScope } from "@omp/paths";
 import chalk from "chalk";
-import { loadPluginsJson } from "../manifest.js";
-import { npmOutdated } from "../npm.js";
-import { PLUGINS_DIR } from "../paths.js";
 
 export interface OutdatedOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -12,7 +13,7 @@ export interface OutdatedOptions {
  * List plugins with newer versions available
  */
 export async function showOutdated(options: OutdatedOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
 
 	console.log(chalk.blue("Checking for outdated plugins..."));
@@ -21,9 +22,12 @@ export async function showOutdated(options: OutdatedOptions = {}): Promise<void>
 		const outdated = await npmOutdated(prefix);
 		const pluginsJson = await loadPluginsJson(isGlobal);
 
-		// Filter to only show plugins we manage
+		// Filter to only show plugins we manage AND are not local
 		const managedOutdated = Object.entries(outdated).filter(([name]) => {
-			return pluginsJson.plugins[name] !== undefined;
+			const specifier = pluginsJson.plugins[name];
+			if (!specifier) return false; // Not in our manifest
+			if (specifier.startsWith("file:")) return false; // Local plugin, skip
+			return true;
 		});
 
 		if (managedOutdated.length === 0) {
@@ -66,11 +70,18 @@ export async function showOutdated(options: OutdatedOptions = {}): Promise<void>
 			);
 		}
 
+		// Note about local plugins excluded from check
+		const localPlugins = Object.entries(pluginsJson.plugins).filter(([_, spec]) => spec.startsWith("file:"));
+		if (localPlugins.length > 0) {
+			console.log(chalk.dim(`\nNote: ${localPlugins.length} local plugin(s) excluded from check`));
+		}
+
 		console.log();
 		console.log(chalk.dim("Update with: omp update [package]"));
 		console.log(chalk.dim("  - 'wanted' = latest within semver range"));
 		console.log(chalk.dim("  - 'latest' = latest available version"));
 	} catch (err) {
 		console.log(chalk.red(`Error checking outdated: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }