@omnidev-ai/cli 0.1.0 → 0.3.0

package/src/commands/init.ts

@@ -1,46 +1,43 @@
 import { existsSync, mkdirSync } from "node:fs";
-import type { Provider } from "@omnidev-ai/core";
+import { getAllAdapters, getEnabledAdapters } from "@omnidev-ai/adapters";
+import type { ProviderId, ProviderContext } from "@omnidev-ai/core";
 import {
-	generateAgentsTemplate,
-	generateClaudeTemplate,
 	generateInstructionsTemplate,
-	parseProviderFlag,
+	loadConfig,
 	setActiveProfile,
 	syncAgentConfiguration,
 	writeConfig,
+	writeEnabledProviders,
 } from "@omnidev-ai/core";
 import { buildCommand } from "@stricli/core";
-import { promptForProvider } from "../prompts/provider.js";
+import { promptForProviders } from "../prompts/provider.js";
 
-export async function runInit(_flags: Record<string, never>, provider?: string) {
+export async function runInit(_flags: Record<string, never>, providerArg?: string) {
 	console.log("Initializing OmniDev...");
 
 	// Create .omni/ directory structure
 	mkdirSync(".omni", { recursive: true });
 	mkdirSync(".omni/capabilities", { recursive: true });
 	mkdirSync(".omni/state", { recursive: true });
-	mkdirSync(".omni/sandbox", { recursive: true });
 
-	// Create .omni/.gitignore for internal working files
-	if (!existsSync(".omni/.gitignore")) {
-		await Bun.write(".omni/.gitignore", internalGitignore());
-	}
+	// Update root .gitignore to ignore .omni/ and omni.local.toml
+	await updateRootGitignore();
 
 	// Get provider selection
-	let providers: Provider[];
-	if (provider) {
-		providers = parseProviderFlag(provider);
+	let providerIds: ProviderId[];
+	if (providerArg) {
+		providerIds = parseProviderArg(providerArg);
 	} else {
-		providers = await promptForProvider();
+		providerIds = await promptForProviders();
 	}
 
-	// Create omni.toml at project root
+	// Save enabled providers to local state (not omni.toml)
+	await writeEnabledProviders(providerIds);
+
+	// Create omni.toml at project root (without provider config - that's in state)
 	if (!existsSync("omni.toml")) {
 		await writeConfig({
 			project: "my-project",
-			providers: {
-				enabled: providers,
-			},
 			profiles: {
 				default: {
 					capabilities: [],
@@ -53,7 +50,7 @@ export async function runInit(_flags: Record<string, never>, provider?: string)
 				},
 			},
 		});
-		// Set active profile in state file (not omni.toml)
+		// Set active profile in state file
 		await setActiveProfile("default");
 	}
 
@@ -62,61 +59,58 @@ export async function runInit(_flags: Record<string, never>, provider?: string)
 		await Bun.write(".omni/instructions.md", generateInstructionsTemplate());
 	}
 
-	// Create provider-specific files
-	const fileStatus = await createProviderFiles(providers);
+	// Load config and create provider context
+	const config = await loadConfig();
+	const ctx: ProviderContext = {
+		projectRoot: process.cwd(),
+		config,
+	};
+
+	// Initialize enabled adapters (create their root files)
+	const allAdapters = getAllAdapters();
+	const selectedAdapters = allAdapters.filter((a) => providerIds.includes(a.id));
+	const filesCreated: string[] = [];
+	const filesExisting: string[] = [];
+
+	for (const adapter of selectedAdapters) {
+		if (adapter.init) {
+			const result = await adapter.init(ctx);
+			if (result.filesCreated) {
+				filesCreated.push(...result.filesCreated);
+			}
+		}
+	}
 
-	// Run initial sync
-	await syncAgentConfiguration({ silent: false });
+	// Run initial sync with enabled adapters (silent - no need to show details)
+	const enabledAdapters = await getEnabledAdapters();
+	await syncAgentConfiguration({ silent: true, adapters: enabledAdapters });
 
+	// Output success message
 	console.log("");
-	console.log(`✓ OmniDev initialized for ${providers.join(" and ")}!`);
+	console.log(
+		`✓ OmniDev initialized for ${selectedAdapters.map((a) => a.displayName).join(" and ")}!`,
+	);
 	console.log("");
 
 	// Show appropriate message based on file status
-	const hasNewFiles = fileStatus.created.length > 0;
-	const hasExistingFiles = fileStatus.existing.length > 0;
-
-	if (hasNewFiles) {
+	if (filesCreated.length > 0) {
 		console.log("📝 Don't forget to add your project description to:");
 		console.log("   • .omni/instructions.md");
 	}
 
-	if (hasExistingFiles) {
+	if (filesExisting.length > 0) {
 		console.log("📝 Add this line to your existing file(s):");
-		for (const file of fileStatus.existing) {
+		for (const file of filesExisting) {
 			console.log(`   • ${file}: @import .omni/instructions.md`);
 		}
 	}
 
 	console.log("");
-	console.log("🔌 Add OmniDev MCP Server to your AI provider:");
-	console.log("");
-	console.log("   Add to Claude Desktop config:");
-	console.log("   {");
-	console.log('     "mcpServers": {');
-	console.log('       "omnidev": {');
-	console.log('         "command": "npx",');
-	console.log('         "args": ["-y", "@omnidev-ai/cli", "serve"]');
-	console.log("       }");
-	console.log("     }");
-	console.log("   }");
-	console.log("");
-	console.log("   Or for local development:");
-	console.log("   {");
-	console.log('     "mcpServers": {');
-	console.log('       "omnidev": {');
-	console.log('         "command": "bun",');
-	console.log('         "args": ["run", "omnidev", "serve"],');
-	console.log('         "cwd": "/path/to/your/project"');
-	console.log("       }");
-	console.log("     }");
-	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("📁 File structure:");
-	console.log("   • omni.toml - Main config (commit to share with team)");
-	console.log("   • omni.lock.toml - Lock file (commit for reproducibility)");
-	console.log("   • omni.local.toml - Local overrides (add to .gitignore)");
-	console.log("   • .omni/ - Runtime directory (add to .gitignore)");
+	console.log("   Run 'omnidev capability list' to see available capabilities.");
 }
 
 export const initCommand = buildCommand({
@@ -126,7 +120,7 @@ export const initCommand = buildCommand({
 			kind: "tuple" as const,
 			parameters: [
 				{
-					brief: "AI provider: claude, codex, or both",
+					brief: "AI provider(s): claude-code, cursor, codex, opencode, or comma-separated",
 					parse: String,
 					optional: true,
 				},
@@ -139,54 +133,56 @@ export const initCommand = buildCommand({
 	func: runInit,
 });
 
-async function createProviderFiles(
-	providers: Provider[],
-): Promise<{ created: string[]; existing: string[] }> {
-	const created: string[] = [];
-	const existing: string[] = [];
-
-	// Create AGENTS.md for Codex
-	if (providers.includes("codex")) {
-		if (!existsSync("AGENTS.md")) {
-			await Bun.write("AGENTS.md", generateAgentsTemplate());
-			created.push("AGENTS.md");
-		} else {
-			existing.push("AGENTS.md");
-		}
+function parseProviderArg(arg: string): ProviderId[] {
+	const allAdapters = getAllAdapters();
+	const validIds = new Set(allAdapters.map((a) => a.id));
+
+	// Handle legacy "both" argument
+	if (arg.toLowerCase() === "both") {
+		return ["claude-code", "cursor"];
 	}
 
-	// Create CLAUDE.md for Claude
-	if (providers.includes("claude")) {
-		if (!existsSync("CLAUDE.md")) {
-			await Bun.write("CLAUDE.md", generateClaudeTemplate());
-			created.push("CLAUDE.md");
-		} else {
-			existing.push("CLAUDE.md");
+	// Handle comma-separated list
+	const parts = arg.split(",").map((p) => p.trim().toLowerCase());
+	const result: ProviderId[] = [];
+
+	for (const part of parts) {
+		// Map legacy names
+		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 as ProviderId);
 	}
 
-	return { created, existing };
+	return result;
 }
 
-function internalGitignore(): string {
-	return `# OmniDev working files - always ignored
-# These files change frequently and are machine-specific
-
-# Secrets
-.env
+async function updateRootGitignore(): Promise<void> {
+	const gitignorePath = ".gitignore";
+	const entriesToAdd = [".omni/", "omni.local.toml"];
 
-# Runtime state
-state/
+	let content = "";
+	if (existsSync(gitignorePath)) {
+		content = await Bun.file(gitignorePath).text();
+	}
 
-# Sandbox execution
-sandbox/
+	const lines = content.split("\n");
+	const missingEntries = entriesToAdd.filter(
+		(entry) => !lines.some((line) => line.trim() === entry),
+	);
 
-# Logs
-*.log
+	if (missingEntries.length === 0) {
+		return;
+	}
 
-# MCP server process ID
-server.pid
+	// Add a newline before our section if the file doesn't end with one
+	const needsNewline = content.length > 0 && !content.endsWith("\n");
+	const section = `${needsNewline ? "\n" : ""}# OmniDev\n${missingEntries.join("\n")}\n`;
 
-# Capability-specific patterns are appended below by each capability
-`;
+	await Bun.write(gitignorePath, content + section);
 }

package/src/commands/profile.test.ts

@@ -1,23 +1,18 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { runProfileList, runProfileSet } from "./profile";
 
 describe("profile commands", () => {
-	let testDir: string;
-	let originalCwd: string;
+	setupTestDir("profile-test-", { chdir: true });
 	let originalExit: typeof process.exit;
 	let exitCode: number | undefined;
 	let consoleOutput: string[];
 	let consoleErrors: string[];
+	let originalLog: typeof console.log;
+	let originalError: typeof console.error;
 
 	beforeEach(() => {
-		// Create a unique test directory
-		testDir = join(import.meta.dir, "..", "..", "..", "test-temp", `profile-test-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-		originalCwd = process.cwd();
-		process.chdir(testDir);
-
 		// Mock process.exit
 		exitCode = undefined;
 		originalExit = process.exit;
@@ -29,28 +24,20 @@ describe("profile commands", () => {
 		// Mock console
 		consoleOutput = [];
 		consoleErrors = [];
-		const originalLog = console.log;
-		const originalError = console.error;
+		originalLog = console.log;
+		originalError = console.error;
 		console.log = (...args: unknown[]) => {
 			consoleOutput.push(args.join(" "));
 		};
 		console.error = (...args: unknown[]) => {
 			consoleErrors.push(args.join(" "));
 		};
-
-		// Restore after test (in afterEach)
-		return () => {
-			console.log = originalLog;
-			console.error = originalError;
-		};
 	});
 
 	afterEach(() => {
 		process.exit = originalExit;
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
+		console.log = originalLog;
+		console.error = originalError;
 	});
 
 	describe("runProfileList", () => {

package/src/commands/profile.ts

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { getEnabledAdapters } from "@omnidev-ai/adapters";
 import {
 	getActiveProfile,
 	loadConfig,
@@ -142,8 +143,9 @@ export async function runProfileSet(profileName: string): Promise<void> {
 		console.log(`✓ Active profile set to: ${profileName}`);
 		console.log("");
 
-		// Auto-sync agent configuration
-		await syncAgentConfiguration();
+		// Auto-sync agent configuration with enabled adapters
+		const adapters = await getEnabledAdapters();
+		await syncAgentConfiguration({ adapters });
 	} catch (error) {
 		console.error("✗ Error setting profile:", error);
 		process.exit(1);

package/src/commands/provider.test.ts

@@ -0,0 +1,128 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { captureConsole, tmpdir } from "@omnidev-ai/core/test-utils";
+import { runProviderList, runProviderEnable, runProviderDisable } from "./provider";
+
+// Import the functions we need to test
+async function getProviderFunctions() {
+	const { readEnabledProviders, writeEnabledProviders } = await import("@omnidev-ai/core");
+	return { readEnabledProviders, writeEnabledProviders };
+}
+
+describe("provider commands", () => {
+	let testDir: string;
+	let originalCwd: string;
+
+	beforeEach(async () => {
+		originalCwd = process.cwd();
+		testDir = tmpdir("provider-test-");
+		process.chdir(testDir);
+
+		// Create basic OmniDev structure
+		mkdirSync(".omni/state", { recursive: true });
+		await Bun.write("omni.toml", 'project = "test"\n');
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe("runProviderList", () => {
+		test("lists all providers with status", async () => {
+			const { writeEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code", "cursor"]);
+
+			const { stdout } = await captureConsole(async () => {
+				await runProviderList();
+			});
+
+			const output = stdout.join("\n");
+			expect(output).toContain("Available providers:");
+			expect(output).toContain("Claude Code");
+			expect(output).toContain("Cursor");
+			expect(output).toContain("Codex");
+			expect(output).toContain("OpenCode");
+		});
+
+		test("shows enabled providers with marker", async () => {
+			const { writeEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code"]);
+
+			const { stdout } = await captureConsole(async () => {
+				await runProviderList();
+			});
+
+			const output = stdout.join("\n");
+			// Should have at least one enabled marker
+			expect(output).toContain("●");
+		});
+
+		test("shows disabled providers with different marker", async () => {
+			const { writeEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code"]);
+
+			const { stdout } = await captureConsole(async () => {
+				await runProviderList();
+			});
+
+			const output = stdout.join("\n");
+			// Should have disabled markers for other providers
+			expect(output).toContain("○");
+		});
+	});
+
+	describe("runProviderEnable", () => {
+		test("enables a provider", async () => {
+			const { writeEnabledProviders, readEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code"]);
+
+			await captureConsole(async () => {
+				await runProviderEnable({}, "cursor");
+			});
+
+			const providers = await readEnabledProviders();
+			expect(providers).toContain("cursor");
+		});
+
+		test("shows success message", async () => {
+			const { writeEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code"]);
+
+			const { stdout } = await captureConsole(async () => {
+				await runProviderEnable({}, "cursor");
+			});
+
+			const output = stdout.join("\n");
+			expect(output).toContain("✓ Enabled provider: Cursor");
+		});
+	});
+
+	describe("runProviderDisable", () => {
+		test("disables a provider", async () => {
+			const { writeEnabledProviders, readEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code", "cursor"]);
+
+			await captureConsole(async () => {
+				await runProviderDisable({}, "cursor");
+			});
+
+			const providers = await readEnabledProviders();
+			expect(providers).not.toContain("cursor");
+		});
+
+		test("shows success message", async () => {
+			const { writeEnabledProviders } = await getProviderFunctions();
+			await writeEnabledProviders(["claude-code", "cursor"]);
+
+			const { stdout } = await captureConsole(async () => {
+				await runProviderDisable({}, "cursor");
+			});
+
+			const output = stdout.join("\n");
+			expect(output).toContain("✓ Disabled provider: Cursor");
+		});
+	});
+});

package/src/commands/provider.ts

@@ -0,0 +1,139 @@
+import { getAllAdapters } from "@omnidev-ai/adapters";
+import type { ProviderId } from "@omnidev-ai/core";
+import {
+	disableProvider,
+	enableProvider,
+	readEnabledProviders,
+	syncAgentConfiguration,
+} from "@omnidev-ai/core";
+import { getEnabledAdapters } from "@omnidev-ai/adapters";
+import { buildCommand, buildRouteMap } from "@stricli/core";
+
+export 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");
+}
+
+export async function runProviderEnable(_flags: Record<string, never>, providerId?: string) {
+	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 as ProviderId);
+	console.log(`✓ Enabled provider: ${adapter.displayName}`);
+
+	// Sync with newly enabled adapter
+	const enabledAdapters = await getEnabledAdapters();
+	await syncAgentConfiguration({ silent: false, adapters: enabledAdapters });
+}
+
+export async function runProviderDisable(_flags: Record<string, never>, providerId?: string) {
+	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 as ProviderId);
+	console.log(`✓ Disabled provider: ${adapter.displayName}`);
+}
+
+const listCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: { kind: "tuple" as const, parameters: [] },
+	},
+	docs: {
+		brief: "List all providers and their status",
+	},
+	func: runProviderList,
+});
+
+const enableCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple" as const,
+			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" as const,
+			parameters: [
+				{
+					brief: "Provider ID to disable",
+					parse: String,
+					optional: true,
+				},
+			],
+		},
+	},
+	docs: {
+		brief: "Disable a provider",
+	},
+	func: runProviderDisable,
+});
+
+export const providerRoutes = buildRouteMap({
+	routes: {
+		list: listCommand,
+		enable: enableCommand,
+		disable: disableCommand,
+	},
+	docs: {
+		brief: "Manage AI provider adapters",
+	},
+});

package/src/commands/sync.ts

@@ -1,9 +1,10 @@
+import { getEnabledAdapters } from "@omnidev-ai/adapters";
 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",
+		brief: "Manually sync all capabilities, roles, and instructions",
 	},
 	parameters: {},
 	async func() {
@@ -19,21 +20,26 @@ export async function runSync(): Promise<void> {
 		const config = await loadConfig();
 		const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
 
-		const result = await syncAgentConfiguration({ silent: false });
+		// Get enabled adapters for provider-specific sync
+		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");
-		console.log("  • .claude/skills/");
-		console.log("  • .cursor/rules/");
+		if (adapters.length > 0) {
+			console.log("  • Provider-specific files");
+		}
 	} catch (error) {
 		console.error("");
 		console.error("✗ Sync failed:");

package/src/index.ts

@@ -2,8 +2,8 @@
 /**
  * @omnidev-ai/cli - Command-line interface for OmniDev
  *
- * This package provides the CLI for managing OmniDev configuration,
- * capabilities, and the MCP server.
+ * This package provides the CLI for managing OmniDev configuration
+ * and capabilities.
  */
 
 import { run } from "@stricli/core";