@omnidev-ai/cli 0.1.0

package/src/commands/init.test.ts

@@ -0,0 +1,265 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+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 });
+		}
+	});
+
+	test("creates .omni/ directory", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync(".omni")).toBe(true);
+		expect(existsSync(".omni/capabilities")).toBe(true);
+	});
+
+	test("creates omni.toml with default config", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync("omni.toml")).toBe(true);
+
+		const content = readFileSync("omni.toml", "utf-8");
+		expect(content).toContain('project = "my-project"');
+		// active_profile is stored in state file, not config.toml
+		expect(content).not.toContain("active_profile");
+		// profiles should be in config.toml
+		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]");
+		// should have documentation comments
+		expect(content).toContain("# OmniDev Configuration");
+	});
+
+	test("creates active profile in state file", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync(".omni/state/active-profile")).toBe(true);
+
+		const content = readFileSync(".omni/state/active-profile", "utf-8");
+		expect(content).toBe("default");
+	});
+
+	test("does not create separate capabilities.toml file", async () => {
+		await runInit({}, "claude");
+
+		// 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");
+
+		// Profiles are in config.toml
+		expect(existsSync(".omni/profiles.toml")).toBe(false);
+	});
+
+	test("creates .omni/ directory with subdirectories", async () => {
+		await runInit({}, "claude");
+
+		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");
+
+		// Providers are in config.toml
+		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"]');
+	});
+
+	test("creates AGENTS.md for Codex provider", async () => {
+		await runInit({}, "codex");
+
+		expect(existsSync("AGENTS.md")).toBe(true);
+
+		const content = readFileSync("AGENTS.md", "utf-8");
+		expect(content).toContain("# Project Instructions");
+		expect(content).toContain("@import .omni/instructions.md");
+	});
+
+	test("creates .omni/instructions.md", async () => {
+		await runInit({}, "codex");
+
+		expect(existsSync(".omni/instructions.md")).toBe(true);
+
+		const content = readFileSync(".omni/instructions.md", "utf-8");
+		expect(content).toContain("# OmniDev Instructions");
+		expect(content).toContain("## Project Description");
+		expect(content).toContain("<!-- TODO: Add 2-3 sentences describing your project -->");
+		expect(content).toContain("## Capabilities");
+		expect(content).toContain("No capabilities enabled yet");
+	});
+
+	test("does not create AGENTS.md for Claude provider", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync("AGENTS.md")).toBe(false);
+	});
+
+	test("creates CLAUDE.md for Claude provider", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync("CLAUDE.md")).toBe(true);
+
+		const content = readFileSync("CLAUDE.md", "utf-8");
+		expect(content).toContain("# Project Instructions");
+		expect(content).toContain("@import .omni/instructions.md");
+	});
+
+	test("does not create CLAUDE.md for Codex provider", async () => {
+		await runInit({}, "codex");
+
+		expect(existsSync("CLAUDE.md")).toBe(false);
+	});
+
+	test("creates both AGENTS.md and CLAUDE.md for 'both' providers", async () => {
+		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");
+
+		const claudeContent = readFileSync("CLAUDE.md", "utf-8");
+		expect(claudeContent).toContain("# Project Instructions");
+		expect(claudeContent).toContain("@import .omni/instructions.md");
+	});
+
+	test("does not modify existing CLAUDE.md", async () => {
+		const existingContent = "# My Existing Config\n\nExisting content here.\n";
+		await Bun.write("CLAUDE.md", existingContent);
+
+		await runInit({}, "claude");
+
+		const content = readFileSync("CLAUDE.md", "utf-8");
+		expect(content).toBe(existingContent);
+	});
+
+	test("does not modify existing AGENTS.md", async () => {
+		const existingContent = "# My Existing Agents\n\nExisting content here.\n";
+		await Bun.write("AGENTS.md", existingContent);
+
+		await runInit({}, "codex");
+
+		const content = readFileSync("AGENTS.md", "utf-8");
+		expect(content).toBe(existingContent);
+	});
+
+	test("creates .omni/.gitignore with internal patterns", async () => {
+		await runInit({}, "claude");
+
+		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");
+	});
+
+	test("does not modify project's root .gitignore", async () => {
+		// Create a root .gitignore with custom content
+		await Bun.write(".gitignore", "node_modules/\n*.log\n");
+
+		await runInit({}, "claude");
+
+		// Verify .gitignore was not modified
+		const content = readFileSync(".gitignore", "utf-8");
+		expect(content).toBe("node_modules/\n*.log\n");
+		expect(content).not.toContain(".omni/");
+	});
+
+	test("does not create root .gitignore if it doesn't exist", async () => {
+		await runInit({}, "claude");
+
+		expect(existsSync(".gitignore")).toBe(false);
+	});
+
+	test("is idempotent - safe to run multiple times", async () => {
+		await runInit({}, "claude");
+		await runInit({}, "claude");
+		await runInit({}, "claude");
+
+		expect(existsSync("omni.toml")).toBe(true);
+		expect(existsSync(".omni")).toBe(true);
+		expect(existsSync("CLAUDE.md")).toBe(true);
+
+		// Should not create AGENTS.md for Claude
+		expect(existsSync("AGENTS.md")).toBe(false);
+	});
+
+	test("does not overwrite existing config.toml", async () => {
+		const customConfig = 'project = "custom"\n';
+		mkdirSync(".omni", { recursive: true });
+		await Bun.write("omni.toml", customConfig);
+
+		await runInit({}, "claude");
+
+		const content = readFileSync("omni.toml", "utf-8");
+		expect(content).toBe(customConfig);
+	});
+
+	test("does not overwrite existing AGENTS.md", async () => {
+		const customAgents = "# Custom agents\n";
+		await Bun.write("AGENTS.md", customAgents);
+
+		await runInit({}, "codex");
+
+		const content = readFileSync("AGENTS.md", "utf-8");
+		expect(content).toBe(customAgents);
+	});
+
+	test("creates all directories even if some already exist", async () => {
+		mkdirSync(".omni", { recursive: true });
+
+		await runInit({}, "claude");
+
+		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 () => {
+		await runInit({}, "codex");
+
+		expect(existsSync(".omni/provider.toml")).toBe(false);
+
+		const content = readFileSync("omni.toml", "utf-8");
+		expect(content).toContain('enabled = ["codex"]');
+	});
+
+	test("accepts 'both' as provider parameter", async () => {
+		await runInit({}, "both");
+
+		expect(existsSync(".omni/provider.toml")).toBe(false);
+
+		const content = readFileSync("omni.toml", "utf-8");
+		expect(content).toContain('enabled = ["claude", "codex"]');
+	});
+});

