@oh-my-pi/cli 0.1.0

package/src/commands/list.ts

@@ -0,0 +1,71 @@
+import chalk from "chalk";
+import { loadPluginsJson, readPluginPackageJson } from "../manifest.js";
+
+export interface ListOptions {
+	global?: boolean;
+	json?: boolean;
+}
+
+/**
+ * List all installed plugins
+ */
+export async function listPlugins(options: ListOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+	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>"));
+		return;
+	}
+
+	if (options.json) {
+		const plugins: Record<string, unknown> = {};
+		for (const name of pluginNames) {
+			const pkgJson = await readPluginPackageJson(name, isGlobal);
+			const disabled = pluginsJson.disabled?.includes(name) || false;
+			plugins[name] = {
+				version: pkgJson?.version || pluginsJson.plugins[name],
+				description: pkgJson?.description,
+				disabled,
+				files: pkgJson?.omp?.install?.map((e) => e.dest) || [],
+			};
+		}
+		console.log(JSON.stringify({ plugins }, null, 2));
+		return;
+	}
+
+	const location = isGlobal ? "~/.pi/plugins" : ".pi";
+	console.log(chalk.bold(`Installed plugins (${pluginNames.length}) [${location}]:\n`));
+
+	for (const name of pluginNames.sort()) {
+		const pkgJson = await readPluginPackageJson(name, isGlobal);
+		const specifier = pluginsJson.plugins[name];
+		const isLocal = specifier.startsWith("file:");
+		const disabled = pluginsJson.disabled?.includes(name);
+
+		const version = pkgJson?.version ? chalk.dim(` v${pkgJson.version}`) : "";
+		const localBadge = isLocal ? chalk.cyan(" (local)") : "";
+		const disabledBadge = disabled ? chalk.yellow(" (disabled)") : "";
+		const icon = disabled ? chalk.gray("○") : chalk.green("◆");
+
+		console.log(`${icon} ${chalk.bold(name)}${version}${localBadge}${disabledBadge}`);
+
+		if (pkgJson?.description) {
+			console.log(chalk.dim(`    ${pkgJson.description}`));
+		}
+
+		if (isLocal) {
+			const localPath = specifier.replace("file:", "");
+			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(", ")}`));
+		}
+
+		console.log();
+	}
+}

package/src/commands/outdated.ts

@@ -0,0 +1,76 @@
+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;
+	json?: boolean;
+}
+
+/**
+ * List plugins with newer versions available
+ */
+export async function showOutdated(options: OutdatedOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
+
+	console.log(chalk.blue("Checking for outdated plugins..."));
+
+	try {
+		const outdated = await npmOutdated(prefix);
+		const pluginsJson = await loadPluginsJson(isGlobal);
+
+		// Filter to only show plugins we manage
+		const managedOutdated = Object.entries(outdated).filter(([name]) => {
+			return pluginsJson.plugins[name] !== undefined;
+		});
+
+		if (managedOutdated.length === 0) {
+			console.log(chalk.green("\n✓ All plugins are up to date!"));
+			return;
+		}
+
+		if (options.json) {
+			const result = Object.fromEntries(managedOutdated);
+			console.log(JSON.stringify({ outdated: result }, null, 2));
+			return;
+		}
+
+		console.log(chalk.bold(`\nOutdated plugins (${managedOutdated.length}):\n`));
+
+		// Header
+		console.log(
+			chalk.dim("  Package".padEnd(30)) +
+				chalk.dim("Current".padEnd(15)) +
+				chalk.dim("Wanted".padEnd(15)) +
+				chalk.dim("Latest"),
+		);
+
+		for (const [name, versions] of managedOutdated) {
+			const current = versions.current || "?";
+			const wanted = versions.wanted || "?";
+			const latest = versions.latest || "?";
+
+			const hasMinorUpdate = wanted !== current;
+			const hasMajorUpdate = latest !== wanted;
+
+			const wantedColor = hasMinorUpdate ? chalk.yellow : chalk.dim;
+			const latestColor = hasMajorUpdate ? chalk.red : wantedColor;
+
+			console.log(
+				`  ${chalk.white(name.padEnd(28))}` +
+					`${chalk.dim(current.padEnd(15))}` +
+					`${wantedColor(wanted.padEnd(15))}` +
+					`${latestColor(latest)}`,
+			);
+		}
+
+		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}`));
+	}
+}

package/src/commands/search.ts

