@oh-my-pi/cli 0.1.0 → 0.3.0

package/src/commands/enable.ts

@@ -1,9 +1,11 @@
+import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "@omp/manifest";
+import { resolveScope } from "@omp/paths";
+import { checkPluginSymlinks, createPluginSymlinks, removePluginSymlinks } from "@omp/symlinks";
 import chalk from "chalk";
-import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "../manifest.js";
-import { createPluginSymlinks, removePluginSymlinks } from "../symlinks.js";
 
 export interface EnableDisableOptions {
 	global?: boolean;
+	local?: boolean;
 	json?: boolean;
 }
 
@@ -11,19 +13,21 @@ export interface EnableDisableOptions {
  * Enable a disabled plugin (re-create symlinks)
  */
 export async function enablePlugin(name: string, options: EnableDisableOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 
 	const pluginsJson = await loadPluginsJson(isGlobal);
 
 	// Check if plugin exists
 	if (!pluginsJson.plugins[name]) {
 		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
 		return;
 	}
 
 	// Check if already enabled
 	if (!pluginsJson.disabled?.includes(name)) {
 		console.log(chalk.yellow(`Plugin "${name}" is already enabled.`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -32,12 +36,20 @@ export async function enablePlugin(name: string, options: EnableDisableOptions =
 		const pkgJson = await readPluginPackageJson(name, isGlobal);
 		if (!pkgJson) {
 			console.log(chalk.red(`Could not read package.json for ${name}`));
+			process.exitCode = 1;
 			return;
 		}
 
-		// Re-create symlinks
-		console.log(chalk.blue(`Enabling ${name}...`));
-		await createPluginSymlinks(name, pkgJson, isGlobal);
+		// Check if symlinks are already in place
+		const symlinkStatus = await checkPluginSymlinks(name, pkgJson, isGlobal);
+
+		if (symlinkStatus.valid.length > 0 && symlinkStatus.broken.length === 0 && symlinkStatus.missing.length === 0) {
+			console.log(chalk.yellow(`Plugin "${name}" symlinks are already in place.`));
+		} else {
+			// Re-create symlinks
+			console.log(chalk.blue(`Enabling ${name}...`));
+			await createPluginSymlinks(name, pkgJson, isGlobal);
+		}
 
 		// Remove from disabled list
 		pluginsJson.disabled = pluginsJson.disabled.filter((n) => n !== name);
@@ -50,6 +62,7 @@ export async function enablePlugin(name: string, options: EnableDisableOptions =
 		}
 	} catch (err) {
 		console.log(chalk.red(`Error enabling plugin: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }
 
@@ -57,19 +70,21 @@ export async function enablePlugin(name: string, options: EnableDisableOptions =
  * Disable a plugin (remove symlinks but keep installed)
  */
 export async function disablePlugin(name: string, options: EnableDisableOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 
 	const pluginsJson = await loadPluginsJson(isGlobal);
 
 	// Check if plugin exists
 	if (!pluginsJson.plugins[name]) {
 		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
 		return;
 	}
 
 	// Check if already disabled
 	if (pluginsJson.disabled?.includes(name)) {
 		console.log(chalk.yellow(`Plugin "${name}" is already disabled.`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -78,12 +93,13 @@ export async function disablePlugin(name: string, options: EnableDisableOptions
 		const pkgJson = await readPluginPackageJson(name, isGlobal);
 		if (!pkgJson) {
 			console.log(chalk.red(`Could not read package.json for ${name}`));
+			process.exitCode = 1;
 			return;
 		}
 
 		// Remove symlinks
 		console.log(chalk.blue(`Disabling ${name}...`));
-		await removePluginSymlinks(name, pkgJson);
+		await removePluginSymlinks(name, pkgJson, isGlobal);
 
 		// Add to disabled list
 		if (!pluginsJson.disabled) {
@@ -101,5 +117,6 @@ export async function disablePlugin(name: string, options: EnableDisableOptions
 		}
 	} catch (err) {
 		console.log(chalk.red(`Error disabling plugin: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }

package/src/commands/env.ts

@@ -0,0 +1,38 @@
+import { resolveScope } from "@omp/paths";
+import { generateEnvScript, getEnvJson } from "@omp/runtime";
+import chalk from "chalk";
+
+export interface EnvOptions {
+	global?: boolean;
+	local?: boolean;
+	json?: boolean;
+	fish?: boolean;
+}
+
+/**
+ * Output environment variables for plugins
+ * omp env                     # Print shell exports (sh/bash/zsh)
+ * omp env --fish              # Print fish shell syntax
+ * omp env --json              # Print as JSON
+ */
+export async function envCommand(options: EnvOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+
+	if (options.json) {
+		const vars = await getEnvJson(isGlobal);
+		console.log(JSON.stringify(vars, null, 2));
+		return;
+	}
+
+	const shell = options.fish ? "fish" : "sh";
+	const script = await generateEnvScript(isGlobal, shell);
+
+	if (script.length === 0) {
+		console.error(chalk.yellow("No environment variables configured."));
+		console.error(chalk.dim("Set variables with: omp config <plugin> <variable> <value>"));
+		return;
+	}
+
+	// Output script directly (for eval or sourcing)
+	console.log(script);
+}

package/src/commands/features.ts

@@ -0,0 +1,295 @@
+import { checkbox } from "@inquirer/prompts";
+import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "@omp/manifest";
+import { resolveScope } from "@omp/paths";
+import { getDefaultFeatures, getRuntimeConfigPath, readRuntimeConfig, writeRuntimeConfig } from "@omp/symlinks";
+import chalk from "chalk";
+
+export interface FeaturesOptions {
+	global?: boolean;
+	local?: boolean;
+	json?: boolean;
+	enable?: string[];
+	disable?: string[];
+	set?: string;
+}
+
+/**
+ * Interactive feature selection for a plugin
+ * omp features @oh-my-pi/exa
+ */
+export async function interactiveFeatures(name: string, options: FeaturesOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	// Check if plugin exists
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const pkgJson = await readPluginPackageJson(name, isGlobal);
+	if (!pkgJson) {
+		console.log(chalk.red(`Could not read package.json for ${name}`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const features = pkgJson.omp?.features;
+	if (!features || Object.keys(features).length === 0) {
+		console.log(chalk.yellow(`Plugin "${name}" has no configurable features.`));
+		return;
+	}
+
+	// Get runtime config path and current enabled features
+	const runtimePath = getRuntimeConfigPath(pkgJson, isGlobal);
+	if (!runtimePath) {
+		console.log(chalk.yellow(`Plugin "${name}" does not have a runtime.json config file.`));
+		return;
+	}
+
+	const runtimeConfig = readRuntimeConfig(runtimePath);
+	const enabledFeatures = runtimeConfig.features ?? getDefaultFeatures(features);
+
+	// JSON output mode - just list
+	if (options.json) {
+		console.log(
+			JSON.stringify(
+				{
+					plugin: name,
+					features: Object.entries(features).map(([fname, fdef]) => ({
+						name: fname,
+						enabled: enabledFeatures.includes(fname),
+						default: fdef.default !== false,
+						description: fdef.description,
+						variables: fdef.variables ? Object.keys(fdef.variables) : [],
+					})),
+				},
+				null,
+				2,
+			),
+		);
+		return;
+	}
+
+	// Non-interactive mode - just list
+	if (!process.stdout.isTTY || !process.stdin.isTTY) {
+		listFeaturesNonInteractive(name, features, enabledFeatures);
+		return;
+	}
+
+	// Interactive mode - checkbox prompt
+	console.log(chalk.bold(`\nConfigure features for ${name}:\n`));
+
+	const choices = Object.entries(features).map(([fname, fdef]) => {
+		const optIn = fdef.default === false ? chalk.dim(" (opt-in)") : "";
+		const desc = fdef.description ? chalk.dim(` - ${fdef.description}`) : "";
+		return {
+			name: `${fname}${optIn}${desc}`,
+			value: fname,
+			checked: enabledFeatures.includes(fname),
+		};
+	});
+
+	try {
+		const selected = await checkbox({
+			message: "Select features to enable:",
+			choices,
+			pageSize: 15,
+		});
+
+		// Apply changes
+		await applyFeatureChanges(name, runtimePath, features, enabledFeatures, selected);
+	} catch (err) {
+		// User cancelled (Ctrl+C)
+		console.log(chalk.dim("\nCancelled."));
+	}
+}
+
+/**
+ * Non-interactive feature listing
+ */
+function listFeaturesNonInteractive(
+	name: string,
+	features: Record<string, { description?: string; default?: boolean; variables?: Record<string, unknown> }>,
+	enabledFeatures: string[],
+): void {
+	console.log(chalk.bold(`\nFeatures for ${name}:\n`));
+
+	for (const [fname, fdef] of Object.entries(features)) {
+		const isEnabled = enabledFeatures.includes(fname);
+		const icon = isEnabled ? chalk.green("✓") : chalk.gray("○");
+		const defaultStr = fdef.default === false ? chalk.dim(" (opt-in)") : "";
+
+		console.log(`${icon} ${chalk.bold(fname)}${defaultStr}`);
+		if (fdef.description) {
+			console.log(chalk.dim(`    ${fdef.description}`));
+		}
+		if (fdef.variables && Object.keys(fdef.variables).length > 0) {
+			console.log(chalk.dim(`    Variables: ${Object.keys(fdef.variables).join(", ")}`));
+		}
+	}
+
+	console.log();
+	console.log(chalk.dim(`Configure with: omp features ${name} --enable <feature> --disable <feature>`));
+	console.log(chalk.dim(`Or set exactly: omp features ${name} --set feature1,feature2`));
+}
+
+/**
+ * Apply feature changes - update both plugins.json (for config/env) and runtime.json (for runtime)
+ */
+async function applyFeatureChanges(
+	name: string,
+	runtimePath: string,
+	features: Record<string, { description?: string; default?: boolean; variables?: Record<string, unknown> }>,
+	currentlyEnabled: string[],
+	newEnabled: string[],
+	isGlobal: boolean,
+): Promise<void> {
+	// Compute what changed
+	const toDisable = currentlyEnabled.filter((f) => !newEnabled.includes(f));
+	const toEnable = newEnabled.filter((f) => !currentlyEnabled.includes(f));
+
+	if (toDisable.length === 0 && toEnable.length === 0) {
+		console.log(chalk.yellow("\nNo changes to feature configuration."));
+		return;
+	}
+
+	console.log(chalk.blue(`\nApplying changes...`));
+
+	if (toDisable.length > 0) {
+		console.log(chalk.dim(`  Disabling: ${toDisable.join(", ")}`));
+	}
+	if (toEnable.length > 0) {
+		console.log(chalk.dim(`  Enabling: ${toEnable.join(", ")}`));
+	}
+
+	// Update plugins.json (source of truth for config/env commands)
+	const pluginsJson = await loadPluginsJson(isGlobal);
+	if (!pluginsJson.config) pluginsJson.config = {};
+	if (!pluginsJson.config[name]) pluginsJson.config[name] = {};
+	pluginsJson.config[name].features = newEnabled;
+	await savePluginsJson(pluginsJson, isGlobal);
+
+	// Also write to runtime.json (for runtime feature detection)
+	await writeRuntimeConfig(runtimePath, { features: newEnabled });
+
+	console.log(chalk.green(`\n✓ Features updated`));
+	if (newEnabled.length > 0) {
+		console.log(chalk.dim(`  Enabled: ${newEnabled.join(", ")}`));
+	} else {
+		console.log(chalk.dim(`  Enabled: none`));
+	}
+}
+
+/**
+ * Configure features for an installed plugin via CLI flags
+ * omp features @oh-my-pi/exa --enable websets --disable search
+ * omp features @oh-my-pi/exa --set search,websets
+ */
+export async function configureFeatures(name: string, options: FeaturesOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	// Check if plugin exists
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const pkgJson = await readPluginPackageJson(name, isGlobal);
+	if (!pkgJson) {
+		console.log(chalk.red(`Could not read package.json for ${name}`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const features = pkgJson.omp?.features;
+	if (!features || Object.keys(features).length === 0) {
+		console.log(chalk.yellow(`Plugin "${name}" has no configurable features.`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const allFeatureNames = Object.keys(features);
+
+	// Get runtime config
+	const runtimePath = getRuntimeConfigPath(pkgJson, isGlobal);
+	if (!runtimePath) {
+		console.log(chalk.yellow(`Plugin "${name}" does not have a runtime.json config file.`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const runtimeConfig = readRuntimeConfig(runtimePath);
+	const currentlyEnabled = runtimeConfig.features ?? getDefaultFeatures(features);
+
+	let newEnabled: string[];
+
+	// Handle --set (explicit list)
+	if (options.set !== undefined) {
+		if (options.set === "*") {
+			newEnabled = allFeatureNames;
+		} else if (options.set === "") {
+			newEnabled = [];
+		} else {
+			newEnabled = options.set.split(",").map((f) => f.trim()).filter(Boolean);
+			// Validate
+			for (const f of newEnabled) {
+				if (!features[f]) {
+					console.log(chalk.red(`Unknown feature "${f}". Available: ${allFeatureNames.join(", ")}`));
+					process.exitCode = 1;
+					return;
+				}
+			}
+		}
+	} else {
+		// Handle --enable and --disable
+		newEnabled = [...currentlyEnabled];
+
+		if (options.enable) {
+			for (const f of options.enable) {
+				if (!features[f]) {
+					console.log(chalk.red(`Unknown feature "${f}". Available: ${allFeatureNames.join(", ")}`));
+					process.exitCode = 1;
+					return;
+				}
+				if (!newEnabled.includes(f)) {
+					newEnabled.push(f);
+				}
+			}
+		}
+
+		if (options.disable) {
+			for (const f of options.disable) {
+				if (!features[f]) {
+					console.log(chalk.red(`Unknown feature "${f}". Available: ${allFeatureNames.join(", ")}`));
+					process.exitCode = 1;
+					return;
+				}
+				newEnabled = newEnabled.filter((e) => e !== f);
+			}
+		}
+	}
+
+	await applyFeatureChanges(name, runtimePath, features, currentlyEnabled, newEnabled);
+
+	if (options.json) {
+		console.log(JSON.stringify({ plugin: name, enabled: newEnabled }, null, 2));
+	}
+}
+
+/**
+ * Main features command handler
+ * Routes to interactive or configure based on options
+ */
+export async function featuresCommand(name: string, options: FeaturesOptions = {}): Promise<void> {
+	// If any modification options are passed, configure via CLI
+	if (options.enable || options.disable || options.set !== undefined) {
+		await configureFeatures(name, options);
+	} else {
+		// Otherwise, show interactive UI (or list in non-TTY mode)
+		await interactiveFeatures(name, options);
+	}
+}

package/src/commands/info.ts

@@ -1,9 +1,10 @@
+import { npmInfo } from "@omp/npm";
 import chalk from "chalk";
-import { npmInfo } from "../npm.js";
 
 export interface InfoOptions {
 	json?: boolean;
 	versions?: boolean;
+	allVersions?: boolean;
 }
 
 /**
@@ -17,6 +18,7 @@ export async function showInfo(packageName: string, options: InfoOptions = {}):
 
 		if (!info) {
 			console.log(chalk.red(`Package not found: ${packageName}`));
+			process.exitCode = 1;
 			return;
 		}
 
@@ -59,6 +61,14 @@ export async function showInfo(packageName: string, options: InfoOptions = {}):
 			console.log(chalk.dim("keywords: ") + info.keywords.join(", "));
 		}
 
+		// Dependencies
+		if (info.dependencies && Object.keys(info.dependencies).length > 0) {
+			console.log(chalk.dim("\ndependencies:"));
+			for (const [depName, depVersion] of Object.entries(info.dependencies)) {
+				console.log(chalk.dim(`  ${depName}: ${depVersion}`));
+			}
+		}
+
 		// Is it an omp plugin?
 		const isOmpPlugin = info.keywords?.includes("omp-plugin");
 		if (isOmpPlugin) {
@@ -68,11 +78,36 @@ export async function showInfo(packageName: string, options: InfoOptions = {}):
 			console.log(chalk.dim("  It may work, but might not have omp.install configuration"));
 		}
 
+		// Show what files will be installed
+		if (info.omp?.install?.length) {
+			console.log(chalk.dim("\nFiles to install:"));
+			for (const entry of info.omp.install) {
+				console.log(chalk.dim(`  ${entry.src} → ${entry.dest}`));
+			}
+		}
+
 		// Versions
-		if (options.versions && info["dist-tags"]) {
-			console.log(chalk.dim("\ndist-tags:"));
-			for (const [tag, version] of Object.entries(info["dist-tags"])) {
-				console.log(chalk.dim(`  ${tag}: `) + version);
+		if (options.versions || options.allVersions) {
+			if (info["dist-tags"]) {
+				console.log(chalk.dim("\ndist-tags:"));
+				for (const [tag, version] of Object.entries(info["dist-tags"])) {
+					console.log(chalk.dim(`  ${tag}: `) + version);
+				}
+			}
+
+			if (info.versions?.length) {
+				console.log(chalk.dim("\nall versions:"));
+				if (options.allVersions) {
+					// Show all versions
+					console.log(chalk.dim(`  ${info.versions.join(", ")}`));
+				} else {
+					// Show last 10
+					const versionsToShow = info.versions.slice(-10);
+					console.log(chalk.dim(`  ${versionsToShow.join(", ")}`));
+					if (info.versions.length > 10) {
+						console.log(chalk.dim(`  ... and ${info.versions.length - 10} more (use --all-versions to see all)`));
+					}
+				}
 			}
 		}
 
@@ -80,5 +115,6 @@ export async function showInfo(packageName: string, options: InfoOptions = {}):
 		console.log(chalk.dim(`Install with: omp install ${packageName}`));
 	} catch (err) {
 		console.log(chalk.red(`Error fetching info: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }

package/src/commands/init.ts

@@ -1,7 +1,17 @@
 import { existsSync } from "node:fs";
 import { mkdir, writeFile } from "node:fs/promises";
+import { PROJECT_PI_DIR, PROJECT_PLUGINS_JSON } from "@omp/paths";
 import chalk from "chalk";
-import { PROJECT_PI_DIR, PROJECT_PLUGINS_JSON } from "../paths.js";
+
+/**
+ * Format permission-related errors with actionable guidance
+ */
+function formatPermissionError(err: NodeJS.ErrnoException, path: string): string {
+	if (err.code === "EACCES" || err.code === "EPERM") {
+		return `Permission denied: Cannot write to ${path}. Check directory permissions or run with appropriate privileges.`;
+	}
+	return err.message;
+}
 
 export interface InitOptions {
 	force?: boolean;
@@ -15,6 +25,7 @@ export async function initProject(options: InitOptions = {}): Promise<void> {
 	if (existsSync(PROJECT_PLUGINS_JSON) && !options.force) {
 		console.log(chalk.yellow(`${PROJECT_PLUGINS_JSON} already exists.`));
 		console.log(chalk.dim("Use --force to overwrite"));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -37,6 +48,13 @@ export async function initProject(options: InitOptions = {}): Promise<void> {
 		console.log(chalk.dim("  2. Or edit plugins.json directly"));
 		console.log(chalk.dim("  3. Run: omp install (to install all)"));
 	} catch (err) {
-		console.log(chalk.red(`Error initializing project: ${(err as Error).message}`));
+		const error = err as NodeJS.ErrnoException;
+		if (error.code === "EACCES" || error.code === "EPERM") {
+			console.log(chalk.red(formatPermissionError(error, PROJECT_PI_DIR)));
+			console.log(chalk.dim("  Check directory permissions or run with appropriate privileges."));
+		} else {
+			console.log(chalk.red(`Error initializing project: ${error.message}`));
+		}
+		process.exitCode = 1;
 	}
 }