package/src/commands/init.ts

@@ -0,0 +1,192 @@
+import { existsSync, mkdirSync } from "node:fs";
+import type { Provider } from "@omnidev-ai/core";
+import {
+	generateAgentsTemplate,
+	generateClaudeTemplate,
+	generateInstructionsTemplate,
+	parseProviderFlag,
+	setActiveProfile,
+	syncAgentConfiguration,
+	writeConfig,
+} from "@omnidev-ai/core";
+import { buildCommand } from "@stricli/core";
+import { promptForProvider } from "../prompts/provider.js";
+
+export async function runInit(_flags: Record<string, never>, provider?: 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());
+	}
+
+	// Get provider selection
+	let providers: Provider[];
+	if (provider) {
+		providers = parseProviderFlag(provider);
+	} else {
+		providers = await promptForProvider();
+	}
+
+	// Create omni.toml at project root
+	if (!existsSync("omni.toml")) {
+		await writeConfig({
+			project: "my-project",
+			providers: {
+				enabled: providers,
+			},
+			profiles: {
+				default: {
+					capabilities: [],
+				},
+				planning: {
+					capabilities: [],
+				},
+				coding: {
+					capabilities: [],
+				},
+			},
+		});
+		// Set active profile in state file (not omni.toml)
+		await setActiveProfile("default");
+	}
+
+	// Create .omni/instructions.md
+	if (!existsSync(".omni/instructions.md")) {
+		await Bun.write(".omni/instructions.md", generateInstructionsTemplate());
+	}
+
+	// Create provider-specific files
+	const fileStatus = await createProviderFiles(providers);
+
+	// Run initial sync
+	await syncAgentConfiguration({ silent: false });
+
+	console.log("");
+	console.log(`✓ OmniDev initialized for ${providers.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) {
+		console.log("📝 Don't forget to add your project description to:");
+		console.log("   • .omni/instructions.md");
+	}
+
+	if (hasExistingFiles) {
+		console.log("📝 Add this line to your existing file(s):");
+		for (const file of fileStatus.existing) {
+			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("");
+	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)");
+}
+
+export const initCommand = buildCommand({
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple" as const,
+			parameters: [
+				{
+					brief: "AI provider: claude, codex, or both",
+					parse: String,
+					optional: true,
+				},
+			],
+		},
+	},
+	docs: {
+		brief: "Initialize OmniDev in the current project",
+	},
+	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");
+		}
+	}
+
+	// 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");
+		}
+	}
+
+	return { created, existing };
+}
+
+function internalGitignore(): string {
+	return `# OmniDev working files - always ignored
+# These files change frequently and are machine-specific
+
+# Secrets
+.env
+
+# Runtime state
+state/
+
+# Sandbox execution
+sandbox/
+
+# Logs
+*.log
+
+# MCP server process ID
+server.pid
+
+# Capability-specific patterns are appended below by each capability
+`;
+}

package/src/commands/mcp.ts

@@ -0,0 +1,113 @@
+import { existsSync } from "node:fs";
+import { buildCommand, buildRouteMap } from "@stricli/core";
+
+const STATUS_FILE = ".omni/state/mcp-status.json";
+
+// Local type definition to avoid circular dependency with @omnidev-ai/mcp
+interface McpChildProcess {
+	capabilityId: string;
+	pid: number | null;
+	status: "starting" | "connected" | "disconnected" | "error";
+	transport: "stdio" | "sse" | "http";
+	lastHealthCheck?: string;
+	error?: string;
+	toolCount?: number;
+}
+
+interface McpStatusFile {
+	lastUpdated: string;
+	relayPort: number;
+	children: McpChildProcess[];
+}
+
+/**
+ * Run the mcp status command.
+ */
+export async function runMcpStatus(): Promise<void> {
+	try {
+		if (!existsSync(STATUS_FILE)) {
+			console.log("No MCP status found.");
+			console.log("");
+			console.log("Is the OmniDev server running? Start it with:");
+			console.log("  omnidev serve");
+			return;
+		}
+
+		const statusText = await Bun.file(STATUS_FILE).text();
+		const status = JSON.parse(statusText) as McpStatusFile;
+
+		console.log("");
+		console.log("=== MCP Controller Status ===");
+		console.log("");
+		console.log(`Last updated: ${status.lastUpdated}`);
+		console.log(`Relay port:   ${status.relayPort}`);
+		console.log("");
+
+		if (status.children.length === 0) {
+			console.log("No MCP children running.");
+			console.log("");
+			console.log("Enable a capability with [mcp] configuration to spawn child MCPs.");
+			return;
+		}
+
+		console.log(`Child Processes (${status.children.length}):`);
+		console.log("");
+
+		for (const child of status.children) {
+			const statusIcon = getStatusIcon(child.status);
+			console.log(`  ${statusIcon} ${child.capabilityId}`);
+			console.log(`      Status:    ${child.status}`);
+			console.log(`      Transport: ${child.transport}`);
+			if (child.pid) {
+				console.log(`      PID:       ${child.pid}`);
+			}
+			if (child.toolCount !== undefined) {
+				console.log(`      Tools:     ${child.toolCount}`);
+			}
+			if (child.lastHealthCheck) {
+				console.log(`      Last check: ${child.lastHealthCheck}`);
+			}
+			if (child.error) {
+				console.log(`      Error:     ${child.error}`);
+			}
+			console.log("");
+		}
+	} catch (error) {
+		console.error("Error reading MCP status:", error);
+		process.exit(1);
+	}
+}
+
+function getStatusIcon(status: string): string {
+	switch (status) {
+		case "connected":
+			return "\u2713"; // checkmark
+		case "starting":
+			return "\u2022"; // bullet
+		case "disconnected":
+			return "\u2717"; // x mark
+		case "error":
+			return "\u2717"; // x mark
+		default:
+			return "?";
+	}
+}
+
+const statusCommand = buildCommand({
+	docs: {
+		brief: "Show MCP controller status",
+	},
+	parameters: {},
+	async func() {
+		await runMcpStatus();
+	},
+});
+
+export const mcpRoutes = buildRouteMap({
+	routes: {
+		status: statusCommand,
+	},
+	docs: {
+		brief: "MCP controller commands",
+	},
+});