@omnidev-ai/cli 0.1.0

package/src/commands/serve.ts

@@ -0,0 +1,63 @@
+import { existsSync } from "node:fs";
+import { setActiveProfile } from "@omnidev-ai/core";
+import { buildCommand } from "@stricli/core";
+
+interface ServeFlags {
+	profile?: string;
+}
+
+export async function runServe(flags: ServeFlags): Promise<void> {
+	console.log("Starting OmniDev MCP server...");
+
+	// Check if OmniDev is initialized
+	if (!existsSync(".omni")) {
+		console.error("✗ OmniDev not initialized. Run: omnidev init");
+		process.exit(1);
+	}
+
+	// Set profile if provided
+	if (flags.profile) {
+		console.log(`Setting profile to: ${flags.profile}`);
+		try {
+			// Validate profile exists in config
+			const { loadConfig } = await import("@omnidev-ai/core");
+			const config = await loadConfig();
+			if (!config.profiles?.[flags.profile]) {
+				console.error(`✗ Profile "${flags.profile}" not found in config`);
+				process.exit(1);
+			}
+			await setActiveProfile(flags.profile);
+		} catch (error) {
+			console.error(`✗ Failed to set profile: ${error}`);
+			process.exit(1);
+		}
+	}
+
+	// Import and start the MCP server
+	try {
+		const { startServer } = await import("@omnidev-ai/mcp");
+		console.log("✓ Server starting...");
+		await startServer();
+	} catch (error) {
+		console.error(`✗ Failed to start server: ${error}`);
+		process.exit(1);
+	}
+}
+
+export const serveCommand = buildCommand({
+	docs: {
+		brief: "Start the OmniDev MCP server",
+		fullDescription: "Starts the MCP server that exposes omni_query and omni_execute tools to LLMs",
+	},
+	parameters: {
+		flags: {
+			profile: {
+				kind: "parsed" as const,
+				parse: String,
+				brief: "Set active profile before starting server",
+				optional: true,
+			},
+		},
+	},
+	func: runServe,
+});

package/src/commands/sync.ts

