@oh-my-pi/cli 0.1.0

package/src/commands/enable.ts

@@ -0,0 +1,105 @@
+import chalk from "chalk";
+import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "../manifest.js";
+import { createPluginSymlinks, removePluginSymlinks } from "../symlinks.js";
+
+export interface EnableDisableOptions {
+	global?: boolean;
+	json?: boolean;
+}
+
+/**
+ * Enable a disabled plugin (re-create symlinks)
+ */
+export async function enablePlugin(name: string, options: EnableDisableOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	// Check if plugin exists
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		return;
+	}
+
+	// Check if already enabled
+	if (!pluginsJson.disabled?.includes(name)) {
+		console.log(chalk.yellow(`Plugin "${name}" is already enabled.`));
+		return;
+	}
+
+	try {
+		// Read package.json
+		const pkgJson = await readPluginPackageJson(name, isGlobal);
+		if (!pkgJson) {
+			console.log(chalk.red(`Could not read package.json for ${name}`));
+			return;
+		}
+
+		// 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);
+		await savePluginsJson(pluginsJson, isGlobal);
+
+		console.log(chalk.green(`✓ Enabled "${name}"`));
+
+		if (options.json) {
+			console.log(JSON.stringify({ name, enabled: true }, null, 2));
+		}
+	} catch (err) {
+		console.log(chalk.red(`Error enabling plugin: ${(err as Error).message}`));
+	}
+}
+
+/**
+ * Disable a plugin (remove symlinks but keep installed)
+ */
+export async function disablePlugin(name: string, options: EnableDisableOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	// Check if plugin exists
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		return;
+	}
+
+	// Check if already disabled
+	if (pluginsJson.disabled?.includes(name)) {
+		console.log(chalk.yellow(`Plugin "${name}" is already disabled.`));
+		return;
+	}
+
+	try {
+		// Read package.json
+		const pkgJson = await readPluginPackageJson(name, isGlobal);
+		if (!pkgJson) {
+			console.log(chalk.red(`Could not read package.json for ${name}`));
+			return;
+		}
+
+		// Remove symlinks
+		console.log(chalk.blue(`Disabling ${name}...`));
+		await removePluginSymlinks(name, pkgJson);
+
+		// Add to disabled list
+		if (!pluginsJson.disabled) {
+			pluginsJson.disabled = [];
+		}
+		pluginsJson.disabled.push(name);
+		await savePluginsJson(pluginsJson, isGlobal);
+
+		console.log(chalk.green(`✓ Disabled "${name}"`));
+		console.log(chalk.dim("  Plugin is still installed, symlinks removed"));
+		console.log(chalk.dim(`  Re-enable with: omp enable ${name}`));
+
+		if (options.json) {
+			console.log(JSON.stringify({ name, enabled: false }, null, 2));
+		}
+	} catch (err) {
+		console.log(chalk.red(`Error disabling plugin: ${(err as Error).message}`));
+	}
+}

package/src/commands/info.ts

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import { npmInfo } from "../npm.js";
+
+export interface InfoOptions {
+	json?: boolean;
+	versions?: boolean;
+}
+
+/**
+ * Show detailed info about a package before install
+ */
+export async function showInfo(packageName: string, options: InfoOptions = {}): Promise<void> {
+	console.log(chalk.blue(`Fetching info for ${packageName}...`));
+
+	try {
+		const info = await npmInfo(packageName);
+
+		if (!info) {
+			console.log(chalk.red(`Package not found: ${packageName}`));
+			return;
+		}
+
+		if (options.json) {
+			console.log(JSON.stringify(info, null, 2));
+			return;
+		}
+
+		console.log();
+		console.log(chalk.bold.green(info.name) + chalk.dim(` v${info.version}`));
+		console.log();
+
+		if (info.description) {
+			console.log(chalk.white(info.description));
+			console.log();
+		}
+
+		// Author
+		if (info.author) {
+			const authorStr =
+				typeof info.author === "string"
+					? info.author
+					: `${info.author.name}${info.author.email ? ` <${info.author.email}>` : ""}`;
+			console.log(chalk.dim("author: ") + authorStr);
+		}
+
+		// Homepage
+		if (info.homepage) {
+			console.log(chalk.dim("homepage: ") + info.homepage);
+		}
+
+		// Repository
+		if (info.repository) {
+			const repoUrl = typeof info.repository === "string" ? info.repository : info.repository.url;
+			console.log(chalk.dim("repo: ") + repoUrl);
+		}
+
+		// Keywords
+		if (info.keywords?.length) {
+			console.log(chalk.dim("keywords: ") + info.keywords.join(", "));
+		}
+
+		// Is it an omp plugin?
+		const isOmpPlugin = info.keywords?.includes("omp-plugin");
+		if (isOmpPlugin) {
+			console.log(chalk.green("\n✓ This is an omp plugin"));
+		} else {
+			console.log(chalk.yellow("\n⚠ This package does not have the omp-plugin keyword"));
+			console.log(chalk.dim("  It may work, but might not have omp.install configuration"));
+		}
+
+		// 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);
+			}
+		}
+
+		console.log();
+		console.log(chalk.dim(`Install with: omp install ${packageName}`));
+	} catch (err) {
+		console.log(chalk.red(`Error fetching info: ${(err as Error).message}`));
+	}
+}