@@ -0,0 +1,60 @@
+import chalk from "chalk";
+import { npmSearch } from "../npm.js";
+
+export interface SearchOptions {
+	json?: boolean;
+	limit?: number;
+}
+
+/**
+ * Search npm for plugins with omp-plugin keyword
+ */
+export async function searchPlugins(query: string, options: SearchOptions = {}): Promise<void> {
+	console.log(chalk.blue(`Searching npm for "${query}" with omp-plugin keyword...`));
+
+	try {
+		const results = await npmSearch(query, "omp-plugin");
+
+		if (results.length === 0) {
+			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"));
+			return;
+		}
+
+		const limit = options.limit || 20;
+		const displayResults = results.slice(0, limit);
+
+		if (options.json) {
+			console.log(JSON.stringify({ results: displayResults }, null, 2));
+			return;
+		}
+
+		console.log(chalk.bold(`\nFound ${results.length} plugin(s):\n`));
+
+		for (const result of displayResults) {
+			console.log(chalk.green("◆ ") + chalk.bold(result.name) + chalk.dim(` v${result.version}`));
+
+			if (result.description) {
+				console.log(chalk.dim(`    ${result.description}`));
+			}
+
+			if (result.keywords?.length) {
+				const otherKeywords = result.keywords.filter((k) => k !== "omp-plugin");
+				if (otherKeywords.length > 0) {
+					console.log(chalk.dim(`    tags: ${otherKeywords.join(", ")}`));
+				}
+			}
+
+			console.log();
+		}
+
+		if (results.length > limit) {
+			console.log(chalk.dim(`... and ${results.length - limit} more. Use --limit to see more.`));
+		}
+
+		console.log(chalk.dim("Install with: omp install <package-name>"));
+	} catch (err) {
+		console.log(chalk.red(`Error searching: ${(err as Error).message}`));
+	}
+}

package/src/commands/uninstall.ts

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+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;
+	json?: boolean;
+}
+
+/**
+ * Uninstall a plugin
+ */
+export async function uninstallPlugin(name: string, options: UninstallOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false; // Default to global
+	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
+	const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
+
+	// Check if plugin is installed
+	const pluginsJson = await loadPluginsJson(isGlobal);
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		return;
+	}
+
+	try {
+		console.log(chalk.blue(`Uninstalling ${name}...`));
+
+		// 1. Read package.json for omp.install entries before uninstalling
+		const pkgJson = await readPluginPackageJson(name, isGlobal);
+
+		// 2. Remove symlinks
+		if (pkgJson) {
+			await removePluginSymlinks(name, pkgJson);
+		}
+
+		// 3. npm uninstall
+		try {
+			await npmUninstall([name], prefix);
+		} catch (_err) {
+			// Package might have been installed via file: protocol
+			// Try to remove manually from node_modules
+			const pluginDir = join(nodeModules, name);
+			if (existsSync(pluginDir)) {
+				await rm(pluginDir, { recursive: true, force: true });
+			}
+		}
+
+		// 4. Update plugins.json/package.json
+		delete pluginsJson.plugins[name];
+		// Also remove from disabled list if present
+		if (pluginsJson.disabled) {
+			pluginsJson.disabled = pluginsJson.disabled.filter((n) => n !== name);
+		}
+		await savePluginsJson(pluginsJson, isGlobal);
+
+		console.log(chalk.green(`✓ Uninstalled "${name}"`));
+
+		if (options.json) {
+			console.log(JSON.stringify({ name, success: true }, null, 2));
+		}
+	} catch (err) {
+		console.log(chalk.red(`Error uninstalling plugin: ${(err as Error).message}`));
+
+		if (options.json) {
+			console.log(JSON.stringify({ name, success: false, error: (err as Error).message }, null, 2));
+		}
+	}
+}

package/src/commands/update.ts

