@oh-my-pi/cli 0.1.0

package/src/manifest.ts

@@ -0,0 +1,212 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import {
+	GLOBAL_PACKAGE_JSON,
+	LEGACY_MANIFEST_PATH,
+	NODE_MODULES_DIR,
+	PLUGINS_DIR,
+	PROJECT_PLUGINS_JSON,
+} from "./paths.js";
+
+/**
+ * OMP field in package.json - defines what files to install
+ */
+export interface OmpInstallEntry {
+	src: string;
+	dest: string;
+}
+
+export interface OmpField {
+	install?: OmpInstallEntry[];
+	disabled?: boolean;
+}
+
+/**
+ * Package.json structure for plugins
+ */
+export interface PluginPackageJson {
+	name: string;
+	version: string;
+	description?: string;
+	keywords?: string[];
+	omp?: OmpField;
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+	files?: string[];
+}
+
+/**
+ * Global/project plugins.json structure
+ */
+export interface PluginsJson {
+	plugins: Record<string, string>; // name -> version specifier
+	disabled?: string[]; // disabled plugin names
+}
+
+/**
+ * Legacy manifest structure (for migration)
+ */
+export interface LegacyPluginInfo {
+	type: "github" | "local" | "npm";
+	repo?: string;
+	package?: string;
+	path?: string;
+	subdir?: string;
+	version?: string;
+	linked?: boolean;
+	installed: string[];
+	installedAt: string;
+}
+
+export interface LegacyManifest {
+	plugins: Record<string, LegacyPluginInfo>;
+}
+
+/**
+ * Initialize the global plugins directory with package.json
+ */
+export async function initGlobalPlugins(): Promise<void> {
+	await mkdir(PLUGINS_DIR, { recursive: true });
+
+	if (!existsSync(GLOBAL_PACKAGE_JSON)) {
+		const packageJson = {
+			name: "pi-plugins",
+			version: "1.0.0",
+			private: true,
+			description: "Global pi plugins managed by omp",
+			dependencies: {},
+		};
+		await writeFile(GLOBAL_PACKAGE_JSON, JSON.stringify(packageJson, null, 2));
+	}
+}
+
+/**
+ * Load plugins.json (global or project)
+ */
+export async function loadPluginsJson(global = true): Promise<PluginsJson> {
+	const path = global ? GLOBAL_PACKAGE_JSON : PROJECT_PLUGINS_JSON;
+
+	try {
+		const data = await readFile(path, "utf-8");
+		const parsed = JSON.parse(data);
+
+		if (global) {
+			// Global uses standard package.json format
+			return {
+				plugins: parsed.dependencies || {},
+				disabled: parsed.omp?.disabled || [],
+			};
+		}
+
+		// Project uses plugins.json format
+		return {
+			plugins: parsed.plugins || {},
+			disabled: parsed.disabled || [],
+		};
+	} catch (err) {
+		if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+			return { plugins: {}, disabled: [] };
+		}
+		throw err;
+	}
+}
+
+/**
+ * Save plugins.json (global or project)
+ */
+export async function savePluginsJson(data: PluginsJson, global = true): Promise<void> {
+	const path = global ? GLOBAL_PACKAGE_JSON : PROJECT_PLUGINS_JSON;
+	await mkdir(dirname(path), { recursive: true });
+
+	if (global) {
+		// Read existing package.json and update dependencies
+		let existing: Record<string, unknown> = {};
+		try {
+			existing = JSON.parse(await readFile(path, "utf-8"));
+		} catch {
+			existing = {
+				name: "pi-plugins",
+				version: "1.0.0",
+				private: true,
+				description: "Global pi plugins managed by omp",
+			};
+		}
+
+		existing.dependencies = data.plugins;
+		if (data.disabled?.length) {
+			existing.omp = { ...((existing.omp as Record<string, unknown>) || {}), disabled: data.disabled };
+		}
+
+		await writeFile(path, JSON.stringify(existing, null, 2));
+	} else {
+		// Project uses simple plugins.json format
+		await writeFile(path, JSON.stringify(data, null, 2));
+	}
+}
+
+/**
+ * Read a plugin's package.json from node_modules
+ */
+export async function readPluginPackageJson(pluginName: string, global = true): Promise<PluginPackageJson | null> {
+	const nodeModules = global ? NODE_MODULES_DIR : ".pi/node_modules";
+	let pkgPath: string;
+
+	// Handle scoped packages
+	if (pluginName.startsWith("@")) {
+		pkgPath = join(nodeModules, pluginName, "package.json");
+	} else {
+		pkgPath = join(nodeModules, pluginName, "package.json");
+	}
+
+	try {
+		const data = await readFile(pkgPath, "utf-8");
+		return JSON.parse(data) as PluginPackageJson;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Get the source directory for a plugin in node_modules
+ */
+export function getPluginSourceDir(pluginName: string, global = true): string {
+	const nodeModules = global ? NODE_MODULES_DIR : ".pi/node_modules";
+	return join(nodeModules, pluginName);
+}
+
+/**
+ * Check if legacy manifest.json exists
+ */
+export function hasLegacyManifest(): boolean {
+	return existsSync(LEGACY_MANIFEST_PATH);
+}
+
+/**
+ * Load legacy manifest.json
+ */
+export async function loadLegacyManifest(): Promise<LegacyManifest> {
+	try {
+		const data = await readFile(LEGACY_MANIFEST_PATH, "utf-8");
+		return JSON.parse(data) as LegacyManifest;
+	} catch {
+		return { plugins: {} };
+	}
+}
+
+/**
+ * Get all installed plugins with their info
+ */
+export async function getInstalledPlugins(global = true): Promise<Map<string, PluginPackageJson>> {
+	const pluginsJson = await loadPluginsJson(global);
+	const plugins = new Map<string, PluginPackageJson>();
+
+	for (const name of Object.keys(pluginsJson.plugins)) {
+		const pkgJson = await readPluginPackageJson(name, global);
+		if (pkgJson) {
+			plugins.set(name, pkgJson);
+		}
+	}
+
+	return plugins;
+}

package/src/migrate.ts

@@ -0,0 +1,181 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rename, rm, symlink, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import {
+	hasLegacyManifest,
+	type LegacyPluginInfo,
+	loadLegacyManifest,
+	type PluginPackageJson,
+	type PluginsJson,
+	savePluginsJson,
+} from "./manifest.js";
+import { LEGACY_MANIFEST_PATH, NODE_MODULES_DIR, PLUGINS_DIR } from "./paths.js";
+
+/**
+ * Prompt user for migration
+ */
+async function promptMigration(): Promise<boolean> {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+	});
+
+	return new Promise((resolve) => {
+		rl.question(chalk.yellow("Migrate to npm-native format? [y/N] "), (answer) => {
+			rl.close();
+			resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+		});
+	});
+}
+
+/**
+ * Check for and prompt migration if legacy manifest exists
+ */
+export async function checkMigration(auto = false): Promise<boolean> {
+	if (!hasLegacyManifest()) {
+		return false;
+	}
+
+	console.log(chalk.yellow("\n⚠ Legacy manifest.json detected"));
+	console.log(chalk.dim("  oh-my-pi has been updated to use npm-native plugin management."));
+	console.log();
+
+	if (!auto) {
+		const shouldMigrate = await promptMigration();
+		if (!shouldMigrate) {
+			console.log(chalk.dim("  Migration skipped. Use 'omp migrate' to migrate later."));
+			return false;
+		}
+	}
+
+	return await migrateToNpm();
+}
+
+/**
+ * Migrate from legacy manifest.json to npm-native format
+ */
+export async function migrateToNpm(): Promise<boolean> {
+	console.log(chalk.blue("\nMigrating to npm-native format..."));
+
+	try {
+		const legacyManifest = await loadLegacyManifest();
+		const plugins = Object.entries(legacyManifest.plugins);
+
+		if (plugins.length === 0) {
+			console.log(chalk.dim("  No plugins to migrate"));
+			await archiveLegacyManifest();
+			return true;
+		}
+
+		// Create node_modules directory
+		await mkdir(NODE_MODULES_DIR, { recursive: true });
+
+		const newPluginsJson: PluginsJson = { plugins: {} };
+		const migrated: string[] = [];
+		const failed: string[] = [];
+
+		for (const [name, info] of plugins) {
+			try {
+				console.log(chalk.dim(`  Migrating ${name}...`));
+				await migratePlugin(name, info);
+
+				// Determine version specifier for plugins.json
+				if (info.type === "npm" && info.package) {
+					newPluginsJson.plugins[info.package] = info.version ? `^${info.version}` : "latest";
+				} else if (info.type === "local" && info.path) {
+					newPluginsJson.plugins[name] = `file:${info.path}`;
+				} else if (info.type === "github" && info.repo) {
+					// GitHub plugins become local after clone
+					newPluginsJson.plugins[name] = `file:${join(NODE_MODULES_DIR, name)}`;
+				}
+
+				migrated.push(name);
+			} catch (err) {
+				console.log(chalk.yellow(`    ⚠ Failed to migrate ${name}: ${(err as Error).message}`));
+				failed.push(name);
+			}
+		}
+
+		// Save new plugins.json
+		await savePluginsJson(newPluginsJson, true);
+
+		// Archive legacy manifest
+		await archiveLegacyManifest();
+
+		console.log();
+		console.log(chalk.green(`✓ Migrated ${migrated.length} plugin(s)`));
+		if (failed.length > 0) {
+			console.log(chalk.yellow(`⚠ Failed to migrate ${failed.length} plugin(s): ${failed.join(", ")}`));
+		}
+
+		return true;
+	} catch (err) {
+		console.log(chalk.red(`Error during migration: ${(err as Error).message}`));
+		return false;
+	}
+}
+
+/**
+ * Migrate a single plugin to the new structure
+ */
+async function migratePlugin(name: string, info: LegacyPluginInfo): Promise<void> {
+	const oldPluginDir = join(PLUGINS_DIR, name);
+	const newPluginDir = join(NODE_MODULES_DIR, name);
+
+	if (!existsSync(oldPluginDir)) {
+		throw new Error(`Plugin directory not found: ${oldPluginDir}`);
+	}
+
+	// For linked plugins, create symlink in node_modules
+	if (info.linked && info.path) {
+		await mkdir(NODE_MODULES_DIR, { recursive: true });
+		if (existsSync(newPluginDir)) {
+			await rm(newPluginDir, { force: true, recursive: true });
+		}
+		await symlink(info.path, newPluginDir);
+		// Remove old symlink
+		await rm(oldPluginDir, { force: true });
+		return;
+	}
+
+	// For regular plugins, move to node_modules
+	if (existsSync(newPluginDir)) {
+		await rm(newPluginDir, { force: true, recursive: true });
+	}
+
+	// Rename/move the directory
+	await rename(oldPluginDir, newPluginDir);
+
+	// Create package.json if it doesn't exist (convert from omp.json)
+	const pkgJsonPath = join(newPluginDir, "package.json");
+	const ompJsonPath = join(newPluginDir, "omp.json");
+
+	if (!existsSync(pkgJsonPath) && existsSync(ompJsonPath)) {
+		const ompJson = JSON.parse(await readFile(ompJsonPath, "utf-8"));
+		const pkgJson: PluginPackageJson = {
+			name: ompJson.name || name,
+			version: ompJson.version || info.version || "0.0.0",
+			description: ompJson.description,
+			keywords: ["omp-plugin"],
+			omp: {
+				install: ompJson.install,
+			},
+		};
+		await writeFile(pkgJsonPath, JSON.stringify(pkgJson, null, 2));
+	}
+}
+
+/**
+ * Archive the legacy manifest.json
+ */
+async function archiveLegacyManifest(): Promise<void> {
+	if (!existsSync(LEGACY_MANIFEST_PATH)) {
+		return;
+	}
+
+	const archivePath = join(PLUGINS_DIR, `manifest.json.bak.${Date.now()}`);
+	await rename(LEGACY_MANIFEST_PATH, archivePath);
+	console.log(chalk.dim(`  Archived old manifest to ${basename(archivePath)}`));
+}

package/src/npm.ts

@@ -0,0 +1,150 @@
+import { execSync } from "node:child_process";
+
+export interface NpmPackageInfo {
+	name: string;
+	version: string;
+	description?: string;
+	keywords?: string[];
+	author?: string | { name: string; email?: string };
+	homepage?: string;
+	repository?: { type: string; url: string } | string;
+	versions?: string[];
+	"dist-tags"?: Record<string, string>;
+}
+
+export interface NpmSearchResult {
+	name: string;
+	version: string;
+	description?: string;
+	keywords?: string[];
+	date?: string;
+	author?: { name: string };
+}
+
+/**
+ * Execute npm command and return output
+ */
+export function npmExec(args: string[], cwd?: string): string {
+	const cmd = `npm ${args.join(" ")}`;
+	return execSync(cmd, {
+		cwd,
+		stdio: ["pipe", "pipe", "pipe"],
+		encoding: "utf-8",
+	});
+}
+
+/**
+ * Execute npm command with prefix (for installing to specific directory)
+ */
+export function npmExecWithPrefix(args: string[], prefix: string): string {
+	return npmExec(["--prefix", prefix, ...args]);
+}
+
+/**
+ * Install packages using npm
+ */
+export async function npmInstall(
+	packages: string[],
+	prefix: string,
+	options: { save?: boolean; saveDev?: boolean } = {},
+): Promise<void> {
+	const args = ["install"];
+
+	if (options.save) {
+		args.push("--save");
+	} else if (options.saveDev) {
+		args.push("--save-dev");
+	}
+
+	args.push(...packages);
+
+	npmExecWithPrefix(args, prefix);
+}
+
+/**
+ * Uninstall packages using npm
+ */
+export async function npmUninstall(packages: string[], prefix: string): Promise<void> {
+	npmExecWithPrefix(["uninstall", ...packages], prefix);
+}
+
+/**
+ * Get package info from npm registry
+ */
+export async function npmInfo(packageName: string): Promise<NpmPackageInfo | null> {
+	try {
+		const output = npmExec(["info", packageName, "--json"]);
+		return JSON.parse(output);
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Search npm for packages with a keyword
+ */
+export async function npmSearch(query: string, keyword = "omp-plugin"): Promise<NpmSearchResult[]> {
+	try {
+		// Search for packages with the omp-plugin keyword
+		const searchTerm = keyword ? `keywords:${keyword} ${query}` : query;
+		const output = npmExec(["search", searchTerm, "--json"]);
+		return JSON.parse(output);
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Check for outdated packages
+ */
+export async function npmOutdated(
+	prefix: string,
+): Promise<Record<string, { current: string; wanted: string; latest: string }>> {
+	try {
+		const output = npmExecWithPrefix(["outdated", "--json"], prefix);
+		return JSON.parse(output);
+	} catch (err) {
+		// npm outdated exits with code 1 if there are outdated packages
+		const error = err as { stdout?: string };
+		if (error.stdout) {
+			try {
+				return JSON.parse(error.stdout);
+			} catch {
+				return {};
+			}
+		}
+		return {};
+	}
+}
+
+/**
+ * Update packages using npm
+ */
+export async function npmUpdate(packages: string[], prefix: string): Promise<void> {
+	const args = ["update"];
+	if (packages.length > 0) {
+		args.push(...packages);
+	}
+	npmExecWithPrefix(args, prefix);
+}
+
+/**
+ * Get list of installed packages
+ */
+export async function npmList(prefix: string): Promise<Record<string, { version: string }>> {
+	try {
+		const output = npmExecWithPrefix(["list", "--json", "--depth=0"], prefix);
+		const parsed = JSON.parse(output);
+		return parsed.dependencies || {};
+	} catch {
+		return {};
+	}
+}
+
+/**
+ * Resolve a package version from the registry
+ */
+export async function resolveVersion(packageName: string, versionRange = "latest"): Promise<string | null> {
+	const info = await npmInfo(`${packageName}@${versionRange}`);
+	return info?.version || null;
+}

package/src/paths.ts

@@ -0,0 +1,72 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// Global pi configuration directory
+export const PI_CONFIG_DIR = join(homedir(), ".pi");
+
+// Global plugins directory
+export const PLUGINS_DIR = join(PI_CONFIG_DIR, "plugins");
+
+// npm node_modules within plugins directory
+export const NODE_MODULES_DIR = join(PLUGINS_DIR, "node_modules");
+
+// Global package.json for plugin management
+export const GLOBAL_PACKAGE_JSON = join(PLUGINS_DIR, "package.json");
+
+// Global package-lock.json
+export const GLOBAL_LOCK_FILE = join(PLUGINS_DIR, "package-lock.json");
+
+// Legacy manifest (for migration)
+export const LEGACY_MANIFEST_PATH = join(PLUGINS_DIR, "manifest.json");
+
+// Project-local config directory
+export const PROJECT_PI_DIR = ".pi";
+
+// Project-local plugins.json
+export const PROJECT_PLUGINS_JSON = join(PROJECT_PI_DIR, "plugins.json");
+
+// Project-local lock file
+export const PROJECT_PLUGINS_LOCK = join(PROJECT_PI_DIR, "plugins-lock.json");
+
+// Project-local node_modules
+export const PROJECT_NODE_MODULES = join(PROJECT_PI_DIR, "node_modules");
+
+/**
+ * Get the agent directory (where symlinks are installed)
+ */
+export function getAgentDir(global = true): string {
+	if (global) {
+		return join(PI_CONFIG_DIR, "agent");
+	}
+	return join(PROJECT_PI_DIR, "agent");
+}
+
+/**
+ * Get the plugins directory for the given scope
+ */
+export function getPluginsDir(global = true): string {
+	if (global) {
+		return PLUGINS_DIR;
+	}
+	return PROJECT_PI_DIR;
+}
+
+/**
+ * Get the node_modules directory for the given scope
+ */
+export function getNodeModulesDir(global = true): string {
+	if (global) {
+		return NODE_MODULES_DIR;
+	}
+	return PROJECT_NODE_MODULES;
+}
+
+/**
+ * Get the package.json path for the given scope
+ */
+export function getPackageJsonPath(global = true): string {
+	if (global) {
+		return GLOBAL_PACKAGE_JSON;
+	}
+	return PROJECT_PLUGINS_JSON;
+}