@omnidev-ai/cli 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/cli",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {
@@ -9,7 +9,9 @@
 		"directory": "packages/cli"
 	},
 	"exports": {
-		".": "./src/index.ts"
+		".": "./src/index.ts",
+		"./commands/init": "./src/commands/init.ts",
+		"./commands/sync": "./src/commands/sync.ts"
 	},
 	"bin": {
 		"omnidev": "./src/index.ts"
@@ -28,7 +30,8 @@
 	},
 	"dependencies": {
 		"@inquirer/prompts": "^8.1.0",
-		"@omnidev-ai/core": "workspace:*",
+		"@omnidev-ai/adapters": "^0.3.0",
+		"@omnidev-ai/core": "^0.3.0",
 		"@stricli/core": "^1.2.5"
 	},
 	"devDependencies": {}

package/src/commands/AGENTS.md

@@ -10,13 +10,11 @@ Static CLI commands built with Stricli framework for OmniDev project management.
 | Command | File | Purpose |
 |---------|------|---------|
 | `omnidev init` | init.ts | Creates .omni/ directory, config.toml, provider.toml, instructions.md, internal gitignore |
-| `omnidev serve` | serve.ts | Starts MCP server via @omnidev-ai/mcp, optional --profile flag sets active profile |
 | `omnidev doctor` | doctor.ts | Validates Bun version (≥1.0), .omni/ directory, config.toml, internal gitignore |
 | `omnidev capability` | capability.ts | Subcommands: list, enable <name>, disable <name> (auto-syncs on enable/disable) |
 | `omnidev profile` | profile.ts | Subcommands: list, set <name> (auto-syncs on set, shows active with ● indicator) |
 | `omnidev ralph` | ralph.ts | Orchestrator: init, start [--agent/--iterations/--prd], stop, status; prd/story/spec/log/patterns subcommands |
 | `omnidev sync` | sync.ts | Manual agent configuration sync (capabilities, skills, rules, .omni/.gitignore) |
-| `omnidev mcp status` | mcp.ts | Shows MCP controller status from .omni/state/mcp-status.json |
 
 ## CONVENTIONS
 

package/src/commands/capability.test.ts