@@ -0,0 +1,112 @@
+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;
+	json?: boolean;
+}
+
+/**
+ * Update plugin(s) to latest within semver range
+ */
+export async function updatePlugin(name?: string, options: UpdateOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+	const prefix = isGlobal ? PLUGINS_DIR : ".pi";
+	const _nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
+
+	const pluginsJson = await loadPluginsJson(isGlobal);
+	const pluginNames = Object.keys(pluginsJson.plugins);
+
+	if (pluginNames.length === 0) {
+		console.log(chalk.yellow("No plugins installed."));
+		return;
+	}
+
+	// If specific plugin name provided, verify it's installed
+	if (name && !pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		return;
+	}
+
+	const toUpdate = name ? [name] : pluginNames;
+
+	// Filter out file: dependencies (local plugins)
+	const npmPlugins = toUpdate.filter((n) => {
+		const version = pluginsJson.plugins[n];
+		return !version.startsWith("file:");
+	});
+
+	const localPlugins = toUpdate.filter((n) => {
+		const version = pluginsJson.plugins[n];
+		return version.startsWith("file:");
+	});
+
+	if (localPlugins.length > 0) {
+		console.log(chalk.dim(`Skipping ${localPlugins.length} local plugin(s): ${localPlugins.join(", ")}`));
+	}
+
+	if (npmPlugins.length === 0) {
+		console.log(chalk.yellow("No npm plugins to update."));
+		return;
+	}
+
+	console.log(chalk.blue(`Updating ${npmPlugins.length} plugin(s)...`));
+
+	const results: Array<{ name: string; from: string; to: string; success: boolean }> = [];
+
+	try {
+		// Get current versions before update
+		const beforeVersions: Record<string, string> = {};
+		for (const pluginName of npmPlugins) {
+			const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
+			if (pkgJson) {
+				beforeVersions[pluginName] = pkgJson.version;
+
+				// Remove old symlinks before update
+				await removePluginSymlinks(pluginName, pkgJson, false);
+			}
+		}
+
+		// npm update
+		await npmUpdate(npmPlugins, prefix);
+
+		// Re-process symlinks for each updated plugin
+		for (const pluginName of npmPlugins) {
+			const pkgJson = await readPluginPackageJson(pluginName, isGlobal);
+			if (pkgJson) {
+				const beforeVersion = beforeVersions[pluginName] || "unknown";
+				const afterVersion = pkgJson.version;
+
+				// Create new symlinks
+				await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+
+				const changed = beforeVersion !== afterVersion;
+				if (changed) {
+					console.log(chalk.green(`  ✓ ${pluginName}: ${beforeVersion} → ${afterVersion}`));
+				} else {
+					console.log(chalk.dim(`  · ${pluginName}: ${afterVersion} (already latest)`));
+				}
+
+				results.push({
+					name: pluginName,
+					from: beforeVersion,
+					to: afterVersion,
+					success: true,
+				});
+			}
+		}
+
+		const updated = results.filter((r) => r.from !== r.to);
+		console.log();
+		console.log(chalk.dim(`Updated: ${updated.length}, Already latest: ${results.length - updated.length}`));
+
+		if (options.json) {
+			console.log(JSON.stringify({ results }, null, 2));
+		}
+	} catch (err) {
+		console.log(chalk.red(`Error updating plugins: ${(err as Error).message}`));
+	}
+}

package/src/commands/why.ts

