@oh-my-pi/cli 0.1.0 → 0.3.0

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,36 @@
-// 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 {
 	npmInfo,
 	npmInstall,
@@ -45,9 +38,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 });
+}

package/src/lockfile.ts

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