@@ -1,20 +1,14 @@
 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 { runCapabilityDisable, runCapabilityEnable, runCapabilityList } from "./capability";
 
 describe("capability list command", () => {
-	let testDir: string;
-	let originalCwd: string;
+	setupTestDir("capability-test-", { chdir: true });
 	let originalExit: typeof process.exit;
 	let exitCode: number | undefined;
 
 	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = join(import.meta.dir, `test-capability-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-		process.chdir(testDir);
-
 		// Mock process.exit
 		exitCode = undefined;
 		originalExit = process.exit;
@@ -26,10 +20,6 @@ describe("capability list command", () => {
 
 	afterEach(() => {
 		process.exit = originalExit;
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("shows message when no capabilities found", async () => {
@@ -307,17 +297,11 @@ capabilities = ["alpha", "beta", "gamma"]
 });
 
 describe("capability enable command", () => {
-	let testDir: string;
-	let originalCwd: string;
+	setupTestDir("capability-enable-test-", { chdir: true });
 	let originalExit: typeof process.exit;
 	let exitCode: number | undefined;
 
 	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = join(import.meta.dir, `test-capability-enable-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-		process.chdir(testDir);
-
 		// Mock process.exit
 		exitCode = undefined;
 		originalExit = process.exit;
@@ -329,10 +313,6 @@ describe("capability enable command", () => {
 
 	afterEach(() => {
 		process.exit = originalExit;
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("enables a capability", async () => {
@@ -419,17 +399,11 @@ capabilities = []
 });
 
 describe("capability disable command", () => {
-	let testDir: string;
-	let originalCwd: string;
+	setupTestDir("capability-disable-test-", { chdir: true });
 	let originalExit: typeof process.exit;
 	let _exitCode: number | undefined;
 
 	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = join(import.meta.dir, `test-capability-disable-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-		process.chdir(testDir);
-
 		// Mock process.exit
 		_exitCode = undefined;
 		originalExit = process.exit;
@@ -441,10 +415,6 @@ describe("capability disable command", () => {
 
 	afterEach(() => {
 		process.exit = originalExit;
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("disables a capability", async () => {

package/src/commands/capability.ts

@@ -1,3 +1,4 @@
+import { getEnabledAdapters } from "@omnidev-ai/adapters";
 import {
 	disableCapability,
 	discoverCapabilities,
@@ -75,8 +76,9 @@ export async function runCapabilityEnable(
 		console.log(`✓ Enabled capability: ${name}`);
 		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 enabling capability:", error);
 		process.exit(1);
@@ -95,8 +97,9 @@ export async function runCapabilityDisable(
 		console.log(`✓ Disabled capability: ${name}`);
 		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 disabling capability:", error);
 		process.exit(1);

package/src/commands/doctor.test.ts

@@ -1,11 +1,10 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { runDoctor } from "./doctor";
 
 describe("doctor command", () => {
-	let testDir: string;
-	let originalCwd: string;
+	setupTestDir("doctor-test-", { chdir: true });
 	let originalExit: typeof process.exit;
 	let exitCalled: boolean;
 	let exitCode: number;
@@ -29,30 +28,15 @@ capabilities = []
 `,
 		);
 		writeFileSync(
-			".omni/.gitignore",
-			`# OmniDev Core
-.env
-generated/
-state/
-sandbox/
-*.log
+			".gitignore",
+			`# OmniDev
+.omni/
+omni.local.toml
 `,
 		);
 	}
 
 	beforeEach(() => {
-		// Create a unique test directory
-		testDir = join(
-			process.cwd(),
-			".test-tmp",
-			`doctor-test-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
-		);
-		mkdirSync(testDir, { recursive: true });
-
-		// Change to test directory
-		originalCwd = process.cwd();
-		process.chdir(testDir);
-
 		// Mock process.exit
 		exitCalled = false;
 		exitCode = 0;
@@ -66,14 +50,6 @@ sandbox/
 	afterEach(() => {
 		// Restore process.exit
 		process.exit = originalExit;
-
-		// Restore working directory
-		process.chdir(originalCwd);
-
-		// Clean up test directory
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("should pass all checks when setup is complete", async () => {
@@ -163,7 +139,29 @@ sandbox/
 		expect(exitCalled).toBe(false);
 	});
 
-	test("should validate internal .gitignore exists", async () => {
+	test("should validate root .gitignore has OmniDev entries", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			"omni.toml",
+			`project = "test"
+active_profile = "default"
+
+[providers]
+enabled = ["claude"]
+
+[profiles.default]
+capabilities = []
+`,
+		);
+		// Missing root .gitignore
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should fail when root .gitignore is missing OmniDev entries", async () => {
 		mkdirSync(".omni", { recursive: true });
 		writeFileSync(
 			"omni.toml",
@@ -177,7 +175,8 @@ enabled = ["claude"]
 capabilities = []
 `,
 		);
-		// Missing .omni/.gitignore
+		// .gitignore exists but missing OmniDev entries
+		writeFileSync(".gitignore", "node_modules/\n");
 
 		await runDoctor();
 

package/src/commands/doctor.ts

@@ -20,7 +20,7 @@ export async function runDoctor(): Promise<void> {
 		checkBunVersion(),
 		checkOmniLocalDir(),
 		checkConfig(),
-		checkInternalGitignore(),
+		checkRootGitignore(),
 		checkCapabilitiesDir(),
 	];
 
@@ -128,21 +128,38 @@ async function checkConfig(): Promise<Check> {
 	}
 }
 
-async function checkInternalGitignore(): Promise<Check> {
-	const gitignorePath = ".omni/.gitignore";
+async function checkRootGitignore(): Promise<Check> {
+	const gitignorePath = ".gitignore";
 	if (!existsSync(gitignorePath)) {
 		return {
-			name: "Internal .gitignore",
+			name: "Root .gitignore",
 			passed: false,
-			message: ".omni/.gitignore not found",
+			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: string[] = [];
+		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: "Internal .gitignore",
+		name: "Root .gitignore",
 		passed: true,
-		message: "Found",
+		message: "Found with OmniDev entries",
 	};
 }
 

package/src/commands/init.test.ts

@@ -1,35 +1,20 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { runInit } from "./init";
 
 describe("init command", () => {
-	let testDir: string;
-	let originalCwd: string;
-
-	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = join(import.meta.dir, `test-init-${Date.now()}`);
-		mkdirSync(testDir, { recursive: true });
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
+	setupTestDir("init-test-", { chdir: true });
 
 	test("creates .omni/ directory", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		expect(existsSync(".omni")).toBe(true);
 		expect(existsSync(".omni/capabilities")).toBe(true);
 	});
 
 	test("creates omni.toml with default config", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		expect(existsSync("omni.toml")).toBe(true);
 
@@ -41,14 +26,14 @@ describe("init command", () => {
 		expect(content).toContain("[profiles.default]");
 		expect(content).toContain("[profiles.planning]");
 		expect(content).toContain("[profiles.coding]");
-		// providers should be in config.toml
-		expect(content).toContain("[providers]");
+		// providers are stored in local state, not config.toml
+		expect(content).not.toContain("[providers]");
 		// should have documentation comments
 		expect(content).toContain("# OmniDev Configuration");
 	});
 
 	test("creates active profile in state file", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		expect(existsSync(".omni/state/active-profile")).toBe(true);
 
@@ -56,37 +41,47 @@ describe("init command", () => {
 		expect(content).toBe("default");
 	});
 
+	test("stores enabled providers in local state file", async () => {
+		await runInit({}, "claude-code");
+
+		expect(existsSync(".omni/state/providers.json")).toBe(true);
+
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		expect(state.enabled).toContain("claude-code");
+	});
+
 	test("does not create separate capabilities.toml file", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		// All config is unified in config.toml
 		expect(existsSync(".omni/capabilities.toml")).toBe(false);
 	});
 
 	test("does not create separate profiles.toml file", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		// Profiles are in config.toml
 		expect(existsSync(".omni/profiles.toml")).toBe(false);
 	});
 
 	test("creates .omni/ directory with subdirectories", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		expect(existsSync(".omni")).toBe(true);
 		expect(existsSync(".omni/state")).toBe(true);
-		expect(existsSync(".omni/sandbox")).toBe(true);
 	});
 
 	test("does not create separate provider.toml file", async () => {
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
-		// Providers are in config.toml
+		// Provider state is in .omni/state/providers.json
 		expect(existsSync(".omni/provider.toml")).toBe(false);
 
-		// Verify provider is in config.toml instead
-		const content = readFileSync("omni.toml", "utf-8");
-		expect(content).toContain('enabled = ["claude"]');
+		// Verify provider is in state file instead
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		expect(state.enabled).toContain("claude-code");
 	});
 
 	test("creates AGENTS.md for Codex provider", async () => {
@@ -112,14 +107,14 @@ describe("init command", () => {
 		expect(content).toContain("No capabilities enabled yet");
 	});
 
-	test("does not create AGENTS.md for Claude provider", async () => {
-		await runInit({}, "claude");
+	test("does not create AGENTS.md for Claude Code provider", async () => {
+		await runInit({}, "claude-code");
 
 		expect(existsSync("AGENTS.md")).toBe(false);
 	});
 
-	test("creates CLAUDE.md for Claude provider", async () => {
-		await runInit({}, "claude");
+	test("creates CLAUDE.md for Claude Code provider", async () => {
+		await runInit({}, "claude-code");
 
 		expect(existsSync("CLAUDE.md")).toBe(true);
 
@@ -134,15 +129,12 @@ describe("init command", () => {
 		expect(existsSync("CLAUDE.md")).toBe(false);
 	});
 
-	test("creates both AGENTS.md and CLAUDE.md for 'both' providers", async () => {
+	test("creates both CLAUDE.md and .cursor/rules/ for 'both' providers", async () => {
+		// "both" maps to claude-code and cursor
 		await runInit({}, "both");
 
-		expect(existsSync("AGENTS.md")).toBe(true);
 		expect(existsSync("CLAUDE.md")).toBe(true);
-
-		const agentsContent = readFileSync("AGENTS.md", "utf-8");
-		expect(agentsContent).toContain("# Project Instructions");
-		expect(agentsContent).toContain("@import .omni/instructions.md");
+		expect(existsSync(".cursor/rules")).toBe(true);
 
 		const claudeContent = readFileSync("CLAUDE.md", "utf-8");
 		expect(claudeContent).toContain("# Project Instructions");
@@ -153,7 +145,7 @@ describe("init command", () => {
 		const existingContent = "# My Existing Config\n\nExisting content here.\n";
 		await Bun.write("CLAUDE.md", existingContent);
 
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		const content = readFileSync("CLAUDE.md", "utf-8");
 		expect(content).toBe(existingContent);
@@ -169,47 +161,58 @@ describe("init command", () => {
 		expect(content).toBe(existingContent);
 	});
 
-	test("creates .omni/.gitignore with internal patterns", async () => {
-		await runInit({}, "claude");
+	test("does not create .omni/.gitignore", async () => {
+		await runInit({}, "claude-code");
 
-		expect(existsSync(".omni/.gitignore")).toBe(true);
-
-		const content = readFileSync(".omni/.gitignore", "utf-8");
-		expect(content).toContain("# OmniDev working files - always ignored");
-		expect(content).toContain(".env");
-		expect(content).toContain("state/");
-		expect(content).toContain("sandbox/");
-		expect(content).toContain("*.log");
+		// The whole .omni/ directory is gitignored, no need for internal .gitignore
+		expect(existsSync(".omni/.gitignore")).toBe(false);
 	});
 
-	test("does not modify project's root .gitignore", async () => {
+	test("updates root .gitignore with omnidev entries", async () => {
 		// Create a root .gitignore with custom content
 		await Bun.write(".gitignore", "node_modules/\n*.log\n");
 
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
-		// Verify .gitignore was not modified
 		const content = readFileSync(".gitignore", "utf-8");
-		expect(content).toBe("node_modules/\n*.log\n");
-		expect(content).not.toContain(".omni/");
+		expect(content).toContain("node_modules/");
+		expect(content).toContain("*.log");
+		expect(content).toContain("# OmniDev");
+		expect(content).toContain(".omni/");
+		expect(content).toContain("omni.local.toml");
 	});
 
-	test("does not create root .gitignore if it doesn't exist", async () => {
-		await runInit({}, "claude");
+	test("creates root .gitignore if it doesn't exist", async () => {
+		await runInit({}, "claude-code");
+
+		expect(existsSync(".gitignore")).toBe(true);
+
+		const content = readFileSync(".gitignore", "utf-8");
+		expect(content).toContain("# OmniDev");
+		expect(content).toContain(".omni/");
+		expect(content).toContain("omni.local.toml");
+	});
+
+	test("does not duplicate gitignore entries on multiple runs", async () => {
+		await runInit({}, "claude-code");
+		await runInit({}, "claude-code");
 
-		expect(existsSync(".gitignore")).toBe(false);
+		const content = readFileSync(".gitignore", "utf-8");
+		// Should only have one occurrence of each entry
+		expect(content.match(/\.omni\//g)?.length).toBe(1);
+		expect(content.match(/omni\.local\.toml/g)?.length).toBe(1);
 	});
 
 	test("is idempotent - safe to run multiple times", async () => {
-		await runInit({}, "claude");
-		await runInit({}, "claude");
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
+		await runInit({}, "claude-code");
+		await runInit({}, "claude-code");
 
 		expect(existsSync("omni.toml")).toBe(true);
 		expect(existsSync(".omni")).toBe(true);
 		expect(existsSync("CLAUDE.md")).toBe(true);
 
-		// Should not create AGENTS.md for Claude
+		// Should not create AGENTS.md for Claude Code
 		expect(existsSync("AGENTS.md")).toBe(false);
 	});
 
@@ -218,7 +221,7 @@ describe("init command", () => {
 		mkdirSync(".omni", { recursive: true });
 		await Bun.write("omni.toml", customConfig);
 
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		const content = readFileSync("omni.toml", "utf-8");
 		expect(content).toBe(customConfig);
@@ -237,12 +240,11 @@ describe("init command", () => {
 	test("creates all directories even if some already exist", async () => {
 		mkdirSync(".omni", { recursive: true });
 
-		await runInit({}, "claude");
+		await runInit({}, "claude-code");
 
 		expect(existsSync(".omni/capabilities")).toBe(true);
 		expect(existsSync(".omni")).toBe(true);
 		expect(existsSync(".omni/state")).toBe(true);
-		expect(existsSync(".omni/sandbox")).toBe(true);
 	});
 
 	test("accepts provider via positional parameter", async () => {
@@ -250,8 +252,9 @@ describe("init command", () => {
 
 		expect(existsSync(".omni/provider.toml")).toBe(false);
 
-		const content = readFileSync("omni.toml", "utf-8");
-		expect(content).toContain('enabled = ["codex"]');
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		expect(state.enabled).toContain("codex");
 	});
 
 	test("accepts 'both' as provider parameter", async () => {
@@ -259,7 +262,28 @@ describe("init command", () => {
 
 		expect(existsSync(".omni/provider.toml")).toBe(false);
 
-		const content = readFileSync("omni.toml", "utf-8");
-		expect(content).toContain('enabled = ["claude", "codex"]');
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		// "both" maps to claude-code and cursor
+		expect(state.enabled).toContain("claude-code");
+		expect(state.enabled).toContain("cursor");
+	});
+
+	test("supports legacy 'claude' name mapping to claude-code", async () => {
+		await runInit({}, "claude");
+
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		expect(state.enabled).toContain("claude-code");
+	});
+
+	test("supports comma-separated providers", async () => {
+		await runInit({}, "claude-code,codex,cursor");
+
+		const content = readFileSync(".omni/state/providers.json", "utf-8");
+		const state = JSON.parse(content);
+		expect(state.enabled).toContain("claude-code");
+		expect(state.enabled).toContain("codex");
+		expect(state.enabled).toContain("cursor");
 	});
 });