@@ -0,0 +1,105 @@
+import { existsSync, lstatSync } from "node:fs";
+import { readlink } from "node:fs/promises";
+import { join, relative } from "node:path";
+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;
+	json?: boolean;
+}
+
+/**
+ * Show which plugin installed a file
+ */
+export async function whyFile(filePath: string, options: WhyOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+
+	// Normalize path - make it relative to PI_CONFIG_DIR if it's absolute
+	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/
+	}
+
+	// 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);
+		if (existsSync(fullWithAgent)) {
+			relativePath = withAgent;
+		}
+	}
+
+	const fullPath = join(PI_CONFIG_DIR, relativePath);
+
+	// Check if file exists
+	if (!existsSync(fullPath)) {
+		console.log(chalk.yellow(`File not found: ${fullPath}`));
+		return;
+	}
+
+	// Check if it's a symlink
+	const stats = lstatSync(fullPath);
+	const isSymlink = stats.isSymbolicLink();
+
+	let target: string | null = null;
+	if (isSymlink) {
+		target = await readlink(fullPath);
+	}
+
+	// Search through installed plugins
+	const installedPlugins = await getInstalledPlugins(isGlobal);
+	const result = await traceInstalledFile(relativePath, installedPlugins);
+
+	if (options.json) {
+		console.log(
+			JSON.stringify(
+				{
+					path: relativePath,
+					fullPath,
+					isSymlink,
+					target,
+					plugin: result?.plugin || null,
+					source: result?.entry.src || null,
+				},
+				null,
+				2,
+			),
+		);
+		return;
+	}
+
+	console.log(chalk.bold(`File: ${relativePath}`));
+	console.log(chalk.dim(`Full path: ${fullPath}`));
+	console.log();
+
+	if (isSymlink && target) {
+		console.log(`${chalk.dim("Type: ")}symlink`);
+		console.log(chalk.dim("Target: ") + target);
+		console.log();
+	}
+
+	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}`));
+
+		// Get plugin info
+		const pkgJson = await readPluginPackageJson(result.plugin, isGlobal);
+		if (pkgJson) {
+			console.log();
+			console.log(chalk.dim(`Plugin version: ${pkgJson.version}`));
+			if (pkgJson.description) {
+				console.log(chalk.dim(`Description: ${pkgJson.description}`));
+			}
+		}
+	} else {
+		console.log(chalk.yellow("⚠ Not installed by any tracked plugin"));
+		console.log(chalk.dim("  This file may have been created manually or by a plugin that was uninstalled."));
+	}
+}

package/src/conflicts.ts

@@ -0,0 +1,84 @@
+import type { PluginPackageJson } from "./manifest.js";
+
+export interface Conflict {
+	dest: string;
+	plugins: Array<{ name: string; src: string }>;
+}
+
+/**
+ * Detect conflicts between a new plugin and existing plugins
+ */
+export function detectConflicts(
+	newPluginName: string,
+	newPkgJson: PluginPackageJson,
+	existingPlugins: Map<string, PluginPackageJson>,
+): Conflict[] {
+	const conflicts: Conflict[] = [];
+
+	if (!newPkgJson.omp?.install?.length) {
+		return conflicts;
+	}
+
+	// Build a map of existing destinations
+	const destMap = new Map<string, Array<{ name: string; src: string }>>();
+
+	for (const [name, pkgJson] of existingPlugins) {
+		if (pkgJson.omp?.install) {
+			for (const entry of pkgJson.omp.install) {
+				const existing = destMap.get(entry.dest) || [];
+				existing.push({ name, src: entry.src });
+				destMap.set(entry.dest, existing);
+			}
+		}
+	}
+
+	// Check new plugin's destinations
+	for (const entry of newPkgJson.omp.install) {
+		const existing = destMap.get(entry.dest);
+		if (existing && existing.length > 0) {
+			conflicts.push({
+				dest: entry.dest,
+				plugins: [...existing, { name: newPluginName, src: entry.src }],
+			});
+		}
+	}
+
+	return conflicts;
+}
+
+/**
+ * Detect all conflicts among a set of plugins
+ */
+export function detectAllConflicts(plugins: Map<string, PluginPackageJson>): Conflict[] {
+	const conflicts: Conflict[] = [];
+	const destMap = new Map<string, Array<{ name: string; src: string }>>();
+
+	for (const [name, pkgJson] of plugins) {
+		if (pkgJson.omp?.install) {
+			for (const entry of pkgJson.omp.install) {
+				const existing = destMap.get(entry.dest) || [];
+				existing.push({ name, src: entry.src });
+				destMap.set(entry.dest, existing);
+			}
+		}
+	}
+
+	// Find destinations with multiple sources
+	for (const [dest, sources] of destMap) {
+		if (sources.length > 1) {
+			conflicts.push({ dest, plugins: sources });
+		}
+	}
+
+	return conflicts;
+}
+
+/**
+ * Format conflicts for display
+ */
+export function formatConflicts(conflicts: Conflict[]): string[] {
+	return conflicts.map((conflict) => {
+		const plugins = conflict.plugins.map((p) => p.name).join(" and ");
+		return `${plugins} both install ${conflict.dest}`;
+	});
+}

package/src/index.ts

@@ -0,0 +1,53 @@
+// 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 {
+	detectAllConflicts,
+	detectConflicts,
+	formatConflicts,
+} from "./conflicts.js";
+
+// Types
+export type {
+	OmpField,
+	OmpInstallEntry,
+	PluginPackageJson,
+	PluginsJson,
+} from "./manifest.js";
+
+// Utilities
+export {
+	getInstalledPlugins,
+	initGlobalPlugins,
+	loadPluginsJson,
+	readPluginPackageJson,
+	savePluginsJson,
+} from "./manifest.js";
+// Migration
+export { checkMigration, migrateToNpm } from "./migrate.js";
+export {
+	npmInfo,
+	npmInstall,
+	npmOutdated,
+	npmSearch,
+	npmUninstall,
+	npmUpdate,
+} from "./npm.js";
+export {
+	checkPluginSymlinks,
+	createPluginSymlinks,
+	removePluginSymlinks,
+} from "./symlinks.js";