@oh-my-pi/cli 0.1.0 → 0.2.0

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

package/src/commands/why.ts

@@ -1,13 +1,14 @@
 import { existsSync, lstatSync } from "node:fs";
 import { readlink } from "node:fs/promises";
-import { join, relative } from "node:path";
+import { join, relative, resolve } from "node:path";
+import { getInstalledPlugins, getPluginSourceDir, readPluginPackageJson } from "@omp/manifest";
+import { PI_CONFIG_DIR, PROJECT_PI_DIR, resolveScope } from "@omp/paths";
+import { traceInstalledFile } from "@omp/symlinks";
 import chalk from "chalk";
-import { getInstalledPlugins, readPluginPackageJson } from "../manifest.js";
-import { PI_CONFIG_DIR } from "../paths.js";
-import { traceInstalledFile } from "../symlinks.js";
 
 export interface WhyOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -15,31 +16,45 @@ export interface WhyOptions {
  * Show which plugin installed a file
  */
 export async function whyFile(filePath: string, options: WhyOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 
-	// Normalize path - make it relative to PI_CONFIG_DIR if it's absolute
+	// Determine the base directory based on scope
+	const baseDir = isGlobal ? PI_CONFIG_DIR : resolve(PROJECT_PI_DIR);
+
+	// Normalize path - make it relative to the appropriate base directory
 	let relativePath = filePath;
-	if (filePath.startsWith(PI_CONFIG_DIR)) {
-		relativePath = relative(PI_CONFIG_DIR, filePath);
-	} else if (filePath.startsWith("~/.pi/")) {
-		relativePath = filePath.slice(6); // Remove ~/.pi/
+	if (isGlobal) {
+		if (filePath.startsWith(PI_CONFIG_DIR)) {
+			relativePath = relative(PI_CONFIG_DIR, filePath);
+		} else if (filePath.startsWith("~/.pi/")) {
+			relativePath = filePath.slice(6); // Remove ~/.pi/
+		}
+	} else {
+		// Project-local mode
+		const resolvedProjectDir = resolve(PROJECT_PI_DIR);
+		if (filePath.startsWith(resolvedProjectDir)) {
+			relativePath = relative(resolvedProjectDir, filePath);
+		} else if (filePath.startsWith(".pi/")) {
+			relativePath = filePath.slice(4); // Remove .pi/
+		}
 	}
 
 	// Check if it's a path in agent/ directory
 	if (!relativePath.startsWith("agent/")) {
 		// Try prepending agent/
 		const withAgent = `agent/${relativePath}`;
-		const fullWithAgent = join(PI_CONFIG_DIR, withAgent);
+		const fullWithAgent = join(baseDir, withAgent);
 		if (existsSync(fullWithAgent)) {
 			relativePath = withAgent;
 		}
 	}
 
-	const fullPath = join(PI_CONFIG_DIR, relativePath);
+	const fullPath = join(baseDir, relativePath);
 
 	// Check if file exists
 	if (!existsSync(fullPath)) {
 		console.log(chalk.yellow(`File not found: ${fullPath}`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -54,7 +69,7 @@ export async function whyFile(filePath: string, options: WhyOptions = {}): Promi
 
 	// Search through installed plugins
 	const installedPlugins = await getInstalledPlugins(isGlobal);
-	const result = await traceInstalledFile(relativePath, installedPlugins);
+	const result = await traceInstalledFile(relativePath, installedPlugins, isGlobal);
 
 	if (options.json) {
 		console.log(
@@ -85,9 +100,25 @@ export async function whyFile(filePath: string, options: WhyOptions = {}): Promi
 	}
 
 	if (result) {
-		console.log(chalk.green(`✓ Installed by: ${result.plugin}`));
-		console.log(chalk.dim(`  Source: ${result.entry.src}`));
-		console.log(chalk.dim(`  Dest: ${result.entry.dest}`));
+		// Verify it's actually a symlink pointing to the right place
+		if (!isSymlink) {
+			console.log(chalk.yellow("⚠ This file exists but is not a symlink"));
+			console.log(chalk.dim("  It may have been manually created or the symlink was replaced."));
+			console.log(chalk.dim(`  Expected to be installed by: ${result.plugin}`));
+		} else {
+			// Verify symlink points to correct source
+			const expectedSrc = join(getPluginSourceDir(result.plugin, isGlobal), result.entry.src);
+			if (target !== expectedSrc) {
+				console.log(chalk.yellow("⚠ Symlink target does not match expected source"));
+				console.log(chalk.dim(`  Expected: ${expectedSrc}`));
+				console.log(chalk.dim(`  Actual: ${target}`));
+				console.log(chalk.dim(`  Expected to be installed by: ${result.plugin}`));
+			} else {
+				console.log(chalk.green(`✓ Installed by: ${result.plugin}`));
+				console.log(chalk.dim(`  Source: ${result.entry.src}`));
+				console.log(chalk.dim(`  Dest: ${result.entry.dest}`));
+			}
+		}
 
 		// Get plugin info
 		const pkgJson = await readPluginPackageJson(result.plugin, isGlobal);

package/src/conflicts.ts

@@ -1,10 +1,42 @@
-import type { PluginPackageJson } from "./manifest.js";
+import type { PluginPackageJson } from "@omp/manifest";
 
 export interface Conflict {
 	dest: string;
 	plugins: Array<{ name: string; src: string }>;
 }
 
+export interface IntraPluginDuplicate {
+	dest: string;
+	sources: string[];
+}
+
+/**
+ * Detect duplicate destinations within a single plugin's omp.install array
+ */
+export function detectIntraPluginDuplicates(pkgJson: PluginPackageJson): IntraPluginDuplicate[] {
+	const duplicates: IntraPluginDuplicate[] = [];
+
+	if (!pkgJson.omp?.install?.length) {
+		return duplicates;
+	}
+
+	const destMap = new Map<string, string[]>();
+
+	for (const entry of pkgJson.omp.install) {
+		const sources = destMap.get(entry.dest) || [];
+		sources.push(entry.src);
+		destMap.set(entry.dest, sources);
+	}
+
+	for (const [dest, sources] of destMap) {
+		if (sources.length > 1) {
+			duplicates.push({ dest, sources });
+		}
+	}
+
+	return duplicates;
+}
+
 /**
  * Detect conflicts between a new plugin and existing plugins
  */

package/src/errors.ts

@@ -0,0 +1,22 @@
+import chalk from "chalk";
+
+/**
+ * Wraps a command function with consistent error handling.
+ * - Catches errors and logs user-friendly messages
+ * - Shows stack trace only when DEBUG env var is set
+ * - Sets non-zero exit code on error
+ */
+export function withErrorHandling<T extends (...args: any[]) => Promise<void>>(fn: T): T {
+	return (async (...args: any[]) => {
+		try {
+			await fn(...args);
+		} catch (err) {
+			const error = err as Error;
+			console.log(chalk.red(`Error: ${error.message}`));
+			if (process.env.DEBUG) {
+				console.log(chalk.dim(error.stack));
+			}
+			process.exitCode = 1;
+		}
+	}) as T;
+}

package/src/index.ts

@@ -1,43 +1,37 @@
-// Core commands
-
-export { createPlugin } from "./commands/create.js";
-export { runDoctor } from "./commands/doctor.js";
-export { disablePlugin, enablePlugin } from "./commands/enable.js";
-export { showInfo } from "./commands/info.js";
-// New commands
-export { initProject } from "./commands/init.js";
-export { installPlugin } from "./commands/install.js";
-export { linkPlugin } from "./commands/link.js";
-export { listPlugins } from "./commands/list.js";
-export { showOutdated } from "./commands/outdated.js";
-export { searchPlugins } from "./commands/search.js";
-export { uninstallPlugin } from "./commands/uninstall.js";
-export { updatePlugin } from "./commands/update.js";
-export { whyFile } from "./commands/why.js";
+export { createPlugin } from "@omp/commands/create";
+export { runDoctor } from "@omp/commands/doctor";
+export { disablePlugin, enablePlugin } from "@omp/commands/enable";
+export { showInfo } from "@omp/commands/info";
+export { initProject } from "@omp/commands/init";
+export { installPlugin } from "@omp/commands/install";
+export { linkPlugin } from "@omp/commands/link";
+export { listPlugins } from "@omp/commands/list";
+export { showOutdated } from "@omp/commands/outdated";
+export { searchPlugins } from "@omp/commands/search";
+export { uninstallPlugin } from "@omp/commands/uninstall";
+export { updatePlugin } from "@omp/commands/update";
+export { whyFile } from "@omp/commands/why";
 export {
 	detectAllConflicts,
 	detectConflicts,
 	formatConflicts,
-} from "./conflicts.js";
+} from "@omp/conflicts";
 
-// Types
 export type {
 	OmpField,
 	OmpInstallEntry,
 	PluginPackageJson,
 	PluginsJson,
-} from "./manifest.js";
+} from "@omp/manifest";
 
-// Utilities
 export {
 	getInstalledPlugins,
 	initGlobalPlugins,
 	loadPluginsJson,
 	readPluginPackageJson,
 	savePluginsJson,
-} from "./manifest.js";
-// Migration
-export { checkMigration, migrateToNpm } from "./migrate.js";
+} from "@omp/manifest";
+export { checkMigration, migrateToNpm } from "@omp/migrate";
 export {
 	npmInfo,
 	npmInstall,
@@ -45,9 +39,9 @@ export {
 	npmSearch,
 	npmUninstall,
 	npmUpdate,
-} from "./npm.js";
+} from "@omp/npm";
 export {
 	checkPluginSymlinks,
 	createPluginSymlinks,
 	removePluginSymlinks,
-} from "./symlinks.js";
+} from "@omp/symlinks";

package/src/lock.ts

@@ -0,0 +1,46 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { PI_CONFIG_DIR, PROJECT_PI_DIR } from "@omp/paths";
+
+const LOCK_TIMEOUT_MS = 60000; // 1 minute
+
+export async function acquireLock(global = true): Promise<boolean> {
+	const lockPath = global ? join(PI_CONFIG_DIR, ".lock") : join(PROJECT_PI_DIR, ".lock");
+
+	try {
+		await mkdir(dirname(lockPath), { recursive: true });
+
+		// Check for existing lock
+		if (existsSync(lockPath)) {
+			const content = await readFile(lockPath, "utf-8");
+			const { pid, timestamp } = JSON.parse(content);
+
+			// Check if stale (older than timeout)
+			if (Date.now() - timestamp > LOCK_TIMEOUT_MS) {
+				// Stale lock, remove it
+				await rm(lockPath, { force: true });
+			} else {
+				// Check if process is still alive
+				try {
+					process.kill(pid, 0); // Signal 0 = check existence
+					return false; // Process alive, can't acquire
+				} catch {
+					// Process dead, remove stale lock
+					await rm(lockPath, { force: true });
+				}
+			}
+		}
+
+		// Create lock
+		await writeFile(lockPath, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+export async function releaseLock(global = true): Promise<void> {
+	const lockPath = global ? join(PI_CONFIG_DIR, ".lock") : join(PROJECT_PI_DIR, ".lock");
+	await rm(lockPath, { force: true });
+}