@oh-my-pi/cli 0.3.0 → 0.5.0

package/src/commands/update.ts

@@ -1,170 +0,0 @@
-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";
-
-export interface UpdateOptions {
-	global?: boolean;
-	local?: boolean;
-	json?: boolean;
-}
-
-/**
- * Update plugin(s) to latest within semver range
- */
-export async function updatePlugin(name?: string, options: UpdateOptions = {}): Promise<void> {
-	const isGlobal = resolveScope(options);
-	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."));
-		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;
-	}
-
-	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."));
-		process.exitCode = 1;
-		return;
-	}
-
-	console.log(chalk.blue(`Updating ${npmPlugins.length} plugin(s)...`));
-
-	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 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, 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);
-			if (pkgJson) {
-				const beforeVersion = beforeVersions[pluginName] || "unknown";
-				const afterVersion = pkgJson.version;
-
-				// 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;
-				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) {
-		// 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,136 +0,0 @@
-import { existsSync, lstatSync } from "node:fs";
-import { readlink } from "node:fs/promises";
-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";
-
-export interface WhyOptions {
-	global?: boolean;
-	local?: boolean;
-	json?: boolean;
-}
-
-/**
- * Show which plugin installed a file
- */
-export async function whyFile(filePath: string, options: WhyOptions = {}): Promise<void> {
-	const isGlobal = resolveScope(options);
-
-	// 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 (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(baseDir, withAgent);
-		if (existsSync(fullWithAgent)) {
-			relativePath = withAgent;
-		}
-	}
-
-	const fullPath = join(baseDir, relativePath);
-
-	// Check if file exists
-	if (!existsSync(fullPath)) {
-		console.log(chalk.yellow(`File not found: ${fullPath}`));
-		process.exitCode = 1;
-		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, isGlobal);
-
-	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) {
-		// 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);
-		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

@@ -1,116 +0,0 @@
-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
- */
-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/errors.ts

@@ -1,22 +0,0 @@
-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,46 +0,0 @@
-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 "@omp/conflicts";
-
-export type {
-	OmpField,
-	OmpInstallEntry,
-	PluginPackageJson,
-	PluginsJson,
-} from "@omp/manifest";
-
-export {
-	getInstalledPlugins,
-	initGlobalPlugins,
-	loadPluginsJson,
-	readPluginPackageJson,
-	savePluginsJson,
-} from "@omp/manifest";
-export {
-	npmInfo,
-	npmInstall,
-	npmOutdated,
-	npmSearch,
-	npmUninstall,
-	npmUpdate,
-} from "@omp/npm";
-export {
-	checkPluginSymlinks,
-	createPluginSymlinks,
-	removePluginSymlinks,
-} from "@omp/symlinks";

package/src/lock.ts

@@ -1,46 +0,0 @@
-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 });
-}

package/src/lockfile.ts

@@ -1,132 +0,0 @@
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-import { GLOBAL_LOCK_FILE, PROJECT_PLUGINS_LOCK } from "@omp/paths";
-import chalk from "chalk";
-
-/**
- * Lock file schema version
- */
-export const LOCKFILE_VERSION = 1;
-
-/**
- * Package entry in the lock file
- */
-export interface LockFilePackage {
-	version: string;
-	resolved?: string;
-	integrity?: string;
-	dependencies?: Record<string, string>;
-}
-
-/**
- * Lock file structure
- */
-export interface LockFile {
-	lockfileVersion: number;
-	packages: Record<string, LockFilePackage>;
-}
-
-/**
- * Load and validate a lock file.
- *
- * Returns null if:
- * - File doesn't exist
- * - File contains invalid JSON (corrupted)
- * - File has invalid/incompatible schema
- */
-export async function loadLockFile(global = true): Promise<LockFile | null> {
-	const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
-	try {
-		if (!existsSync(path)) return null;
-		const data = await readFile(path, "utf-8");
-		const parsed = JSON.parse(data);
-
-		// Validate schema
-		if (typeof parsed.lockfileVersion !== "number" || typeof parsed.packages !== "object") {
-			console.log(chalk.yellow(`Warning: ${path} has invalid schema, ignoring`));
-			return null;
-		}
-
-		// Check for incompatible version
-		if (parsed.lockfileVersion > LOCKFILE_VERSION) {
-			console.log(
-				chalk.yellow(
-					`Warning: ${path} was created by a newer version of omp (lockfile v${parsed.lockfileVersion}), ignoring`,
-				),
-			);
-			return null;
-		}
-
-		return parsed as LockFile;
-	} catch (err) {
-		if ((err as Error).name === "SyntaxError") {
-			console.log(chalk.yellow(`Warning: ${path} is corrupted (invalid JSON), ignoring`));
-		}
-		return null;
-	}
-}
-
-/**
- * Save lock file
- */
-export async function saveLockFile(lockFile: LockFile, global = true): Promise<void> {
-	const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
-	await writeFile(path, JSON.stringify(lockFile, null, 2));
-}
-
-/**
- * Create a new empty lock file
- */
-export function createLockFile(): LockFile {
-	return {
-		lockfileVersion: LOCKFILE_VERSION,
-		packages: {},
-	};
-}
-
-/**
- * Validate and optionally regenerate a corrupted lock file.
- *
- * @returns The loaded lock file, a new empty lock file if corrupted/missing, or null if validation fails
- */
-export async function validateOrRegenerateLockFile(global = true): Promise<LockFile> {
-	const existing = await loadLockFile(global);
-	if (existing) {
-		return existing;
-	}
-
-	// Lock file is missing or corrupted - create a fresh one
-	const path = global ? GLOBAL_LOCK_FILE : PROJECT_PLUGINS_LOCK;
-	if (existsSync(path)) {
-		console.log(chalk.yellow(`Regenerating corrupted lock file: ${path}`));
-	}
-
-	return createLockFile();
-}
-
-/**
- * Get the locked version for a package, if it exists in the lock file.
- */
-export async function getLockedVersion(packageName: string, global = true): Promise<string | null> {
-	const lockFile = await loadLockFile(global);
-	if (!lockFile) return null;
-
-	const entry = lockFile.packages[packageName];
-	return entry?.version ?? null;
-}
-
-/**
- * Update the lock file with a package's exact version.
- */
-export async function updateLockFile(packageName: string, version: string, global = true): Promise<void> {
-	let lockFile = await loadLockFile(global);
-	if (!lockFile) {
-		lockFile = createLockFile();
-	}
-
-	lockFile.packages[packageName] = {
-		version,
-	};
-
-	await saveLockFile(lockFile, global);
-}