@oh-my-pi/cli 0.1.0 → 0.3.0

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,22 +1,132 @@
+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;
 }
 
+/**
+ * Known file categories with their patterns and display info
+ */
+interface FileCategory {
+	pattern: RegExp;
+	label: string;
+	color: (s: string) => string;
+	extractName: (dest: string) => string;
+}
+
+const FILE_CATEGORIES: FileCategory[] = [
+	{
+		pattern: /^agent\/tools\/([^/]+)\//,
+		label: "Tools",
+		color: chalk.cyan,
+		extractName: (dest) => dest.match(/^agent\/tools\/([^/]+)\//)?.[1] || dest,
+	},
+	{
+		pattern: /^agent\/agents\/(.+)\.md$/,
+		label: "Agents",
+		color: chalk.magenta,
+		extractName: (dest) => dest.match(/^agent\/agents\/(.+)\.md$/)?.[1] || dest,
+	},
+	{
+		pattern: /^agent\/commands\/(.+)\.md$/,
+		label: "Commands",
+		color: chalk.yellow,
+		extractName: (dest) => dest.match(/^agent\/commands\/(.+)\.md$/)?.[1] || dest,
+	},
+	{
+		pattern: /^agent\/themes\/(.+)\.json$/,
+		label: "Themes",
+		color: chalk.green,
+		extractName: (dest) => dest.match(/^agent\/themes\/(.+)\.json$/)?.[1] || dest,
+	},
+	{
+		pattern: /^agent\/prompts?\//,
+		label: "Prompts",
+		color: chalk.blue,
+		extractName: (dest) => dest.split("/").pop()?.replace(/\.[^.]+$/, "") || dest,
+	},
+	{
+		pattern: /^agent\/hooks?\//,
+		label: "Hooks",
+		color: chalk.red,
+		extractName: (dest) => dest.split("/").pop()?.replace(/\.[^.]+$/, "") || dest,
+	},
+];
+
+/**
+ * Categorize installed files into known categories
+ */
+function categorizeFiles(files: string[]): { categorized: Map<string, string[]>; uncategorized: string[] } {
+	const categorized = new Map<string, string[]>();
+	const uncategorized: string[] = [];
+
+	for (const file of files) {
+		let matched = false;
+		for (const category of FILE_CATEGORIES) {
+			if (category.pattern.test(file)) {
+				const name = category.extractName(file);
+				const existing = categorized.get(category.label) || [];
+				if (!existing.includes(name)) {
+					existing.push(name);
+					categorized.set(category.label, existing);
+				}
+				matched = true;
+				break;
+			}
+		}
+		if (!matched) {
+			uncategorized.push(file);
+		}
+	}
+
+	return { categorized, uncategorized };
+}
+
+/**
+ * Format categorized files for display
+ */
+function formatContributes(files: string[]): string[] {
+	const { categorized, uncategorized } = categorizeFiles(files);
+	const lines: string[] = [];
+
+	if (categorized.size > 0 || uncategorized.length > 0) {
+		lines.push(`    ${chalk.white("Contributes:")}`);
+
+		for (const category of FILE_CATEGORIES) {
+			const items = categorized.get(category.label);
+			if (items && items.length > 0) {
+				const count = category.color(`${items.length}`);
+				const names = items.map((n) => chalk.dim(n)).join(chalk.dim(", "));
+				lines.push(`      ${chalk.green("+")} ${category.label} (${count}): ${names}`);
+			}
+		}
+
+		if (uncategorized.length > 0) {
+			const count = chalk.gray(`${uncategorized.length}`);
+			const names = uncategorized.map((n) => chalk.dim(n)).join(chalk.dim(", "));
+			lines.push(`      ${chalk.green("+")} Files (${count}): ${names}`);
+		}
+	}
+
+	return lines;
+}
+
 /**
  * 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 +154,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}`));
@@ -58,12 +170,15 @@ export async function listPlugins(options: ListOptions = {}): Promise<void> {
 
 		if (isLocal) {
 			const localPath = specifier.replace("file:", "");
-			console.log(chalk.dim(`    path: ${localPath}`));
+			console.log(chalk.dim(`    Path: ${localPath}`));
 		}
 
 		if (pkgJson?.omp?.install?.length) {
 			const files = pkgJson.omp.install.map((e) => e.dest);
-			console.log(chalk.dim(`    files: ${files.join(", ")}`));
+			const contributeLines = formatContributes(files);
+			for (const line of contributeLines) {
+				console.log(line);
+			}
 		}
 
 		console.log();

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;
 	}
 }

package/src/commands/search.ts

@@ -1,5 +1,10 @@
+import { npmSearch } from "@omp/npm";
 import chalk from "chalk";
-import { npmSearch } from "../npm.js";
+
+function truncate(str: string, maxLen: number): string {
+	if (!str || str.length <= maxLen) return str;
+	return `${str.slice(0, maxLen - 3)}...`;
+}
 
 export interface SearchOptions {
 	json?: boolean;
@@ -19,6 +24,7 @@ export async function searchPlugins(query: string, options: SearchOptions = {}):
 			console.log(chalk.yellow("\nNo plugins found."));
 			console.log(chalk.dim("Try a different search term, or search without keyword:"));
 			console.log(chalk.dim("  npm search omp-plugin"));
+			process.exitCode = 1;
 			return;
 		}
 
@@ -36,7 +42,7 @@ export async function searchPlugins(query: string, options: SearchOptions = {}):
 			console.log(chalk.green("◆ ") + chalk.bold(result.name) + chalk.dim(` v${result.version}`));
 
 			if (result.description) {
-				console.log(chalk.dim(`    ${result.description}`));
+				console.log(chalk.dim(`    ${truncate(result.description, 100)}`));
 			}
 
 			if (result.keywords?.length) {
@@ -55,6 +61,17 @@ export async function searchPlugins(query: string, options: SearchOptions = {}):
 
 		console.log(chalk.dim("Install with: omp install <package-name>"));
 	} catch (err) {
-		console.log(chalk.red(`Error searching: ${(err as Error).message}`));
+		const error = err as Error;
+		if (
+			error.message.includes("ENOTFOUND") ||
+			error.message.includes("ETIMEDOUT") ||
+			error.message.includes("EAI_AGAIN")
+		) {
+			console.log(chalk.red("\nNetwork error: Unable to reach npm registry."));
+			console.log(chalk.dim("  Check your internet connection and try again."));
+		} else {
+			console.log(chalk.red(`\nSearch failed: ${error.message}`));
+		}
+		process.exitCode = 1;
 	}
 }

package/src/commands/uninstall.ts

@@ -1,14 +1,16 @@
 import { existsSync } from "node:fs";
 import { rm } from "node:fs/promises";
 import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { getInstalledPlugins, loadPluginsJson, readPluginPackageJson, savePluginsJson } from "@omp/manifest";
+import { npmUninstall } from "@omp/npm";
+import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES, resolveScope } from "@omp/paths";
+import { removePluginSymlinks } from "@omp/symlinks";
 import chalk from "chalk";
-import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "../manifest.js";
-import { npmUninstall } from "../npm.js";
-import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES } from "../paths.js";
-import { removePluginSymlinks } from "../symlinks.js";
 
 export interface UninstallOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -16,7 +18,7 @@ export interface UninstallOptions {
  * Uninstall a plugin
  */
 export async function uninstallPlugin(name: string, options: UninstallOptions = {}): 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;
 
@@ -24,6 +26,7 @@ export async function uninstallPlugin(name: string, options: UninstallOptions =
 	const pluginsJson = await loadPluginsJson(isGlobal);
 	if (!pluginsJson.plugins[name]) {
 		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -33,9 +36,56 @@ export async function uninstallPlugin(name: string, options: UninstallOptions =
 		// 1. Read package.json for omp.install entries before uninstalling
 		const pkgJson = await readPluginPackageJson(name, isGlobal);
 
+		// Check for shared dependencies
+		if (pkgJson?.dependencies) {
+			const allPlugins = await getInstalledPlugins(isGlobal);
+			const sharedDeps: string[] = [];
+
+			for (const depName of Object.keys(pkgJson.dependencies)) {
+				for (const [otherName, otherPkgJson] of allPlugins) {
+					if (otherName !== name && otherPkgJson.dependencies?.[depName]) {
+						sharedDeps.push(`${depName} (also used by ${otherName})`);
+						break;
+					}
+				}
+			}
+
+			if (sharedDeps.length > 0) {
+				console.log(chalk.yellow("\n⚠ Warning: This plugin shares dependencies with other plugins:"));
+				for (const dep of sharedDeps) {
+					console.log(chalk.dim(`  - ${dep}`));
+				}
+				console.log(chalk.dim("  These dependencies will remain installed."));
+			}
+		}
+
 		// 2. Remove symlinks
 		if (pkgJson) {
-			await removePluginSymlinks(name, pkgJson);
+			const result = await removePluginSymlinks(name, pkgJson, isGlobal);
+
+			if (result.skippedNonSymlinks.length > 0) {
+				console.log(chalk.yellow("\nThe following files are not symlinks and were not removed:"));
+				for (const file of result.skippedNonSymlinks) {
+					console.log(chalk.dim(`  - ${file}`));
+				}
+
+				if (process.stdin.isTTY && process.stdout.isTTY) {
+					const rl = createInterface({ input: process.stdin, output: process.stdout });
+					const answer = await new Promise<string>((resolve) => {
+						rl.question(chalk.yellow("Delete these files anyway? [y/N] "), (ans) => {
+							rl.close();
+							resolve(ans);
+						});
+					});
+
+					if (answer.toLowerCase() === "y") {
+						for (const file of result.skippedNonSymlinks) {
+							await rm(file, { force: true, recursive: true });
+							console.log(chalk.dim(`  Deleted: ${file}`));
+						}
+					}
+				}
+			}
 		}
 
 		// 3. npm uninstall
@@ -65,6 +115,7 @@ export async function uninstallPlugin(name: string, options: UninstallOptions =
 		}
 	} catch (err) {
 		console.log(chalk.red(`Error uninstalling plugin: ${(err as Error).message}`));
+		process.exitCode = 1;
 
 		if (options.json) {
 			console.log(JSON.stringify({ name, success: false, error: (err as Error).message }, null, 2));

package/src/commands/update.ts

@@ -1,11 +1,21 @@
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { loadPluginsJson, type OmpInstallEntry, type PluginPackageJson, readPluginPackageJson } from "@omp/manifest";
+import { npmUpdate } from "@omp/npm";
+import {
+	NODE_MODULES_DIR,
+	PI_CONFIG_DIR,
+	PLUGINS_DIR,
+	PROJECT_NODE_MODULES,
+	PROJECT_PI_DIR,
+	resolveScope,
+} from "@omp/paths";
+import { createPluginSymlinks, removePluginSymlinks } from "@omp/symlinks";
 import chalk from "chalk";
-import { loadPluginsJson, readPluginPackageJson } from "../manifest.js";
-import { npmUpdate } from "../npm.js";
-import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES } from "../paths.js";
-import { createPluginSymlinks, removePluginSymlinks } from "../symlinks.js";
 
 export interface UpdateOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -13,7 +23,7 @@ export interface UpdateOptions {
  * Update plugin(s) to latest within semver range
  */
 export async function updatePlugin(name?: string, options: UpdateOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
 	const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
 
@@ -22,12 +32,14 @@ export async function updatePlugin(name?: string, options: UpdateOptions = {}):
 
 	if (pluginNames.length === 0) {
 		console.log(chalk.yellow("No plugins installed."));
+		process.exitCode = 1;
 		return;
 	}
 
 	// If specific plugin name provided, verify it's installed
 	if (name && !pluginsJson.plugins[name]) {
 		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -50,6 +62,7 @@ export async function updatePlugin(name?: string, options: UpdateOptions = {}):
 
 	if (npmPlugins.length === 0) {
 		console.log(chalk.yellow("No npm plugins to update."));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -57,22 +70,35 @@ export async function updatePlugin(name?: string, options: UpdateOptions = {}):
 
 	const results: Array<{ name: string; from: string; to: string; success: boolean }> = [];
 
+	// Save old package info before removing symlinks (for recovery on failure)
+	const oldPkgJsons = new Map<string, PluginPackageJson>();
+	const beforeVersions: Record<string, string> = {};
+	const oldInstallEntries = new Map<string, OmpInstallEntry[]>();
+
 	try {
-		// Get current versions before update
-		const beforeVersions: Record<string, string> = {};
+		// Get current versions and install entries before update
 		for (const pluginName of npmPlugins) {
 			const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
 			if (pkgJson) {
+				oldPkgJsons.set(pluginName, pkgJson);
 				beforeVersions[pluginName] = pkgJson.version;
 
+				// Save old install entries for later comparison
+				if (pkgJson.omp?.install) {
+					oldInstallEntries.set(pluginName, [...pkgJson.omp.install]);
+				}
+
 				// Remove old symlinks before update
-				await removePluginSymlinks(pluginName, pkgJson, false);
+				await removePluginSymlinks(pluginName, pkgJson, isGlobal);
 			}
 		}
 
 		// npm update
 		await npmUpdate(npmPlugins, prefix);
 
+		// Base directory for symlink destinations
+		const baseDir = isGlobal ? PI_CONFIG_DIR : PROJECT_PI_DIR;
+
 		// Re-process symlinks for each updated plugin
 		for (const pluginName of npmPlugins) {
 			const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
@@ -80,7 +106,25 @@ export async function updatePlugin(name?: string, options: UpdateOptions = {}):
 				const beforeVersion = beforeVersions[pluginName] || "unknown";
 				const afterVersion = pkgJson.version;
 
-				// Create new symlinks
+				// Handle changed omp.install entries: remove orphaned symlinks
+				const oldEntries = oldInstallEntries.get(pluginName) || [];
+				const newEntries = pkgJson.omp?.install || [];
+				const newDests = new Set(newEntries.map((e) => e.dest));
+
+				for (const oldEntry of oldEntries) {
+					if (!newDests.has(oldEntry.dest)) {
+						// This destination was in the old version but not in the new one
+						const dest = join(baseDir, oldEntry.dest);
+						try {
+							await rm(dest, { force: true });
+							console.log(chalk.dim(`  Removed orphaned: ${oldEntry.dest}`));
+						} catch {
+							// Ignore removal errors for orphaned symlinks
+						}
+					}
+				}
+
+				// Create new symlinks (handles overwrites for existing destinations)
 				await createPluginSymlinks(pluginName, pkgJson, isGlobal);
 
 				const changed = beforeVersion !== afterVersion;
@@ -107,6 +151,20 @@ export async function updatePlugin(name?: string, options: UpdateOptions = {}):
 			console.log(JSON.stringify({ results }, null, 2));
 		}
 	} catch (err) {
+		// Restore old symlinks on failure
+		if (oldPkgJsons.size > 0) {
+			console.log(chalk.yellow("  Update failed, restoring symlinks..."));
+			for (const [pluginName, pkgJson] of oldPkgJsons) {
+				try {
+					await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+				} catch (restoreErr) {
+					console.log(
+						chalk.red(`  Failed to restore symlinks for ${pluginName}: ${(restoreErr as Error).message}`),
+					);
+				}
+			}
+		}
 		console.log(chalk.red(`Error updating plugins: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }