@oh-my-pi/cli 0.1.0 → 0.3.0

package/src/commands/config.ts

@@ -0,0 +1,384 @@
+import type { OmpVariable } from "@omp/manifest";
+import { loadPluginsJson, readPluginPackageJson, savePluginsJson } from "@omp/manifest";
+import { resolveScope } from "@omp/paths";
+import chalk from "chalk";
+
+export interface ConfigOptions {
+	global?: boolean;
+	local?: boolean;
+	json?: boolean;
+	delete?: boolean;
+}
+
+/**
+ * Collect all variables from a plugin (top-level + enabled features)
+ */
+function collectVariables(
+	pkgJson: { omp?: { variables?: Record<string, OmpVariable>; features?: Record<string, { variables?: Record<string, OmpVariable> }> } },
+	enabledFeatures: string[],
+): Record<string, OmpVariable> {
+	const vars: Record<string, OmpVariable> = {};
+
+	// Top-level variables
+	if (pkgJson.omp?.variables) {
+		Object.assign(vars, pkgJson.omp.variables);
+	}
+
+	// Variables from enabled features
+	if (pkgJson.omp?.features) {
+		for (const fname of enabledFeatures) {
+			const feature = pkgJson.omp.features[fname];
+			if (feature?.variables) {
+				Object.assign(vars, feature.variables);
+			}
+		}
+	}
+
+	return vars;
+}
+
+/**
+ * Parse a string value to the appropriate type based on variable definition
+ */
+function parseValue(value: string, varDef: OmpVariable): string | number | boolean | string[] {
+	switch (varDef.type) {
+		case "number":
+			const num = Number(value);
+			if (isNaN(num)) {
+				throw new Error(`Invalid number: ${value}`);
+			}
+			return num;
+		case "boolean":
+			if (value === "true" || value === "1" || value === "yes") return true;
+			if (value === "false" || value === "0" || value === "no") return false;
+			throw new Error(`Invalid boolean: ${value}. Use true/false, 1/0, or yes/no`);
+		case "string[]":
+			return value.split(",").map((s) => s.trim()).filter(Boolean);
+		default:
+			return value;
+	}
+}
+
+/**
+ * Format a value for display
+ */
+function formatValue(value: unknown, varDef: OmpVariable): string {
+	if (value === undefined) {
+		return chalk.dim("(not set)");
+	}
+	if (varDef.type === "string[]" && Array.isArray(value)) {
+		return value.join(", ");
+	}
+	if (typeof value === "string" && varDef.env) {
+		// Mask sensitive values (likely API keys)
+		if (value.length > 8) {
+			return `${value.slice(0, 4)}...${value.slice(-4)}`;
+		}
+	}
+	return String(value);
+}
+
+/**
+ * Resolve which features are currently enabled
+ *
+ * - null/undefined: use plugin defaults (features with default !== false)
+ * - ["*"]: explicitly all features
+ * - []: no optional features
+ * - ["f1", "f2"]: specific features
+ */
+function resolveEnabledFeatures(
+	allFeatureNames: string[],
+	storedFeatures: string[] | null | undefined,
+	pluginFeatures: Record<string, { default?: boolean }>,
+): string[] {
+	// Explicit "all features" request
+	if (Array.isArray(storedFeatures) && storedFeatures.includes("*")) return allFeatureNames;
+	// Explicit feature list (including empty array = no features)
+	if (Array.isArray(storedFeatures)) return storedFeatures;
+	// null/undefined = use defaults
+	return Object.entries(pluginFeatures)
+		.filter(([_, f]) => f.default !== false)
+		.map(([name]) => name);
+}
+
+/**
+ * List all configurable variables for a plugin
+ * omp config @oh-my-pi/exa
+ */
+export async function listConfig(name: string, options: ConfigOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	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 allFeatureNames = Object.keys(pkgJson.omp?.features || {});
+	const config = pluginsJson.config?.[name];
+	const enabledFeatures = resolveEnabledFeatures(allFeatureNames, config?.features, pkgJson.omp?.features || {});
+	const variables = collectVariables(pkgJson, enabledFeatures);
+
+	if (Object.keys(variables).length === 0) {
+		console.log(chalk.yellow(`Plugin "${name}" has no configurable variables.`));
+		return;
+	}
+
+	const userVars = config?.variables || {};
+
+	if (options.json) {
+		console.log(
+			JSON.stringify(
+				{
+					plugin: name,
+					variables: Object.entries(variables).map(([vname, vdef]) => ({
+						name: vname,
+						type: vdef.type,
+						value: userVars[vname],
+						default: vdef.default,
+						required: vdef.required,
+						env: vdef.env,
+						description: vdef.description,
+					})),
+				},
+				null,
+				2,
+			),
+		);
+		return;
+	}
+
+	console.log(chalk.bold(`\nVariables for ${name}:\n`));
+
+	for (const [vname, vdef] of Object.entries(variables)) {
+		const currentValue = userVars[vname];
+		const hasValue = currentValue !== undefined;
+		const hasDefault = vdef.default !== undefined;
+
+		const icon = hasValue ? chalk.green("✓") : hasDefault ? chalk.blue("○") : vdef.required ? chalk.red("!") : chalk.gray("○");
+		const requiredStr = vdef.required && !hasValue ? chalk.red(" (required)") : "";
+		const envStr = vdef.env ? chalk.dim(` [${vdef.env}]`) : "";
+
+		console.log(`${icon} ${chalk.bold(vname)}${requiredStr}${envStr}`);
+
+		if (vdef.description) {
+			console.log(chalk.dim(`    ${vdef.description}`));
+		}
+
+		console.log(chalk.dim(`    Type: ${vdef.type}`));
+
+		if (hasValue) {
+			console.log(`    Value: ${formatValue(currentValue, vdef)}`);
+		} else if (hasDefault) {
+			console.log(`    Default: ${formatValue(vdef.default, vdef)}`);
+		}
+	}
+
+	console.log();
+	console.log(chalk.dim(`Set a value: omp config ${name} <variable> <value>`));
+	console.log(chalk.dim(`Delete a value: omp config ${name} <variable> --delete`));
+}
+
+/**
+ * Get a specific variable value
+ * omp config @oh-my-pi/exa apiKey
+ */
+export async function getConfig(name: string, key: string, options: ConfigOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	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 allFeatureNames = Object.keys(pkgJson.omp?.features || {});
+	const config = pluginsJson.config?.[name];
+	const enabledFeatures = resolveEnabledFeatures(allFeatureNames, config?.features, pkgJson.omp?.features || {});
+	const variables = collectVariables(pkgJson, enabledFeatures);
+
+	const varDef = variables[key];
+	if (!varDef) {
+		console.log(chalk.red(`Unknown variable "${key}".`));
+		console.log(chalk.dim(`Available: ${Object.keys(variables).join(", ") || "(none)"}`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const userValue = config?.variables?.[key];
+	const value = userValue ?? varDef.default;
+
+	if (options.json) {
+		console.log(JSON.stringify({ plugin: name, variable: key, value, default: varDef.default }, null, 2));
+		return;
+	}
+
+	if (value !== undefined) {
+		console.log(formatValue(value, varDef));
+	} else {
+		console.log(chalk.dim("(not set)"));
+	}
+}
+
+/**
+ * Set a variable value
+ * omp config @oh-my-pi/exa apiKey sk-xxx
+ */
+export async function setConfig(name: string, key: string, value: string, options: ConfigOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	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 allFeatureNames = Object.keys(pkgJson.omp?.features || {});
+	const config = pluginsJson.config?.[name];
+	const enabledFeatures = resolveEnabledFeatures(allFeatureNames, config?.features, pkgJson.omp?.features || {});
+	const variables = collectVariables(pkgJson, enabledFeatures);
+
+	const varDef = variables[key];
+	if (!varDef) {
+		console.log(chalk.red(`Unknown variable "${key}".`));
+		console.log(chalk.dim(`Available: ${Object.keys(variables).join(", ") || "(none)"}`));
+		process.exitCode = 1;
+		return;
+	}
+
+	// Parse and validate value
+	let parsed: string | number | boolean | string[];
+	try {
+		parsed = parseValue(value, varDef);
+	} catch (err) {
+		console.log(chalk.red((err as Error).message));
+		process.exitCode = 1;
+		return;
+	}
+
+	// Update config
+	if (!pluginsJson.config) pluginsJson.config = {};
+	if (!pluginsJson.config[name]) pluginsJson.config[name] = {};
+	if (!pluginsJson.config[name].variables) pluginsJson.config[name].variables = {};
+
+	pluginsJson.config[name].variables[key] = parsed;
+	await savePluginsJson(pluginsJson, isGlobal);
+
+	console.log(chalk.green(`✓ Set ${name}.${key} = ${JSON.stringify(parsed)}`));
+
+	if (varDef.env) {
+		console.log(chalk.dim(`  Environment variable: ${varDef.env}`));
+		console.log(chalk.dim(`  Export with: omp env`));
+	}
+
+	if (options.json) {
+		console.log(JSON.stringify({ plugin: name, variable: key, value: parsed }, null, 2));
+	}
+}
+
+/**
+ * Delete a variable override (revert to default)
+ * omp config @oh-my-pi/exa apiKey --delete
+ */
+export async function deleteConfig(name: string, key: string, options: ConfigOptions = {}): Promise<void> {
+	const isGlobal = resolveScope(options);
+	const pluginsJson = await loadPluginsJson(isGlobal);
+
+	if (!pluginsJson.plugins[name]) {
+		console.log(chalk.yellow(`Plugin "${name}" is not installed.`));
+		process.exitCode = 1;
+		return;
+	}
+
+	const config = pluginsJson.config?.[name];
+	// Check key presence with hasOwnProperty, not truthiness (allows deleting falsy values like false, 0, "", [])
+	if (!config?.variables || !Object.prototype.hasOwnProperty.call(config.variables, key)) {
+		console.log(chalk.yellow(`Variable "${key}" is not set for ${name}.`));
+		return;
+	}
+
+	delete pluginsJson.config![name].variables![key];
+
+	// Clean up empty objects
+	if (Object.keys(pluginsJson.config![name].variables!).length === 0) {
+		delete pluginsJson.config![name].variables;
+	}
+	if (Object.keys(pluginsJson.config![name]).length === 0) {
+		delete pluginsJson.config![name];
+	}
+	if (Object.keys(pluginsJson.config!).length === 0) {
+		delete pluginsJson.config;
+	}
+
+	await savePluginsJson(pluginsJson, isGlobal);
+
+	console.log(chalk.green(`✓ Deleted ${name}.${key} (reverted to default)`));
+
+	if (options.json) {
+		console.log(JSON.stringify({ plugin: name, variable: key, deleted: true }, null, 2));
+	}
+}
+
+/**
+ * Main config command handler
+ * Routes to list, get, set, or delete based on arguments
+ */
+export async function configCommand(
+	name: string,
+	keyOrOptions?: string | ConfigOptions,
+	valueOrOptions?: string | ConfigOptions,
+	options: ConfigOptions = {},
+): Promise<void> {
+	// Handle different argument patterns
+	let key: string | undefined;
+	let value: string | undefined;
+	let opts: ConfigOptions;
+
+	if (typeof keyOrOptions === "object") {
+		// omp config <name> [options]
+		opts = keyOrOptions;
+	} else if (typeof valueOrOptions === "object") {
+		// omp config <name> <key> [options]
+		key = keyOrOptions;
+		opts = valueOrOptions;
+	} else {
+		// omp config <name> <key> <value> [options]
+		key = keyOrOptions;
+		value = valueOrOptions;
+		opts = options;
+	}
+
+	if (!key) {
+		await listConfig(name, opts);
+	} else if (opts.delete) {
+		await deleteConfig(name, key, opts);
+	} else if (value !== undefined) {
+		await setConfig(name, key, value, opts);
+	} else {
+		await getConfig(name, key, opts);
+	}
+}

package/src/commands/create.ts

@@ -8,16 +8,65 @@ export interface CreateOptions {
 	author?: string;
 }
 
+const VALID_NPM_CHARS = new Set("abcdefghijklmnopqrstuvwxyz0123456789-_.");
+
+/**
+ * Validate that a name conforms to npm naming rules
+ */
+function isValidNpmName(name: string): boolean {
+	if (!name || name.length === 0) return false;
+	if (name.startsWith(".") || name.startsWith("_")) return false;
+	if (name.includes(" ")) return false;
+	for (const char of name) {
+		if (!VALID_NPM_CHARS.has(char)) return false;
+	}
+	return true;
+}
+
+/**
+ * Normalize a string to be a valid npm package name
+ */
+function normalizePluginName(name: string): string {
+	let normalized = name.toLowerCase().split(" ").join("-");
+
+	// Remove invalid characters (keep alphanumeric, -, _, .)
+	normalized = Array.from(normalized)
+		.filter((char) => VALID_NPM_CHARS.has(char))
+		.join("");
+
+	// Can't start with . or _ or -
+	while (normalized.startsWith(".") || normalized.startsWith("_") || normalized.startsWith("-")) {
+		normalized = normalized.slice(1);
+	}
+
+	return normalized;
+}
+
 /**
  * Scaffold a new plugin from template
  */
 export async function createPlugin(name: string, options: CreateOptions = {}): Promise<void> {
 	// Ensure name follows conventions
-	const pluginName = name.startsWith("omp-") ? name : `omp-${name}`;
+	let pluginName = name.startsWith("omp-") ? name : `omp-${name}`;
+
+	// Validate and normalize the plugin name
+	if (!isValidNpmName(pluginName)) {
+		const normalized = normalizePluginName(pluginName);
+		if (!normalized || normalized === "omp-" || normalized === "omp") {
+			console.log(chalk.red(`Error: Invalid plugin name "${name}" cannot be normalized to a valid npm name`));
+			process.exitCode = 1;
+			return;
+		}
+		// Ensure omp- prefix after normalization
+		const finalName = normalized.startsWith("omp-") ? normalized : `omp-${normalized}`;
+		console.log(chalk.yellow(`Invalid plugin name. Normalized to: ${finalName}`));
+		pluginName = finalName;
+	}
 	const pluginDir = pluginName;
 
 	if (existsSync(pluginDir)) {
 		console.log(chalk.red(`Error: Directory ${pluginDir} already exists`));
+		process.exitCode = 1;
 		return;
 	}
 
@@ -149,5 +198,6 @@ Provide instructions for the agent here.
 		console.log(chalk.dim("  5. Publish: npm publish"));
 	} catch (err) {
 		console.log(chalk.red(`Error creating plugin: ${(err as Error).message}`));
+		process.exitCode = 1;
 	}
 }

package/src/commands/doctor.ts

@@ -1,12 +1,20 @@
 import { existsSync } from "node:fs";
+import { detectAllConflicts, formatConflicts } from "@omp/conflicts";
+import { getInstalledPlugins, loadPluginsJson, readPluginPackageJson, savePluginsJson } from "@omp/manifest";
+import {
+	GLOBAL_PACKAGE_JSON,
+	NODE_MODULES_DIR,
+	PLUGINS_DIR,
+	PROJECT_NODE_MODULES,
+	PROJECT_PLUGINS_JSON,
+	resolveScope,
+} from "@omp/paths";
+import { checkPluginSymlinks, createPluginSymlinks } from "@omp/symlinks";
 import chalk from "chalk";
-import { detectAllConflicts, formatConflicts } from "../conflicts.js";
-import { getInstalledPlugins, loadPluginsJson, readPluginPackageJson } from "../manifest.js";
-import { GLOBAL_PACKAGE_JSON, NODE_MODULES_DIR, PLUGINS_DIR } from "../paths.js";
-import { checkPluginSymlinks } from "../symlinks.js";
 
 export interface DoctorOptions {
 	global?: boolean;
+	local?: boolean;
 	fix?: boolean;
 	json?: boolean;
 }
@@ -22,7 +30,7 @@ interface DiagnosticResult {
  * Run health checks on the plugin system
  */
 export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
-	const isGlobal = options.global !== false;
+	const isGlobal = resolveScope(options);
 	const results: DiagnosticResult[] = [];
 
 	console.log(chalk.blue("Running health checks...\n"));
@@ -45,7 +53,7 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
 	}
 
 	// 2. Check package.json exists
-	const packageJsonPath = isGlobal ? GLOBAL_PACKAGE_JSON : ".pi/plugins.json";
+	const packageJsonPath = isGlobal ? GLOBAL_PACKAGE_JSON : PROJECT_PLUGINS_JSON;
 	if (!existsSync(packageJsonPath)) {
 		results.push({
 			check: "Package manifest",
@@ -62,7 +70,7 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
 	}
 
 	// 3. Check node_modules exists
-	const nodeModules = isGlobal ? NODE_MODULES_DIR : ".pi/node_modules";
+	const nodeModules = isGlobal ? NODE_MODULES_DIR : PROJECT_NODE_MODULES;
 	if (!existsSync(nodeModules)) {
 		results.push({
 			check: "Node modules",
@@ -152,6 +160,38 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
 		});
 	}
 
+	// 7. Check for missing omp dependencies
+	const missingDeps: string[] = [];
+	for (const [name, pkgJson] of installedPlugins) {
+		if (pkgJson.dependencies) {
+			for (const depName of Object.keys(pkgJson.dependencies)) {
+				const depPkgJson = await readPluginPackageJson(depName, isGlobal);
+				if (!depPkgJson) {
+					// Dependency not found in node_modules
+					// Check if it's supposed to be an omp plugin by looking in the plugins manifest
+					if (pluginsJson.plugins[depName]) {
+						missingDeps.push(`${name} requires ${depName} (not in node_modules)`);
+					}
+				} else if (depPkgJson.omp?.install && depPkgJson.omp.install.length > 0) {
+					// Dependency is an omp plugin (has install entries) and is present - that's fine
+					// But check if it's registered in the plugins manifest
+					if (!pluginsJson.plugins[depName]) {
+						missingDeps.push(`${name} requires omp plugin ${depName} (installed but not in manifest)`);
+					}
+				}
+			}
+		}
+	}
+
+	if (missingDeps.length > 0) {
+		results.push({
+			check: "Missing omp dependencies",
+			status: "warning",
+			message: missingDeps.join("; "),
+			fix: isGlobal ? "Run: npm install in ~/.pi/plugins" : "Run: npm install in .pi",
+		});
+	}
+
 	// Output results
 	if (options.json) {
 		console.log(JSON.stringify({ results }, null, 2));
@@ -194,6 +234,7 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
 	} else {
 		if (errors.length > 0) {
 			console.log(chalk.red(`${errors.length} error(s) found`));
+			process.exitCode = 1;
 		}
 		if (warnings.length > 0) {
 			console.log(chalk.yellow(`${warnings.length} warning(s) found`));
@@ -214,4 +255,51 @@ export async function runDoctor(options: DoctorOptions = {}): Promise<void> {
 			console.log(chalk.dim(`  - ${s}`));
 		}
 	}
+
+	// Apply fixes if --fix flag was passed
+	if (options.fix) {
+		let fixedAnything = false;
+
+		// Fix broken/missing symlinks by re-creating them
+		if (brokenSymlinks.length > 0 || missingSymlinks.length > 0) {
+			console.log(chalk.blue("\nAttempting to fix broken/missing symlinks..."));
+			for (const [name, pkgJson] of installedPlugins) {
+				const symlinkResult = await createPluginSymlinks(name, pkgJson, isGlobal, false);
+				if (symlinkResult.created.length > 0) {
+					fixedAnything = true;
+					console.log(chalk.green(`  ✓ Re-created symlinks for ${name}`));
+				}
+				if (symlinkResult.errors.length > 0) {
+					for (const err of symlinkResult.errors) {
+						console.log(chalk.red(`  ✗ ${name}: ${err}`));
+					}
+				}
+			}
+		}
+
+		// Remove orphaned manifest entries
+		if (orphaned.length > 0) {
+			console.log(chalk.blue("\nRemoving orphaned entries from manifest..."));
+			for (const name of orphaned) {
+				delete pluginsJson.plugins[name];
+				console.log(chalk.green(`  ✓ Removed ${name}`));
+			}
+			await savePluginsJson(pluginsJson, isGlobal);
+			fixedAnything = true;
+		}
+
+		// Conflicts cannot be auto-fixed
+		if (conflicts.length > 0) {
+			console.log(chalk.yellow("\nConflicts cannot be auto-fixed. Please resolve manually:"));
+			for (const conflict of formatConflicts(conflicts)) {
+				console.log(chalk.dim(`  - ${conflict}`));
+			}
+		}
+
+		if (fixedAnything) {
+			console.log(chalk.green("\n✓ Fixes applied. Run 'omp doctor' again to verify."));
+		} else if (conflicts.length === 0) {
+			console.log(chalk.dim("\nNo fixable issues found."));
+		}
+	}
 }