package/src/commands/init.ts

@@ -0,0 +1,42 @@
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import chalk from "chalk";
+import { PROJECT_PI_DIR, PROJECT_PLUGINS_JSON } from "../paths.js";
+
+export interface InitOptions {
+	force?: boolean;
+}
+
+/**
+ * Initialize .pi/plugins.json in current project
+ */
+export async function initProject(options: InitOptions = {}): Promise<void> {
+	// Check if already exists
+	if (existsSync(PROJECT_PLUGINS_JSON) && !options.force) {
+		console.log(chalk.yellow(`${PROJECT_PLUGINS_JSON} already exists.`));
+		console.log(chalk.dim("Use --force to overwrite"));
+		return;
+	}
+
+	try {
+		// Create .pi directory
+		await mkdir(PROJECT_PI_DIR, { recursive: true });
+
+		// Create plugins.json
+		const pluginsJson = {
+			plugins: {},
+			disabled: [],
+		};
+
+		await writeFile(PROJECT_PLUGINS_JSON, JSON.stringify(pluginsJson, null, 2));
+
+		console.log(chalk.green(`✓ Created ${PROJECT_PLUGINS_JSON}`));
+		console.log();
+		console.log(chalk.dim("Next steps:"));
+		console.log(chalk.dim("  1. Add plugins: omp install <package> --save"));
+		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}`));
+	}
+}

package/src/commands/install.ts

@@ -0,0 +1,327 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { cp, mkdir, readFile, rm } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { type Conflict, detectConflicts, formatConflicts } from "../conflicts.js";
+import {
+	getInstalledPlugins,
+	initGlobalPlugins,
+	loadPluginsJson,
+	type PluginPackageJson,
+	readPluginPackageJson,
+	savePluginsJson,
+} from "../manifest.js";
+import { npmInfo, npmInstall } from "../npm.js";
+import { NODE_MODULES_DIR, PLUGINS_DIR, PROJECT_NODE_MODULES, PROJECT_PLUGINS_JSON } from "../paths.js";
+import { createPluginSymlinks } from "../symlinks.js";
+
+export interface InstallOptions {
+	global?: boolean;
+	save?: boolean;
+	saveDev?: boolean;
+	force?: boolean;
+	json?: boolean;
+}
+
+/**
+ * Prompt user to choose when there's a conflict
+ */
+async function promptConflictResolution(conflict: Conflict): Promise<number | null> {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return new Promise((resolve) => {
+		console.log(chalk.yellow(`\n⚠ Conflict: ${formatConflicts([conflict])[0]}`));
+		conflict.plugins.forEach((p, i) => {
+			console.log(`  [${i + 1}] ${p.name}`);
+		});
+		console.log(`  [${conflict.plugins.length + 1}] abort`);
+
+		rl.question("  Choose: ", (answer) => {
+			rl.close();
+			const choice = parseInt(answer, 10);
+			if (choice > 0 && choice <= conflict.plugins.length) {
+				resolve(choice - 1);
+			} else {
+				resolve(null);
+			}
+		});
+	});
+}
+
+/**
+ * Parse package specifier into name and version
+ */
+function parsePackageSpec(spec: string): { name: string; version: string } {
+	// Handle scoped packages: @scope/name@version
+	if (spec.startsWith("@")) {
+		const lastAt = spec.lastIndexOf("@");
+		if (lastAt > 0) {
+			return {
+				name: spec.slice(0, lastAt),
+				version: spec.slice(lastAt + 1),
+			};
+		}
+		return { name: spec, version: "latest" };
+	}
+
+	// Handle regular packages: name@version
+	const atIndex = spec.indexOf("@");
+	if (atIndex > 0) {
+		return {
+			name: spec.slice(0, atIndex),
+			version: spec.slice(atIndex + 1),
+		};
+	}
+
+	return { name: spec, version: "latest" };
+}
+
+/**
+ * Check if a path looks like a local path
+ */
+function isLocalPath(spec: string): boolean {
+	return spec.startsWith("/") || spec.startsWith("./") || spec.startsWith("../") || spec.startsWith("~");
+}
+
+/**
+ * Install plugins from package specifiers
+ * omp install [pkg...]
+ */
+export async function installPlugin(packages?: string[], options: InstallOptions = {}): 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;
+
+	// Initialize plugins directory if needed
+	if (isGlobal) {
+		await initGlobalPlugins();
+	} else {
+		// Ensure project .pi directory exists
+		await mkdir(prefix, { recursive: true });
+		// Initialize plugins.json if it doesn't exist
+		if (!existsSync(PROJECT_PLUGINS_JSON)) {
+			await savePluginsJson({ plugins: {} }, false);
+		}
+	}
+
+	// If no packages specified, install from plugins.json
+	if (!packages || packages.length === 0) {
+		const pluginsJson = await loadPluginsJson(isGlobal);
+		packages = Object.entries(pluginsJson.plugins).map(([name, version]) => `${name}@${version}`);
+
+		if (packages.length === 0) {
+			console.log(chalk.yellow("No plugins to install."));
+			console.log(
+				chalk.dim(isGlobal ? "Add plugins with: omp install <package>" : "Add plugins to .pi/plugins.json"),
+			);
+			return;
+		}
+
+		console.log(
+			chalk.blue(`Installing ${packages.length} plugin(s) from ${isGlobal ? "package.json" : "plugins.json"}...`),
+		);
+	}
+
+	// Get existing plugins for conflict detection
+	const existingPlugins = await getInstalledPlugins(isGlobal);
+
+	const results: Array<{ name: string; version: string; success: boolean; error?: string }> = [];
+
+	for (const spec of packages) {
+		// Check if it's a local path
+		if (isLocalPath(spec)) {
+			const result = await installLocalPlugin(spec, isGlobal, options);
+			results.push(result);
+			continue;
+		}
+
+		const { name, version } = parsePackageSpec(spec);
+		const pkgSpec = version === "latest" ? name : `${name}@${version}`;
+
+		try {
+			console.log(chalk.blue(`\nInstalling ${pkgSpec}...`));
+
+			// 1. Resolve version from npm registry
+			const info = await npmInfo(pkgSpec);
+			if (!info) {
+				console.log(chalk.red(`  ✗ Package not found: ${name}`));
+				results.push({ name, version, success: false, error: "Package not found" });
+				continue;
+			}
+
+			// 2. Check for conflicts before installing
+			// We need to fetch the package.json to check omp.install
+			// For now, we'll check after npm install and rollback if needed
+
+			// 3. npm install
+			console.log(chalk.dim(`  Fetching from npm...`));
+			await npmInstall([pkgSpec], prefix, { save: options.save || isGlobal });
+
+			// 4. Read package.json from installed package
+			const pkgJson = await readPluginPackageJson(name, isGlobal);
+			if (!pkgJson) {
+				console.log(chalk.yellow(`  ⚠ Installed but no package.json found`));
+				results.push({ name, version: info.version, success: true });
+				continue;
+			}
+
+			// 5. Check for conflicts
+			const conflicts = detectConflicts(name, pkgJson, existingPlugins);
+
+			if (conflicts.length > 0 && !options.force) {
+				// Handle conflicts
+				let abort = false;
+				for (const conflict of conflicts) {
+					const choice = await promptConflictResolution(conflict);
+					if (choice === null) {
+						abort = true;
+						break;
+					}
+					// If user chose the new plugin, we continue
+					// If user chose existing plugin, we skip this destination
+					// For now, simplify: if not aborted, force overwrite
+				}
+
+				if (abort) {
+					console.log(chalk.yellow(`  Aborted due to conflicts`));
+					// Rollback: uninstall the package
+					execSync(`npm uninstall --prefix ${prefix} ${name}`, { stdio: "pipe" });
+					results.push({ name, version: info.version, success: false, error: "Conflicts" });
+					continue;
+				}
+			}
+
+			// 6. Create symlinks for omp.install entries
+			const _symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal);
+
+			// 7. Process dependencies with omp field
+			if (pkgJson.dependencies) {
+				for (const depName of Object.keys(pkgJson.dependencies)) {
+					const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+					if (depPkgJson?.omp?.install) {
+						console.log(chalk.dim(`  Processing dependency: ${depName}`));
+						await createPluginSymlinks(depName, depPkgJson, isGlobal);
+					}
+				}
+			}
+
+			// Add to installed plugins map for subsequent conflict detection
+			existingPlugins.set(name, pkgJson);
+
+			console.log(chalk.green(`✓ Installed ${name}@${info.version}`));
+			results.push({ name, version: info.version, success: true });
+		} catch (err) {
+			const errorMsg = (err as Error).message;
+			console.log(chalk.red(`  ✗ Failed to install ${name}: ${errorMsg}`));
+			results.push({ name, version, success: false, error: errorMsg });
+		}
+	}
+
+	// Summary
+	const successful = results.filter((r) => r.success);
+	const failed = results.filter((r) => !r.success);
+
+	console.log();
+	if (successful.length > 0) {
+		console.log(chalk.green(`✓ Installed ${successful.length} plugin(s)`));
+	}
+	if (failed.length > 0) {
+		console.log(chalk.red(`✗ Failed to install ${failed.length} plugin(s)`));
+	}
+
+	if (options.json) {
+		console.log(JSON.stringify({ results }, null, 2));
+	}
+}
+
+/**
+ * Install a local plugin (copy or link based on path type)
+ */
+async function installLocalPlugin(
+	localPath: string,
+	isGlobal: boolean,
+	_options: InstallOptions,
+): Promise<{ name: string; version: string; success: boolean; error?: string }> {
+	// Expand ~ to home directory
+	if (localPath.startsWith("~")) {
+		localPath = join(process.env.HOME || "", localPath.slice(1));
+	}
+	localPath = resolve(localPath);
+
+	if (!existsSync(localPath)) {
+		console.log(chalk.red(`Error: Path does not exist: ${localPath}`));
+		return { name: basename(localPath), version: "local", success: false, error: "Path not found" };
+	}
+
+	const _prefix = isGlobal ? PLUGINS_DIR : ".pi";
+	const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
+
+	try {
+		// Read package.json from local path
+		const localPkgJsonPath = join(localPath, "package.json");
+		let pkgJson: PluginPackageJson;
+
+		if (existsSync(localPkgJsonPath)) {
+			pkgJson = JSON.parse(await readFile(localPkgJsonPath, "utf-8"));
+		} else {
+			// Check for omp.json (legacy format)
+			const ompJsonPath = join(localPath, "omp.json");
+			if (existsSync(ompJsonPath)) {
+				const ompJson = JSON.parse(await readFile(ompJsonPath, "utf-8"));
+				// Convert omp.json to package.json format
+				pkgJson = {
+					name: ompJson.name || basename(localPath),
+					version: ompJson.version || "0.0.0",
+					description: ompJson.description,
+					keywords: ["omp-plugin"],
+					omp: {
+						install: ompJson.install,
+					},
+				};
+			} else {
+				pkgJson = {
+					name: basename(localPath),
+					version: "0.0.0",
+					keywords: ["omp-plugin"],
+				};
+			}
+		}
+
+		const pluginName = pkgJson.name;
+		const pluginDir = join(nodeModules, pluginName);
+
+		console.log(chalk.blue(`\nInstalling ${pluginName} from ${localPath}...`));
+
+		// Create node_modules directory
+		await mkdir(nodeModules, { recursive: true });
+
+		// Remove existing if present
+		if (existsSync(pluginDir)) {
+			await rm(pluginDir, { recursive: true, force: true });
+		}
+
+		// Copy the plugin
+		await cp(localPath, pluginDir, { recursive: true });
+		console.log(chalk.dim(`  Copied to ${pluginDir}`));
+
+		// Update plugins.json/package.json
+		const pluginsJson = await loadPluginsJson(isGlobal);
+		pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		await savePluginsJson(pluginsJson, isGlobal);
+
+		// Create symlinks
+		await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+
+		console.log(chalk.green(`✓ Installed ${pluginName}@${pkgJson.version}`));
+		return { name: pluginName, version: pkgJson.version, success: true };
+	} catch (err) {
+		const errorMsg = (err as Error).message;
+		console.log(chalk.red(`  ✗ Failed: ${errorMsg}`));
+		return { name: basename(localPath), version: "local", success: false, error: errorMsg };
+	}
+}

package/src/commands/link.ts

@@ -0,0 +1,108 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, symlink } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import chalk from "chalk";
+import { loadPluginsJson, type PluginPackageJson, savePluginsJson } from "../manifest.js";
+import { NODE_MODULES_DIR, PROJECT_NODE_MODULES } from "../paths.js";
+import { createPluginSymlinks } from "../symlinks.js";
+
+export interface LinkOptions {
+	name?: string;
+	global?: boolean;
+}
+
+/**
+ * Link a local plugin directory for development
+ * Creates a symlink in node_modules pointing to the local directory
+ */
+export async function linkPlugin(localPath: string, options: LinkOptions = {}): Promise<void> {
+	const isGlobal = options.global !== false;
+	const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
+
+	// Expand ~ to home directory
+	if (localPath.startsWith("~")) {
+		localPath = join(process.env.HOME || "", localPath.slice(1));
+	}
+	localPath = resolve(localPath);
+
+	// Verify the path exists
+	if (!existsSync(localPath)) {
+		console.log(chalk.red(`Error: Path does not exist: ${localPath}`));
+		return;
+	}
+
+	// Read package.json from local path
+	let pkgJson: PluginPackageJson;
+	const localPkgJsonPath = join(localPath, "package.json");
+	const localOmpJsonPath = join(localPath, "omp.json");
+
+	if (existsSync(localPkgJsonPath)) {
+		pkgJson = JSON.parse(await readFile(localPkgJsonPath, "utf-8"));
+	} else if (existsSync(localOmpJsonPath)) {
+		// Convert legacy omp.json to package.json format
+		const ompJson = JSON.parse(await readFile(localOmpJsonPath, "utf-8"));
+		pkgJson = {
+			name: ompJson.name || options.name || basename(localPath),
+			version: ompJson.version || "0.0.0-dev",
+			description: ompJson.description,
+			keywords: ["omp-plugin"],
+			omp: {
+				install: ompJson.install,
+			},
+		};
+	} else {
+		pkgJson = {
+			name: options.name || basename(localPath),
+			version: "0.0.0-dev",
+			keywords: ["omp-plugin"],
+		};
+		console.log(chalk.yellow("  Warning: No package.json or omp.json found"));
+	}
+
+	const pluginName = options.name || pkgJson.name;
+	const pluginDir = join(nodeModules, pluginName);
+
+	// Check if already installed
+	const pluginsJson = await loadPluginsJson(isGlobal);
+	if (pluginsJson.plugins[pluginName]) {
+		console.log(chalk.yellow(`Plugin "${pluginName}" is already installed.`));
+		console.log(chalk.dim("Use omp uninstall first, or specify a different name with -n"));
+		return;
+	}
+
+	try {
+		console.log(chalk.blue(`Linking ${localPath}...`));
+
+		// Create parent directory (handles scoped packages like @org/name)
+		await mkdir(dirname(pluginDir), { recursive: true });
+
+		// Remove existing if present
+		if (existsSync(pluginDir)) {
+			await rm(pluginDir, { force: true, recursive: true });
+		}
+
+		// Create symlink to the plugin directory
+		await symlink(localPath, pluginDir);
+		console.log(chalk.dim(`  Symlinked: ${pluginDir} → ${localPath}`));
+
+		// Update plugins.json with file: protocol
+		pluginsJson.plugins[pluginName] = `file:${localPath}`;
+		await savePluginsJson(pluginsJson, isGlobal);
+
+		// Create symlinks for omp.install entries
+		if (pkgJson.omp?.install?.length) {
+			await createPluginSymlinks(pluginName, pkgJson, isGlobal);
+		}
+
+		console.log(
+			chalk.green(`\n✓ Linked "${pluginName}"${pkgJson.version ? ` v${pkgJson.version}` : ""} (development mode)`),
+		);
+		console.log(chalk.dim("  Changes to the source will be reflected immediately"));
+	} catch (err) {
+		console.log(chalk.red(`Error linking plugin: ${(err as Error).message}`));
+		// Cleanup on failure
+		try {
+			await rm(pluginDir, { force: true });
+		} catch {}
+	}
+}