@omnidev-ai/cli 0.1.0

package/src/commands/capability.ts

@@ -0,0 +1,163 @@
+import {
+	disableCapability,
+	discoverCapabilities,
+	enableCapability,
+	getEnabledCapabilities,
+	loadCapabilityConfig,
+	syncAgentConfiguration,
+} from "@omnidev-ai/core";
+import { buildCommand, buildRouteMap } from "@stricli/core";
+
+/**
+ * Run the capability list command.
+ */
+export async function runCapabilityList(): Promise<void> {
+	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.
+ */
+export async function runCapabilityEnable(
+	_flags: Record<string, never>,
+	name: string,
+): Promise<void> {
+	try {
+		// Check if capability exists
+		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("");
+
+		// Auto-sync agent configuration
+		await syncAgentConfiguration();
+	} catch (error) {
+		console.error("Error enabling capability:", error);
+		process.exit(1);
+	}
+}
+
+/**
+ * Run the capability disable command.
+ */
+export async function runCapabilityDisable(
+	_flags: Record<string, never>,
+	name: string,
+): Promise<void> {
+	try {
+		await disableCapability(name);
+		console.log(`✓ Disabled capability: ${name}`);
+		console.log("");
+
+		// Auto-sync agent configuration
+		await syncAgentConfiguration();
+	} catch (error) {
+		console.error("Error disabling capability:", error);
+		process.exit(1);
+	}
+}
+
+const listCommand = buildCommand({
+	docs: {
+		brief: "List all discovered capabilities",
+	},
+	parameters: {},
+	async func() {
+		await runCapabilityList();
+	},
+});
+
+const enableCommand = buildCommand({
+	docs: {
+		brief: "Enable a capability",
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple" as const,
+			parameters: [
+				{
+					brief: "Capability name to enable",
+					parse: String,
+				},
+			],
+		},
+	},
+	func: runCapabilityEnable,
+});
+
+const disableCommand = buildCommand({
+	docs: {
+		brief: "Disable a capability",
+	},
+	parameters: {
+		flags: {},
+		positional: {
+			kind: "tuple" as const,
+			parameters: [
+				{
+					brief: "Capability name to disable",
+					parse: String,
+				},
+			],
+		},
+	},
+	func: runCapabilityDisable,
+});
+
+export const capabilityRoutes = buildRouteMap({
+	routes: {
+		list: listCommand,
+		enable: enableCommand,
+		disable: disableCommand,
+	},
+	docs: {
+		brief: "Manage capabilities",
+	},
+});

package/src/commands/doctor.test.ts

@@ -0,0 +1,197 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { runDoctor } from "./doctor";
+
+describe("doctor command", () => {
+	let testDir: string;
+	let originalCwd: string;
+	let originalExit: typeof process.exit;
+	let exitCalled: boolean;
+	let exitCode: number;
+
+	// Helper to create complete .omni structure
+	function createCompleteStructure() {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			"omni.toml",
+			`project = "test"
+active_profile = "default"
+
+[providers]
+enabled = ["claude"]
+
+[profiles.default]
+capabilities = []
+
+[profiles.coding]
+capabilities = []
+`,
+		);
+		writeFileSync(
+			".omni/.gitignore",
+			`# OmniDev Core
+.env
+generated/
+state/
+sandbox/
+*.log
+`,
+		);
+	}
+
+	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;
+		originalExit = process.exit;
+		process.exit = ((code?: number) => {
+			exitCalled = true;
+			exitCode = code ?? 0;
+		}) as typeof process.exit;
+	});
+
+	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 () => {
+		// Setup complete OmniDev structure
+		createCompleteStructure();
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(false);
+	});
+
+	test("should fail when .omni/ directory is missing", async () => {
+		// Don't create .omni - the test expects it to be missing
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should fail when config.toml is missing", async () => {
+		mkdirSync(".omni", { recursive: true });
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should fail when config.toml is invalid", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync("omni.toml", "invalid toml [[[");
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should check Bun version is 1.0+", async () => {
+		// We can't change Bun.version in tests, but we can verify the check runs
+		// The version check should pass in our dev environment
+		createCompleteStructure();
+
+		await runDoctor();
+
+		// Should not exit with error (Bun version should be >= 1.0)
+		expect(exitCalled).toBe(false);
+	});
+
+	test("should suggest fixes for missing directories", async () => {
+		// No setup - all checks should fail
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should handle partial setup", async () => {
+		// Only create omni/ directory
+		mkdirSync(".omni", { recursive: true });
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should fail when config has invalid syntax", async () => {
+		mkdirSync(".omni", { recursive: true });
+
+		// Create a config with invalid TOML syntax
+		writeFileSync("omni.toml", "invalid = [[[]]");
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should pass with minimal valid config", async () => {
+		createCompleteStructure();
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(false);
+	});
+
+	test("should validate internal .gitignore exists", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			"omni.toml",
+			`project = "test"
+active_profile = "default"
+
+[providers]
+enabled = ["claude"]
+
+[profiles.default]
+capabilities = []
+`,
+		);
+		// Missing .omni/.gitignore
+
+		await runDoctor();
+
+		expect(exitCalled).toBe(true);
+		expect(exitCode).toBe(1);
+	});
+
+	test("should pass when capabilities directory is missing (no custom capabilities)", async () => {
+		createCompleteStructure();
+		// Don't create .omni/capabilities directory
+
+		await runDoctor();
+
+		// Should still pass - capabilities directory is optional
+		expect(exitCalled).toBe(false);
+	});
+});

package/src/commands/doctor.ts

@@ -0,0 +1,164 @@
+import { existsSync } from "node:fs";
+import { buildCommand } from "@stricli/core";
+
+export const doctorCommand = buildCommand({
+	docs: {
+		brief: "Check OmniDev setup and dependencies",
+	},
+	parameters: {},
+	async func() {
+		return await runDoctor();
+	},
+});
+
+export async function runDoctor(): Promise<void> {
+	console.log("OmniDev Doctor");
+	console.log("==============");
+	console.log("");
+
+	const checks = [
+		checkBunVersion(),
+		checkOmniLocalDir(),
+		checkConfig(),
+		checkInternalGitignore(),
+		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);
+	}
+}
+
+interface Check {
+	name: string;
+	passed: boolean;
+	message: string;
+	fix?: string;
+}
+
+async function checkBunVersion(): Promise<Check> {
+	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(): Promise<Check> {
+	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(): Promise<Check> {
+	const configPath = "omni.toml";
+	if (!existsSync(configPath)) {
+		return {
+			name: "Configuration",
+			passed: false,
+			message: "omni.toml not found",
+			fix: "Run: omnidev init",
+		};
+	}
+
+	try {
+		const { loadConfig } = await import("@omnidev-ai/core");
+		await loadConfig();
+		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 checkInternalGitignore(): Promise<Check> {
+	const gitignorePath = ".omni/.gitignore";
+	if (!existsSync(gitignorePath)) {
+		return {
+			name: "Internal .gitignore",
+			passed: false,
+			message: ".omni/.gitignore not found",
+			fix: "Run: omnidev init",
+		};
+	}
+
+	return {
+		name: "Internal .gitignore",
+		passed: true,
+		message: "Found",
+	};
+}
+
+async function checkCapabilitiesDir(): Promise<Check> {
+	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",
+	};
+}