@@ -0,0 +1,43 @@
+import { getActiveProfile, loadConfig, syncAgentConfiguration } from "@omnidev-ai/core";
+import { buildCommand } from "@stricli/core";
+
+export const syncCommand = buildCommand({
+	docs: {
+		brief: "Manually sync all capabilities, roles, instructions, and MCP configuration",
+	},
+	parameters: {},
+	async func() {
+		return await runSync();
+	},
+});
+
+export async function runSync(): Promise<void> {
+	console.log("Syncing OmniDev configuration...");
+	console.log("");
+
+	try {
+		const config = await loadConfig();
+		const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
+
+		const result = await syncAgentConfiguration({ silent: false });
+
+		console.log("");
+		console.log("✓ Sync completed successfully!");
+		console.log("");
+		console.log(`Profile: ${activeProfile}`);
+		console.log(`Capabilities: ${result.capabilities.join(", ") || "none"}`);
+		console.log("");
+		console.log("Synced components:");
+		console.log("  • Capability registry");
+		console.log("  • Capability sync hooks");
+		console.log("  • .omni/.gitignore");
+		console.log("  • .omni/instructions.md");
+		console.log("  • .claude/skills/");
+		console.log("  • .cursor/rules/");
+	} catch (error) {
+		console.error("");
+		console.error("✗ Sync failed:");
+		console.error(`  ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env bun
+/**
+ * @omnidev-ai/cli - Command-line interface for OmniDev
+ *
+ * This package provides the CLI for managing OmniDev configuration,
+ * capabilities, and the MCP server.
+ */
+
+import { run } from "@stricli/core";
+import { buildDynamicApp } from "./lib/dynamic-app";
+import { debug } from "./lib/debug";
+
+// Build app dynamically based on enabled capabilities
+const app = await buildDynamicApp();
+
+debug("CLI startup", {
+	arguments: process.argv.slice(2),
+	cwd: process.cwd(),
+});
+
+// Run CLI with error handling
+try {
+	run(app, process.argv.slice(2), {
+		// biome-ignore lint/suspicious/noExplicitAny: Stricli expects a process-like object with stdin/stdout/stderr
+		process: process as any,
+	});
+} catch (error) {
+	// Provide helpful error messages instead of cryptic stack traces
+	if (error instanceof Error) {
+		// Check if it's a routing error (command not found)
+		if (
+			error.message.includes("getRoutingTargetForInput") ||
+			error.stack?.includes("@stricli/core")
+		) {
+			const args = process.argv.slice(2);
+			console.error(`\nError: Command not found or invalid usage.`);
+
+			if (args.length > 0) {
+				console.error(`\nYou tried to run: omnidev ${args.join(" ")}`);
+				console.error("\nThis could mean:");
+				console.error("  1. The command doesn't exist");
+				console.error("  2. A required capability is not enabled");
+				console.error("  3. Invalid command syntax\n");
+			}
+
+			console.error("Run 'omnidev --help' to see available commands");
+			console.error("\nTo enable capabilities, run: omnidev capability enable <name>");
+			console.error("To see enabled capabilities: omnidev capability list");
+			process.exit(1);
+		} else {
+			// Re-throw other errors
+			throw error;
+		}
+	}
+}

package/src/lib/debug.ts

@@ -0,0 +1,4 @@
+/**
+ * Re-export debug from core for backwards compatibility TODO: remove and update imports
+ */
+export { debug } from "@omnidev-ai/core";

package/src/lib/dynamic-app.ts

@@ -0,0 +1,182 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { CapabilityExport } from "@omnidev-ai/core";
+import { buildApplication, buildRouteMap } from "@stricli/core";
+import { capabilityRoutes } from "../commands/capability";
+// Core commands
+import { doctorCommand } from "../commands/doctor";
+import { initCommand } from "../commands/init";
+import { mcpRoutes } from "../commands/mcp";
+import { profileRoutes } from "../commands/profile";
+import { serveCommand } from "../commands/serve";
+import { syncCommand } from "../commands/sync";
+import { debug } from "./debug";
+
+/**
+ * Build CLI app with dynamically loaded capability commands
+ */
+export async function buildDynamicApp() {
+	// Start with core commands
+	const routes: Record<string, unknown> = {
+		init: initCommand,
+		doctor: doctorCommand,
+		serve: serveCommand,
+		sync: syncCommand,
+		capability: capabilityRoutes,
+		profile: profileRoutes,
+		mcp: mcpRoutes,
+	};
+
+	debug("Core routes registered", Object.keys(routes));
+
+	// Only load capability commands if initialized
+	if (existsSync(".omni/config.toml")) {
+		try {
+			const capabilityCommands = await loadCapabilityCommands();
+			debug("Capability commands loaded", {
+				commands: Object.keys(capabilityCommands),
+				details: Object.entries(capabilityCommands).map(([name, cmd]) => ({
+					name,
+					type: typeof cmd,
+					// biome-ignore lint/suspicious/noExplicitAny: Debug: access constructor name
+					constructor: (cmd as any)?.constructor?.name,
+					keys: Object.keys(cmd as object),
+					// biome-ignore lint/suspicious/noExplicitAny: Debug: check for method
+					hasGetRoutingTargetForInput: typeof (cmd as any)?.getRoutingTargetForInput,
+				})),
+			});
+			Object.assign(routes, capabilityCommands);
+		} catch (error) {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			console.warn(`Warning: Failed to load capability commands: ${errorMessage}`);
+			debug("Full error loading capabilities", error);
+			// Continue with core commands only
+		}
+	}
+
+	debug("Final routes", Object.keys(routes));
+
+	const app = buildApplication(
+		buildRouteMap({
+			// biome-ignore lint/suspicious/noExplicitAny: Dynamic commands from capabilities
+			routes: routes as any,
+			docs: {
+				brief: "OmniDev commands",
+			},
+		}),
+		{
+			name: "omnidev",
+			versionInfo: {
+				currentVersion: "0.1.0",
+			},
+		},
+	);
+
+	debug("App built successfully");
+
+	return app;
+}
+
+/**
+ * Load CLI commands from enabled capabilities
+ */
+async function loadCapabilityCommands(): Promise<Record<string, unknown>> {
+	const { buildCapabilityRegistry, installCapabilityDependencies } = await import(
+		"@omnidev-ai/core"
+	);
+
+	// Install dependencies first (silent to avoid noise during CLI startup)
+	await installCapabilityDependencies(true);
+
+	const registry = await buildCapabilityRegistry();
+	const capabilities = registry.getAllCapabilities();
+
+	const commands: Record<string, unknown> = {};
+
+	for (const capability of capabilities) {
+		try {
+			debug(`Loading capability '${capability.id}'`, { path: capability.path });
+			const capabilityExport = await loadCapabilityExport(capability);
+
+			debug(`Capability '${capability.id}' export`, {
+				found: !!capabilityExport,
+				hasCLICommands: !!capabilityExport?.cliCommands,
+				cliCommands: capabilityExport?.cliCommands ? Object.keys(capabilityExport.cliCommands) : [],
+			});
+
+			// Extract CLI commands from structured export
+			if (capabilityExport?.cliCommands) {
+				for (const [commandName, command] of Object.entries(capabilityExport.cliCommands)) {
+					if (commands[commandName]) {
+						console.warn(
+							`Command '${commandName}' from capability '${capability.id}' conflicts with existing command. Using '${capability.id}' version.`,
+						);
+					}
+					commands[commandName] = command;
+					debug(`Registered command '${commandName}' from '${capability.id}'`, {
+						type: typeof command,
+						// biome-ignore lint/suspicious/noExplicitAny: Debug: access constructor name
+						constructor: (command as any)?.constructor?.name,
+					});
+				}
+			}
+		} catch (error) {
+			console.error(`Failed to load capability '${capability.id}':`, error);
+			// Continue loading other capabilities
+		}
+	}
+
+	return commands;
+}
+
+/**
+ * Load the default export from a capability
+ */
+async function loadCapabilityExport(capability: {
+	id: string;
+	path: string;
+}): Promise<CapabilityExport | null> {
+	const capabilityPath = join(process.cwd(), capability.path);
+	const indexPath = join(capabilityPath, "index.ts");
+
+	if (!existsSync(indexPath)) {
+		// Try .js extension
+		const jsIndexPath = join(capabilityPath, "index.js");
+		if (!existsSync(jsIndexPath)) {
+			return null;
+		}
+		// Use .js path
+		const module = await import(jsIndexPath);
+		if (!module.default) {
+			return null;
+		}
+		return module.default as CapabilityExport;
+	}
+
+	const module = await import(indexPath);
+
+	// Get default export (structured capability export)
+	if (!module.default) {
+		return null;
+	}
+
+	const capExport = module.default as CapabilityExport;
+
+	// Debug: Log the actual structure of CLI commands
+	if (capExport.cliCommands) {
+		for (const [name, cmd] of Object.entries(capExport.cliCommands)) {
+			debug(`CLI command '${name}' structure`, {
+				type: typeof cmd,
+				// biome-ignore lint/suspicious/noExplicitAny: Debug: access constructor name
+				constructor: (cmd as any)?.constructor?.name,
+				keys: Object.keys(cmd as object),
+				// biome-ignore lint/suspicious/noExplicitAny: Debug: check for method
+				hasGetRoutingTargetForInput: typeof (cmd as any)?.getRoutingTargetForInput,
+				// biome-ignore lint/suspicious/noExplicitAny: Debug: access routes property
+				routesKeys: (cmd as any).routes ? Object.keys((cmd as any).routes) : undefined,
+			});
+		}
+	}
+
+	return capExport;
+}

package/src/prompts/provider.ts

@@ -0,0 +1,15 @@
+import { checkbox } from "@inquirer/prompts";
+import type { Provider } from "@omnidev-ai/core";
+
+export async function promptForProvider(): Promise<Provider[]> {
+	const answers = await checkbox({
+		message: "Select your AI provider(s):",
+		choices: [
+			{ name: "Claude (recommended)", value: "claude", checked: true },
+			{ name: "Codex", value: "codex", checked: false },
+		],
+		required: true,
+	});
+
+	return answers as Provider[];
+}