@omnidev-ai/cli 0.1.0

package/src/commands/profile.test.ts

@@ -0,0 +1,352 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { runProfileList, runProfileSet } from "./profile";
+
+describe("profile commands", () => {
+	let testDir: string;
+	let originalCwd: string;
+	let originalExit: typeof process.exit;
+	let exitCode: number | undefined;
+	let consoleOutput: string[];
+	let consoleErrors: string[];
+
+	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;
+		process.exit = ((code?: number) => {
+			exitCode = code ?? 0;
+			throw new Error(`process.exit(${code})`);
+		}) as typeof process.exit;
+
+		// Mock console
+		consoleOutput = [];
+		consoleErrors = [];
+		const originalLog = console.log;
+		const 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 });
+		}
+	});
+
+	describe("runProfileList", () => {
+		test("should show error when config file does not exist", async () => {
+			try {
+				await runProfileList();
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			expect(consoleOutput.join("\n")).toContain("No config file found");
+			expect(consoleOutput.join("\n")).toContain("Run: omnidev init");
+		});
+
+		test("should show message when no profiles defined", async () => {
+			// Create minimal config without profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "default"
+`,
+			);
+
+			await runProfileList();
+
+			expect(exitCode).toBeUndefined();
+			expect(consoleOutput.join("\n")).toContain("No profiles defined");
+			expect(consoleOutput.join("\n")).toContain("Using default capabilities");
+		});
+
+		test("should list all profiles from config", async () => {
+			// Create config with profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "default"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = ["tasks", "planner"]
+
+[profiles.coding]
+capabilities = []
+`,
+			);
+
+			await runProfileList();
+
+			expect(exitCode).toBeUndefined();
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("Available Profiles:");
+			expect(output).toContain("default");
+			expect(output).toContain("planning");
+			expect(output).toContain("coding");
+		});
+
+		test("should show active profile with marker", async () => {
+			// Create config with profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "planning"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = ["planner"]
+`,
+			);
+
+			await runProfileList();
+
+			expect(exitCode).toBeUndefined();
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("● planning (active)");
+			expect(output).toContain("○ default");
+		});
+
+		test("should show profile capabilities", async () => {
+			// Create config with profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "default"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = ["planner", "tasks"]
+`,
+			);
+
+			await runProfileList();
+
+			expect(exitCode).toBeUndefined();
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("Capabilities: planner, tasks");
+		});
+
+		test("should use default_profile when no active profile", async () => {
+			// Create config with active_profile
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "planning"
+
+[profiles.planning]
+capabilities = ["planner"]
+`,
+			);
+
+			await runProfileList();
+
+			expect(exitCode).toBeUndefined();
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("● planning (active)");
+		});
+
+		test("should handle invalid config gracefully", async () => {
+			// Create invalid config
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write("omni.toml", "invalid toml [[[");
+
+			try {
+				await runProfileList();
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			expect(consoleErrors.join("\n")).toContain("Error loading profiles");
+		});
+	});
+
+	describe("runProfileSet", () => {
+		test("should show error when config file does not exist", async () => {
+			try {
+				await runProfileSet("planning");
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			expect(consoleOutput.join("\n")).toContain("No config file found");
+			expect(consoleOutput.join("\n")).toContain("Run: omnidev init");
+		});
+
+		test("should show error when profile does not exist", async () => {
+			// Create config without the requested profile
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+
+[profiles.default]
+capabilities = []
+`,
+			);
+
+			try {
+				await runProfileSet("nonexistent");
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			const output = consoleOutput.join("\n");
+			expect(output).toContain('Profile "nonexistent" not found');
+			expect(output).toContain("Available profiles:");
+			expect(output).toContain("- default");
+		});
+
+		test("should set active profile", async () => {
+			// Create config with profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = ["planner"]
+`,
+			);
+
+			await runProfileSet("planning");
+
+			expect(exitCode).toBeUndefined();
+			expect(consoleOutput.join("\n")).toContain("Active profile set to: planning");
+
+			// Verify active_profile was written to state file (not config.toml)
+			const stateContent = await Bun.file(".omni/state/active-profile").text();
+			expect(stateContent).toBe("planning");
+		});
+
+		test("should trigger agents sync after setting profile", async () => {
+			// Create config with profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+active_profile = "default"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = []
+`,
+			);
+
+			await runProfileSet("planning");
+
+			expect(exitCode).toBeUndefined();
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("Syncing agent configuration");
+		});
+
+		test("should show list of available profiles when profile not found", async () => {
+			// Create config with multiple profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+
+[profiles.default]
+capabilities = []
+
+[profiles.planning]
+capabilities = []
+
+[profiles.coding]
+capabilities = []
+`,
+			);
+
+			try {
+				await runProfileSet("nonexistent");
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			const output = consoleOutput.join("\n");
+			expect(output).toContain("Available profiles:");
+			expect(output).toContain("- default");
+			expect(output).toContain("- planning");
+			expect(output).toContain("- coding");
+		});
+
+		test("should handle empty profiles config", async () => {
+			// Create config without any profiles
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write(
+				"omni.toml",
+				`project = "test-project"
+`,
+			);
+
+			try {
+				await runProfileSet("default");
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			const output = consoleOutput.join("\n");
+			expect(output).toContain('Profile "default" not found');
+			expect(output).toContain("(none defined)");
+		});
+
+		test("should handle invalid config gracefully", async () => {
+			// Create invalid config
+			mkdirSync(".omni", { recursive: true });
+			await Bun.write("omni.toml", "invalid toml [[[");
+
+			try {
+				await runProfileSet("planning");
+			} catch {
+				// Expected to throw due to process.exit mock
+			}
+
+			expect(exitCode).toBe(1);
+			expect(consoleErrors.join("\n")).toContain("Error setting profile");
+		});
+	});
+});

package/src/commands/profile.ts

@@ -0,0 +1,151 @@
+import { existsSync } from "node:fs";
+import {
+	getActiveProfile,
+	loadConfig,
+	resolveEnabledCapabilities,
+	setActiveProfile,
+	syncAgentConfiguration,
+} from "@omnidev-ai/core";
+import { buildCommand, buildRouteMap } from "@stricli/core";
+
+const listCommand = buildCommand({
+	docs: {
+		brief: "List available profiles",
+	},
+	parameters: {},
+	async func() {
+		await runProfileList();
+	},
+});
+
+async function runSetCommand(_flags: Record<string, never>, profileName: string): Promise<void> {
+	await runProfileSet(profileName);
+}
+
+const setCommand = buildCommand({
+	docs: {
+		brief: "Set the active profile",
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple" as const,
+			parameters: [
+				{
+					brief: "Profile name",
+					parse: String,
+				},
+			],
+		},
+	},
+	func: runSetCommand,
+});
+
+export const profileRoutes = buildRouteMap({
+	routes: {
+		list: listCommand,
+		set: setCommand,
+	},
+	docs: {
+		brief: "Manage capability profiles",
+	},
+});
+
+export async function runProfileList(): Promise<void> {
+	try {
+		// Check if omni.toml exists
+		if (!existsSync("omni.toml")) {
+			console.log("✗ No config file found");
+			console.log("  Run: omnidev init");
+			process.exit(1);
+		}
+
+		// Load config
+		const config = await loadConfig();
+
+		// Get active profile
+		const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
+
+		// Check if profiles exist
+		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;
+		}
+
+		// Display profiles
+		console.log("Available Profiles:");
+		console.log("");
+
+		for (const name of profileNames) {
+			const isActive = name === activeProfile;
+			const icon = isActive ? "●" : "○";
+			const profile = profiles[name];
+
+			if (profile === undefined) {
+				continue;
+			}
+
+			console.log(`${icon} ${name}${isActive ? " (active)" : ""}`);
+
+			// Show capabilities (including always-enabled)
+			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);
+	}
+}
+
+export async function runProfileSet(profileName: string): Promise<void> {
+	try {
+		// Check if omni.toml exists
+		if (!existsSync("omni.toml")) {
+			console.log("✗ No config file found");
+			console.log("  Run: omnidev init");
+			process.exit(1);
+		}
+
+		// Load config
+		const config = await loadConfig();
+
+		// Validate profile exists
+		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);
+		}
+
+		// Set active profile
+		await setActiveProfile(profileName);
+
+		console.log(`✓ Active profile set to: ${profileName}`);
+		console.log("");
+
+		// Auto-sync agent configuration
+		await syncAgentConfiguration();
+	} catch (error) {
+		console.error("✗ Error setting profile:", error);
+		process.exit(1);
+	}
+}

package/src/commands/serve.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { runServe } from "./serve";
+
+// Create test fixtures directory
+const testDir = join(process.cwd(), "test-fixtures-serve");
+
+beforeEach(() => {
+	// Clean up and create fresh test directory
+	if (existsSync(testDir)) {
+		rmSync(testDir, { recursive: true, force: true });
+	}
+	mkdirSync(testDir, { recursive: true });
+	process.chdir(testDir);
+});
+
+afterEach(() => {
+	// Return to original directory and clean up
+	process.chdir(join(testDir, ".."));
+	if (existsSync(testDir)) {
+		rmSync(testDir, { recursive: true, force: true });
+	}
+});
+
+describe("serve command", () => {
+	test("should fail when OmniDev is not initialized", async () => {
+		const mockExit = mock((code?: number) => {
+			throw new Error(`process.exit: ${code}`);
+		}) as typeof process.exit;
+		const originalExit = process.exit;
+		process.exit = mockExit;
+
+		try {
+			await expect(runServe({})).rejects.toThrow("process.exit: 1");
+			expect(mockExit).toHaveBeenCalledWith(1);
+		} finally {
+			process.exit = originalExit;
+		}
+	});
+
+	test("should fail when .omni/ directory is missing", async () => {
+		// Don't create .omni/ - test expects it to be missing
+
+		const mockExit = mock((code?: number) => {
+			throw new Error(`process.exit: ${code}`);
+		}) as typeof process.exit;
+		const originalExit = process.exit;
+		process.exit = mockExit;
+
+		try {
+			await expect(runServe({})).rejects.toThrow("process.exit: 1");
+			expect(mockExit).toHaveBeenCalledWith(1);
+		} finally {
+			process.exit = originalExit;
+		}
+	});
+
+	test("should fail when profile does not exist", async () => {
+		// Set up directories
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		// Create a config without the requested profile
+		writeFileSync(
+			"omni.toml",
+			`
+[capability]
+project = "test"
+
+[profiles.default]
+`,
+		);
+
+		const mockExit = mock((code?: number) => {
+			throw new Error(`process.exit: ${code}`);
+		}) as typeof process.exit;
+		const originalExit = process.exit;
+		process.exit = mockExit;
+
+		try {
+			await expect(runServe({ profile: "nonexistent" })).rejects.toThrow("process.exit: 1");
+			expect(mockExit).toHaveBeenCalledWith(1);
+		} finally {
+			process.exit = originalExit;
+		}
+	});
+
+	test("should set profile when provided and valid", async () => {
+		// Set up directories
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		// Create config with profiles
+		writeFileSync(
+			"omni.toml",
+			`project = "test"
+active_profile = "default"
+
+[profiles.default]
+capabilities = []
+
+[profiles.testing]
+capabilities = []
+`,
+		);
+
+		// Mock startServer to prevent actual server start
+		const mockStartServer = mock(async () => {
+			// Server started successfully, do nothing
+		});
+
+		// Mock the import of @omnidev-ai/mcp
+		const originalImport = globalThis[Symbol.for("Bun.lazy")];
+		// biome-ignore lint/suspicious/noExplicitAny: Testing requires dynamic mocking
+		(globalThis as any).import = mock(async (module: string) => {
+			if (module === "@omnidev-ai/mcp") {
+				return { startServer: mockStartServer };
+			}
+			throw new Error(`Unexpected import: ${module}`);
+		});
+
+		const mockExit = mock((code?: number) => {
+			throw new Error(`process.exit: ${code}`);
+		}) as typeof process.exit;
+		const originalExit = process.exit;
+		process.exit = mockExit;
+
+		try {
+			// This should fail because startServer will actually run, but that's OK for this test
+			// We just want to verify that setActiveProfile was called
+			await runServe({ profile: "testing" }).catch(() => {
+				// Ignore the error from startServer
+			});
+
+			// Check that active profile was written to state file (not config.toml)
+			const stateContent = await Bun.file(".omni/state/active-profile").text();
+			expect(stateContent).toBe("testing");
+		} finally {
+			process.exit = originalExit;
+			// biome-ignore lint/suspicious/noExplicitAny: Restore original import
+			if (originalImport) (globalThis as any).import = originalImport;
+		}
+	});
+
+	test("should start server without profile flag", async () => {
+		// Set up directories
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		// Create config
+		writeFileSync(
+			"omni.toml",
+			`
+[capability]
+project = "test"
+default_profile = "default"
+
+[profiles.default]
+`,
+		);
+
+		// We can't actually test server startup without complex mocking,
+		// so we'll just verify the command passes initial checks
+		const mockExit = mock((code?: number) => {
+			throw new Error(`process.exit: ${code}`);
+		}) as typeof process.exit;
+		const originalExit = process.exit;
+		process.exit = mockExit;
+
+		try {
+			// This will fail at the import stage, but that's expected
+			await runServe({}).catch((error) => {
+				// Should fail on import or server start, not on validation
+				expect(error).toBeDefined();
+			});
+
+			// No profile should be written when flag not provided
+			expect(existsSync(".omni/active-profile")).toBe(false);
+		} finally {
+			process.exit = originalExit;
+		}
+	});
+});