@omnidev-ai/cli 0.1.1 → 0.4.0

package/dist/index.js

@@ -0,0 +1,772 @@
+#!/usr/bin/env node
+import { buildApplication, buildCommand, buildRouteMap, run } from "@stricli/core";
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { getAllAdapters, getEnabledAdapters } from "@omnidev-ai/adapters";
+import { debug, disableCapability, disableProvider, discoverCapabilities, enableCapability, enableProvider, generateInstructionsTemplate, getActiveProfile, getEnabledCapabilities, loadCapabilityConfig, loadConfig, readEnabledProviders, resolveEnabledCapabilities, setActiveProfile, syncAgentConfiguration, writeConfig, writeEnabledProviders } from "@omnidev-ai/core";
+import { checkbox } from "@inquirer/prompts";
+
+//#region src/commands/capability.ts
+/**
+* Run the capability list command.
+*/
+async function runCapabilityList() {
+	try {
+		const enabledIds = await getEnabledCapabilities();
+		const capabilityPaths = await discoverCapabilities();
+		if (capabilityPaths.length === 0) {
+			console.log("No capabilities found.");
+			console.log("");
+			console.log("To add capabilities, create directories in omni/capabilities/");
+			console.log("Each capability must have a capability.toml file.");
+			return;
+		}
+		console.log("Capabilities:");
+		console.log("");
+		for (const path of capabilityPaths) try {
+			const capConfig = await loadCapabilityConfig(path);
+			const isEnabled = enabledIds.includes(capConfig.capability.id);
+			const status = isEnabled ? "✓ enabled" : "✗ disabled";
+			const { id, name, version } = capConfig.capability;
+			console.log(`  ${status}  ${name}`);
+			console.log(`           ID: ${id}`);
+			console.log(`           Version: ${version}`);
+			console.log("");
+		} catch (error) {
+			console.error(`  ✗ Failed to load capability at ${path}:`, error);
+			console.log("");
+		}
+	} catch (error) {
+		console.error("Error listing capabilities:", error);
+		process.exit(1);
+	}
+}
+/**
+* Run the capability enable command.
+*/
+async function runCapabilityEnable(_flags, name) {
+	try {
+		const capabilityPaths = await discoverCapabilities();
+		const capabilityExists = capabilityPaths.some(async (path) => {
+			const config = await loadCapabilityConfig(path);
+			return config.capability.id === name;
+		});
+		if (!capabilityExists) {
+			console.error(`Error: Capability '${name}' not found`);
+			console.log("");
+			console.log("Run 'dev capability list' to see available capabilities");
+			process.exit(1);
+		}
+		await enableCapability(name);
+		console.log(`✓ Enabled capability: ${name}`);
+		console.log("");
+		const adapters = await getEnabledAdapters();
+		await syncAgentConfiguration({ adapters });
+	} catch (error) {
+		console.error("Error enabling capability:", error);
+		process.exit(1);
+	}
+}
+/**
+* Run the capability disable command.
+*/
+async function runCapabilityDisable(_flags, name) {
+	try {
+		await disableCapability(name);
+		console.log(`✓ Disabled capability: ${name}`);
+		console.log("");
+		const adapters = await getEnabledAdapters();
+		await syncAgentConfiguration({ adapters });
+	} catch (error) {
+		console.error("Error disabling capability:", error);
+		process.exit(1);
+	}
+}
+const listCommand$2 = buildCommand({
+	docs: { brief: "List all discovered capabilities" },
+	parameters: {},
+	async func() {
+		await runCapabilityList();
+	}
+});
+const enableCommand$1 = buildCommand({
+	docs: { brief: "Enable a capability" },
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Capability name to enable",
+				parse: String
+			}]
+		}
+	},
+	func: runCapabilityEnable
+});
+const disableCommand$1 = buildCommand({
+	docs: { brief: "Disable a capability" },
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Capability name to disable",
+				parse: String
+			}]
+		}
+	},
+	func: runCapabilityDisable
+});
+const capabilityRoutes = buildRouteMap({
+	routes: {
+		list: listCommand$2,
+		enable: enableCommand$1,
+		disable: disableCommand$1
+	},
+	docs: { brief: "Manage capabilities" }
+});
+
+//#endregion
+//#region src/commands/doctor.ts
+const doctorCommand = buildCommand({
+	docs: { brief: "Check OmniDev setup and dependencies" },
+	parameters: {},
+	async func() {
+		return await runDoctor();
+	}
+});
+async function runDoctor() {
+	console.log("OmniDev Doctor");
+	console.log("==============");
+	console.log("");
+	const checks = [
+		checkBunVersion(),
+		checkOmniLocalDir(),
+		checkConfig(),
+		checkRootGitignore(),
+		checkCapabilitiesDir()
+	];
+	let allPassed = true;
+	for (const check of checks) {
+		const { name, passed, message, fix } = await check;
+		const icon = passed ? "✓" : "✗";
+		console.log(`${icon} ${name}: ${message}`);
+		if (!passed && fix) console.log(`  Fix: ${fix}`);
+		if (!passed) allPassed = false;
+	}
+	console.log("");
+	if (allPassed) console.log("All checks passed!");
+	else {
+		console.log("Some checks failed. Please fix the issues above.");
+		process.exit(1);
+	}
+}
+async function checkBunVersion() {
+	const version = Bun.version;
+	const parts = version.split(".");
+	const firstPart = parts[0];
+	if (!firstPart) return {
+		name: "Bun Version",
+		passed: false,
+		message: `Invalid version format: ${version}`,
+		fix: "Reinstall Bun: curl -fsSL https://bun.sh/install | bash"
+	};
+	const major = Number.parseInt(firstPart, 10);
+	if (major < 1) return {
+		name: "Bun Version",
+		passed: false,
+		message: `v${version}`,
+		fix: "Upgrade Bun: curl -fsSL https://bun.sh/install | bash"
+	};
+	return {
+		name: "Bun Version",
+		passed: true,
+		message: `v${version}`
+	};
+}
+async function checkOmniLocalDir() {
+	const exists = existsSync(".omni");
+	if (!exists) return {
+		name: ".omni/ directory",
+		passed: false,
+		message: "Not found",
+		fix: "Run: omnidev init"
+	};
+	return {
+		name: ".omni/ directory",
+		passed: true,
+		message: "Found"
+	};
+}
+async function checkConfig() {
+	const configPath = "omni.toml";
+	if (!existsSync(configPath)) return {
+		name: "Configuration",
+		passed: false,
+		message: "omni.toml not found",
+		fix: "Run: omnidev init"
+	};
+	try {
+		const { loadConfig: loadConfig$1 } = await import("@omnidev-ai/core");
+		await loadConfig$1();
+		return {
+			name: "Configuration",
+			passed: true,
+			message: "Valid"
+		};
+	} catch (error) {
+		return {
+			name: "Configuration",
+			passed: false,
+			message: `Invalid: ${error instanceof Error ? error.message : String(error)}`,
+			fix: "Check omni.toml syntax"
+		};
+	}
+}
+async function checkRootGitignore() {
+	const gitignorePath = ".gitignore";
+	if (!existsSync(gitignorePath)) return {
+		name: "Root .gitignore",
+		passed: false,
+		message: ".gitignore not found",
+		fix: "Run: omnidev init"
+	};
+	const content = await Bun.file(gitignorePath).text();
+	const lines = content.split("\n").map((line) => line.trim());
+	const hasOmniDir = lines.includes(".omni/");
+	const hasLocalToml = lines.includes("omni.local.toml");
+	if (!hasOmniDir || !hasLocalToml) {
+		const missing = [];
+		if (!hasOmniDir) missing.push(".omni/");
+		if (!hasLocalToml) missing.push("omni.local.toml");
+		return {
+			name: "Root .gitignore",
+			passed: false,
+			message: `Missing entries: ${missing.join(", ")}`,
+			fix: "Run: omnidev init"
+		};
+	}
+	return {
+		name: "Root .gitignore",
+		passed: true,
+		message: "Found with OmniDev entries"
+	};
+}
+async function checkCapabilitiesDir() {
+	const capabilitiesDirPath = ".omni/capabilities";
+	if (!existsSync(capabilitiesDirPath)) return {
+		name: "Capabilities Directory",
+		passed: true,
+		message: "Not found (no custom capabilities)"
+	};
+	return {
+		name: "Capabilities Directory",
+		passed: true,
+		message: "Found"
+	};
+}
+
+//#endregion
+//#region src/prompts/provider.ts
+async function promptForProviders() {
+	const answers = await checkbox({
+		message: "Select your AI provider(s):",
+		choices: [
+			{
+				name: "Claude Code (Claude CLI)",
+				value: "claude-code",
+				checked: true
+			},
+			{
+				name: "Cursor",
+				value: "cursor",
+				checked: false
+			},
+			{
+				name: "Codex",
+				value: "codex",
+				checked: false
+			},
+			{
+				name: "OpenCode",
+				value: "opencode",
+				checked: false
+			}
+		],
+		required: true
+	});
+	return answers;
+}
+
+//#endregion
+//#region src/commands/init.ts
+async function runInit(_flags, providerArg) {
+	console.log("Initializing OmniDev...");
+	mkdirSync(".omni", { recursive: true });
+	mkdirSync(".omni/capabilities", { recursive: true });
+	mkdirSync(".omni/state", { recursive: true });
+	await updateRootGitignore();
+	let providerIds;
+	if (providerArg) providerIds = parseProviderArg(providerArg);
+	else providerIds = await promptForProviders();
+	await writeEnabledProviders(providerIds);
+	if (!existsSync("omni.toml")) {
+		await writeConfig({
+			project: "my-project",
+			profiles: {
+				default: { capabilities: [] },
+				planning: { capabilities: [] },
+				coding: { capabilities: [] }
+			}
+		});
+		await setActiveProfile("default");
+	}
+	if (!existsSync(".omni/instructions.md")) await Bun.write(".omni/instructions.md", generateInstructionsTemplate());
+	const config = await loadConfig();
+	const ctx = {
+		projectRoot: process.cwd(),
+		config
+	};
+	const allAdapters = getAllAdapters();
+	const selectedAdapters = allAdapters.filter((a) => providerIds.includes(a.id));
+	const filesCreated = [];
+	const filesExisting = [];
+	for (const adapter of selectedAdapters) if (adapter.init) {
+		const result = await adapter.init(ctx);
+		if (result.filesCreated) filesCreated.push(...result.filesCreated);
+	}
+	const enabledAdapters = await getEnabledAdapters();
+	await syncAgentConfiguration({
+		silent: true,
+		adapters: enabledAdapters
+	});
+	console.log("");
+	console.log(`✓ OmniDev initialized for ${selectedAdapters.map((a) => a.displayName).join(" and ")}!`);
+	console.log("");
+	if (filesCreated.length > 0) {
+		console.log("📝 Don't forget to add your project description to:");
+		console.log("   • .omni/instructions.md");
+	}
+	if (filesExisting.length > 0) {
+		console.log("📝 Add this line to your existing file(s):");
+		for (const file of filesExisting) console.log(`   • ${file}: @import .omni/instructions.md`);
+	}
+	console.log("");
+	console.log("💡 Recommendation:");
+	console.log("   Add provider-specific files to .gitignore:");
+	console.log("   CLAUDE.md, .claude/, AGENTS.md, .cursor/, .mcp.json");
+	console.log("");
+	console.log("   Run 'omnidev capability list' to see available capabilities.");
+}
+const initCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "AI provider(s): claude-code, cursor, codex, opencode, or comma-separated",
+				parse: String,
+				optional: true
+			}]
+		}
+	},
+	docs: { brief: "Initialize OmniDev in the current project" },
+	func: runInit
+});
+function parseProviderArg(arg) {
+	const allAdapters = getAllAdapters();
+	const validIds = new Set(allAdapters.map((a) => a.id));
+	if (arg.toLowerCase() === "both") return ["claude-code", "cursor"];
+	const parts = arg.split(",").map((p) => p.trim().toLowerCase());
+	const result = [];
+	for (const part of parts) {
+		let id = part;
+		if (id === "claude") id = "claude-code";
+		if (!validIds.has(id)) throw new Error(`Invalid provider: ${part}. Valid providers: ${[...validIds].join(", ")}`);
+		result.push(id);
+	}
+	return result;
+}
+async function updateRootGitignore() {
+	const gitignorePath = ".gitignore";
+	const entriesToAdd = [".omni/", "omni.local.toml"];
+	let content = "";
+	if (existsSync(gitignorePath)) content = await Bun.file(gitignorePath).text();
+	const lines = content.split("\n");
+	const missingEntries = entriesToAdd.filter((entry) => !lines.some((line) => line.trim() === entry));
+	if (missingEntries.length === 0) return;
+	const needsNewline = content.length > 0 && !content.endsWith("\n");
+	const section = `${needsNewline ? "\n" : ""}# OmniDev\n${missingEntries.join("\n")}\n`;
+	await Bun.write(gitignorePath, content + section);
+}
+
+//#endregion
+//#region src/commands/profile.ts
+const listCommand$1 = buildCommand({
+	docs: { brief: "List available profiles" },
+	parameters: {},
+	async func() {
+		await runProfileList();
+	}
+});
+async function runSetCommand(_flags, profileName) {
+	await runProfileSet(profileName);
+}
+const setCommand = buildCommand({
+	docs: { brief: "Set the active profile" },
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Profile name",
+				parse: String
+			}]
+		}
+	},
+	func: runSetCommand
+});
+const profileRoutes = buildRouteMap({
+	routes: {
+		list: listCommand$1,
+		set: setCommand
+	},
+	docs: { brief: "Manage capability profiles" }
+});
+async function runProfileList() {
+	try {
+		if (!existsSync("omni.toml")) {
+			console.log("✗ No config file found");
+			console.log("  Run: omnidev init");
+			process.exit(1);
+		}
+		const config = await loadConfig();
+		const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+		const profiles = config.profiles ?? {};
+		const profileNames = Object.keys(profiles);
+		if (profileNames.length === 0) {
+			console.log("No profiles defined in omni.toml");
+			console.log("");
+			console.log("Using default capabilities from omni.toml");
+			return;
+		}
+		console.log("Available Profiles:");
+		console.log("");
+		for (const name of profileNames) {
+			const isActive = name === activeProfile;
+			const icon = isActive ? "●" : "○";
+			const profile = profiles[name];
+			if (profile === void 0) continue;
+			console.log(`${icon} ${name}${isActive ? " (active)" : ""}`);
+			const capabilities = resolveEnabledCapabilities(config, name);
+			if (capabilities.length > 0) console.log(`  Capabilities: ${capabilities.join(", ")}`);
+			else console.log("  Capabilities: none");
+			console.log("");
+		}
+	} catch (error) {
+		console.error("✗ Error loading profiles:", error);
+		process.exit(1);
+	}
+}
+async function runProfileSet(profileName) {
+	try {
+		if (!existsSync("omni.toml")) {
+			console.log("✗ No config file found");
+			console.log("  Run: omnidev init");
+			process.exit(1);
+		}
+		const config = await loadConfig();
+		const profiles = config.profiles ?? {};
+		if (!(profileName in profiles)) {
+			console.log(`✗ Profile "${profileName}" not found in omni.toml`);
+			console.log("");
+			console.log("Available profiles:");
+			const profileNames = Object.keys(profiles);
+			if (profileNames.length === 0) console.log("  (none defined)");
+			else for (const name of profileNames) console.log(`  - ${name}`);
+			process.exit(1);
+		}
+		await setActiveProfile(profileName);
+		console.log(`✓ Active profile set to: ${profileName}`);
+		console.log("");
+		const adapters = await getEnabledAdapters();
+		await syncAgentConfiguration({ adapters });
+	} catch (error) {
+		console.error("✗ Error setting profile:", error);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/commands/provider.ts
+async function runProviderList() {
+	const enabled = await readEnabledProviders();
+	const allAdapters = getAllAdapters();
+	console.log("Available providers:");
+	console.log("");
+	for (const adapter of allAdapters) {
+		const isEnabled = enabled.includes(adapter.id);
+		const marker = isEnabled ? "●" : "○";
+		console.log(`  ${marker} ${adapter.displayName} (${adapter.id})`);
+	}
+	console.log("");
+	console.log("Legend: ● enabled, ○ disabled");
+}
+async function runProviderEnable(_flags, providerId) {
+	if (!providerId) {
+		console.error("Error: Provider ID is required");
+		console.error("Usage: omnidev provider enable <provider-id>");
+		process.exit(1);
+	}
+	const allAdapters = getAllAdapters();
+	const adapter = allAdapters.find((a) => a.id === providerId);
+	if (!adapter) {
+		console.error(`Error: Unknown provider "${providerId}"`);
+		console.error("Available providers:");
+		for (const a of allAdapters) console.error(`  - ${a.id}`);
+		process.exit(1);
+	}
+	await enableProvider(providerId);
+	console.log(`✓ Enabled provider: ${adapter.displayName}`);
+	const enabledAdapters = await getEnabledAdapters();
+	await syncAgentConfiguration({
+		silent: false,
+		adapters: enabledAdapters
+	});
+}
+async function runProviderDisable(_flags, providerId) {
+	if (!providerId) {
+		console.error("Error: Provider ID is required");
+		console.error("Usage: omnidev provider disable <provider-id>");
+		process.exit(1);
+	}
+	const allAdapters = getAllAdapters();
+	const adapter = allAdapters.find((a) => a.id === providerId);
+	if (!adapter) {
+		console.error(`Error: Unknown provider "${providerId}"`);
+		console.error("Available providers:");
+		for (const a of allAdapters) console.error(`  - ${a.id}`);
+		process.exit(1);
+	}
+	await disableProvider(providerId);
+	console.log(`✓ Disabled provider: ${adapter.displayName}`);
+}
+const listCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	docs: { brief: "List all providers and their status" },
+	func: runProviderList
+});
+const enableCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Provider ID to enable",
+				parse: String,
+				optional: true
+			}]
+		}
+	},
+	docs: { brief: "Enable a provider" },
+	func: runProviderEnable
+});
+const disableCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Provider ID to disable",
+				parse: String,
+				optional: true
+			}]
+		}
+	},
+	docs: { brief: "Disable a provider" },
+	func: runProviderDisable
+});
+const providerRoutes = buildRouteMap({
+	routes: {
+		list: listCommand,
+		enable: enableCommand,
+		disable: disableCommand
+	},
+	docs: { brief: "Manage AI provider adapters" }
+});
+
+//#endregion
+//#region src/commands/sync.ts
+const syncCommand = buildCommand({
+	docs: { brief: "Manually sync all capabilities, roles, and instructions" },
+	parameters: {},
+	async func() {
+		return await runSync();
+	}
+});
+async function runSync() {
+	console.log("Syncing OmniDev configuration...");
+	console.log("");
+	try {
+		const config = await loadConfig();
+		const activeProfile = await getActiveProfile() ?? config.active_profile ?? "default";
+		const adapters = await getEnabledAdapters();
+		const result = await syncAgentConfiguration({
+			silent: false,
+			adapters
+		});
+		console.log("");
+		console.log("✓ Sync completed successfully!");
+		console.log("");
+		console.log(`Profile: ${activeProfile}`);
+		console.log(`Capabilities: ${result.capabilities.join(", ") || "none"}`);
+		console.log(`Providers: ${adapters.map((a) => a.displayName).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");
+		if (adapters.length > 0) console.log("  • Provider-specific files");
+	} catch (error) {
+		console.error("");
+		console.error("✗ Sync failed:");
+		console.error(`  ${error instanceof Error ? error.message : String(error)}`);
+		process.exit(1);
+	}
+}
+
+//#endregion
+//#region src/lib/dynamic-app.ts
+/**
+* Build CLI app with dynamically loaded capability commands
+*/
+async function buildDynamicApp() {
+	const routes = {
+		init: initCommand,
+		doctor: doctorCommand,
+		sync: syncCommand,
+		capability: capabilityRoutes,
+		profile: profileRoutes,
+		provider: providerRoutes
+	};
+	debug("Core routes registered", Object.keys(routes));
+	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,
+				constructor: cmd?.constructor?.name,
+				keys: Object.keys(cmd),
+				hasGetRoutingTargetForInput: typeof cmd?.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);
+	}
+	debug("Final routes", Object.keys(routes));
+	const app$1 = buildApplication(buildRouteMap({
+		routes,
+		docs: { brief: "OmniDev commands" }
+	}), {
+		name: "omnidev",
+		versionInfo: { currentVersion: "0.1.0" }
+	});
+	debug("App built successfully");
+	return app$1;
+}
+/**
+* Load CLI commands from enabled capabilities
+*/
+async function loadCapabilityCommands() {
+	const { buildCapabilityRegistry, installCapabilityDependencies } = await import("@omnidev-ai/core");
+	await installCapabilityDependencies(true);
+	const registry = await buildCapabilityRegistry();
+	const capabilities = registry.getAllCapabilities();
+	const commands = {};
+	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) : []
+		});
+		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,
+				constructor: command?.constructor?.name
+			});
+		}
+	} catch (error) {
+		console.error(`Failed to load capability '${capability.id}':`, error);
+	}
+	return commands;
+}
+/**
+* Load the default export from a capability
+*/
+async function loadCapabilityExport(capability) {
+	const capabilityPath = join(process.cwd(), capability.path);
+	const indexPath = join(capabilityPath, "index.ts");
+	if (!existsSync(indexPath)) {
+		const jsIndexPath = join(capabilityPath, "index.js");
+		if (!existsSync(jsIndexPath)) return null;
+		const module$1 = await import(jsIndexPath);
+		if (!module$1.default) return null;
+		return module$1.default;
+	}
+	const module = await import(indexPath);
+	if (!module.default) return null;
+	const capExport = module.default;
+	if (capExport.cliCommands) for (const [name, cmd] of Object.entries(capExport.cliCommands)) debug(`CLI command '${name}' structure`, {
+		type: typeof cmd,
+		constructor: cmd?.constructor?.name,
+		keys: Object.keys(cmd),
+		hasGetRoutingTargetForInput: typeof cmd?.getRoutingTargetForInput,
+		routesKeys: cmd.routes ? Object.keys(cmd.routes) : void 0
+	});
+	return capExport;
+}
+
+//#endregion
+//#region src/index.ts
+const app = await buildDynamicApp();
+debug("CLI startup", {
+	arguments: process.argv.slice(2),
+	cwd: process.cwd()
+});
+try {
+	run(app, process.argv.slice(2), { process });
+} catch (error) {
+	if (error instanceof Error) 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 throw error;
+}
+
+//#endregion