@omnidev-ai/core 0.1.0

package/src/config/parser.ts

@@ -0,0 +1,55 @@
+import { parse } from "smol-toml";
+import type { CapabilityConfig, OmniConfig } from "../types";
+
+/**
+ * Parse a TOML string into an OmniConfig object
+ * @param tomlContent - The TOML content to parse
+ * @returns Parsed OmniConfig object
+ * @throws Error if TOML is invalid
+ */
+export function parseOmniConfig(tomlContent: string): OmniConfig {
+	try {
+		return parse(tomlContent) as OmniConfig;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid TOML in config: ${message}`);
+	}
+}
+
+/**
+ * Validate that parsed TOML has required capability fields
+ */
+function validateCapabilityConfig(parsed: Record<string, unknown>): void {
+	const cap = parsed["capability"];
+	if (typeof cap !== "object" || cap === null) {
+		throw new Error("capability.id is required in capability.toml");
+	}
+	const capability = cap as Record<string, unknown>;
+	if (typeof capability["id"] !== "string") {
+		throw new Error("capability.id is required in capability.toml");
+	}
+	if (typeof capability["name"] !== "string") {
+		throw new Error("capability.name is required in capability.toml");
+	}
+	if (typeof capability["version"] !== "string") {
+		throw new Error("capability.version is required in capability.toml");
+	}
+}
+
+/**
+ * Parse a TOML string into a CapabilityConfig object
+ * @param tomlContent - The TOML content to parse
+ * @returns Parsed CapabilityConfig object
+ * @throws Error if TOML is invalid or required fields are missing
+ */
+export function parseCapabilityConfig(tomlContent: string): CapabilityConfig {
+	try {
+		const parsed = parse(tomlContent) as Record<string, unknown>;
+		validateCapabilityConfig(parsed);
+		// After validation, we know the structure matches CapabilityConfig
+		return parsed as unknown as CapabilityConfig;
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid capability.toml: ${message}`);
+	}
+}

package/src/config/profiles.test.ts

@@ -0,0 +1,259 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { readActiveProfileState } from "../state/active-profile.js";
+import type { OmniConfig } from "../types/index.js";
+import { getActiveProfile, resolveEnabledCapabilities, setActiveProfile } from "./profiles.js";
+
+describe("getActiveProfile", () => {
+	const TEST_DIR = ".omni-test-profiles";
+	let originalCwd: string;
+
+	beforeEach(() => {
+		if (!existsSync(TEST_DIR)) {
+			mkdirSync(TEST_DIR, { recursive: true });
+		}
+		originalCwd = process.cwd();
+		process.chdir(TEST_DIR);
+		if (!existsSync(".omni")) {
+			mkdirSync(".omni", { recursive: true });
+		}
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true, force: true });
+		}
+	});
+
+	test("returns null when no state file or config exists", async () => {
+		const profile = await getActiveProfile();
+		expect(profile).toBe(null);
+	});
+
+	test("returns profile from state file when set", async () => {
+		mkdirSync(".omni/state", { recursive: true });
+		await Bun.write(".omni/state/active-profile", "dev");
+		const profile = await getActiveProfile();
+		expect(profile).toBe("dev");
+	});
+
+	test("falls back to config.toml for backwards compatibility", async () => {
+		writeFileSync("omni.toml", 'active_profile = "legacy"', "utf-8");
+		const profile = await getActiveProfile();
+		expect(profile).toBe("legacy");
+	});
+
+	test("state file takes precedence over config.toml", async () => {
+		mkdirSync(".omni/state", { recursive: true });
+		await Bun.write(".omni/state/active-profile", "from-state");
+		writeFileSync("omni.toml", 'active_profile = "from-config"', "utf-8");
+		const profile = await getActiveProfile();
+		expect(profile).toBe("from-state");
+	});
+
+	test("returns null when config has no active_profile", async () => {
+		writeFileSync("omni.toml", 'project = "test"', "utf-8");
+		const profile = await getActiveProfile();
+		expect(profile).toBe(null);
+	});
+});
+
+describe("setActiveProfile", () => {
+	const TEST_DIR = ".omni-test-profiles-set";
+	let originalCwd: string;
+
+	beforeEach(() => {
+		if (!existsSync(TEST_DIR)) {
+			mkdirSync(TEST_DIR, { recursive: true });
+		}
+		originalCwd = process.cwd();
+		process.chdir(TEST_DIR);
+		if (!existsSync(".omni")) {
+			mkdirSync(".omni", { recursive: true });
+		}
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true, force: true });
+		}
+	});
+
+	test("sets active_profile in state file", async () => {
+		await setActiveProfile("staging");
+		const stateProfile = await readActiveProfileState();
+		expect(stateProfile).toBe("staging");
+	});
+
+	test("overwrites existing active_profile in state file", async () => {
+		mkdirSync(".omni/state", { recursive: true });
+		await Bun.write(".omni/state/active-profile", "dev");
+		await setActiveProfile("prod");
+		const stateProfile = await readActiveProfileState();
+		expect(stateProfile).toBe("prod");
+	});
+
+	test("does not modify config.toml", async () => {
+		writeFileSync("omni.toml", 'project = "test"', "utf-8");
+		await setActiveProfile("staging");
+		const content = await Bun.file("omni.toml").text();
+		expect(content).not.toContain("active_profile");
+	});
+});
+
+describe("resolveEnabledCapabilities", () => {
+	test("returns empty array when no profiles configured", () => {
+		const config: OmniConfig = {};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual([]);
+	});
+
+	test("returns empty array when profile has no capabilities", () => {
+		const config: OmniConfig = {
+			profiles: {
+				default: {
+					capabilities: [],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual([]);
+	});
+
+	test("returns capabilities from specified profile", () => {
+		const config: OmniConfig = {
+			profiles: {
+				dev: {
+					capabilities: ["tasks", "filesystem", "debug"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual(["tasks", "filesystem", "debug"]);
+	});
+
+	test("uses active_profile when profileName is null", () => {
+		const config: OmniConfig = {
+			active_profile: "dev",
+			profiles: {
+				dev: {
+					capabilities: ["tasks", "debug"],
+				},
+				default: {
+					capabilities: ["tasks"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual(["tasks", "debug"]);
+	});
+
+	test('falls back to "default" profile when active_profile not set', () => {
+		const config: OmniConfig = {
+			profiles: {
+				default: {
+					capabilities: ["tasks", "filesystem"],
+				},
+				dev: {
+					capabilities: ["tasks", "debug"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual(["tasks", "filesystem"]);
+	});
+
+	test("handles non-existent profile gracefully", () => {
+		const config: OmniConfig = {
+			profiles: {
+				dev: {
+					capabilities: ["debug"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "nonexistent");
+		expect(result).toEqual([]);
+	});
+
+	test("handles config with no profiles defined", () => {
+		const config: OmniConfig = {};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual([]);
+	});
+
+	test("handles profile with undefined capabilities field", () => {
+		const config: OmniConfig = {
+			profiles: {
+				dev: {},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual([]);
+	});
+
+	test("includes always-enabled capabilities with profile capabilities", () => {
+		const config: OmniConfig = {
+			always_enabled_capabilities: ["logging", "telemetry"],
+			profiles: {
+				dev: {
+					capabilities: ["tasks", "debug"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual(["logging", "telemetry", "tasks", "debug"]);
+	});
+
+	test("removes duplicates when capability is in both always-enabled and profile", () => {
+		const config: OmniConfig = {
+			always_enabled_capabilities: ["logging", "tasks"],
+			profiles: {
+				dev: {
+					capabilities: ["tasks", "debug"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual(["logging", "tasks", "debug"]);
+	});
+
+	test("returns only always-enabled capabilities when profile has none", () => {
+		const config: OmniConfig = {
+			always_enabled_capabilities: ["logging", "telemetry"],
+			profiles: {
+				dev: {
+					capabilities: [],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, "dev");
+		expect(result).toEqual(["logging", "telemetry"]);
+	});
+
+	test("returns always-enabled capabilities even when no profiles exist", () => {
+		const config: OmniConfig = {
+			always_enabled_capabilities: ["logging", "telemetry"],
+		};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual(["logging", "telemetry"]);
+	});
+
+	test("always-enabled capabilities work with active_profile", () => {
+		const config: OmniConfig = {
+			active_profile: "dev",
+			always_enabled_capabilities: ["logging"],
+			profiles: {
+				dev: {
+					capabilities: ["tasks", "debug"],
+				},
+				default: {
+					capabilities: ["tasks"],
+				},
+			},
+		};
+		const result = resolveEnabledCapabilities(config, null);
+		expect(result).toEqual(["logging", "tasks", "debug"]);
+	});
+});

package/src/config/profiles.ts

@@ -0,0 +1,75 @@
+import { readActiveProfileState, writeActiveProfileState } from "../state/active-profile.js";
+import type { OmniConfig, ProfileConfig } from "../types/index.js";
+import { loadConfig, writeConfig } from "./loader.js";
+
+/**
+ * Gets the name of the currently active profile.
+ * Reads from state file first, falls back to config.toml for backwards compatibility.
+ * Returns null if no profile is set.
+ */
+export async function getActiveProfile(): Promise<string | null> {
+	// First check state file (new location)
+	const stateProfile = await readActiveProfileState();
+	if (stateProfile) {
+		return stateProfile;
+	}
+
+	// Fall back to config.toml for backwards compatibility
+	const config = await loadConfig();
+	return config.active_profile ?? null;
+}
+
+/**
+ * Sets the active profile by writing to state file.
+ * @param name - The name of the profile to activate
+ */
+export async function setActiveProfile(name: string): Promise<void> {
+	await writeActiveProfileState(name);
+}
+
+/**
+ * Resolves the enabled capabilities for a given profile
+ *
+ * @param config - The merged OmniConfig
+ * @param profileName - The name of the profile to apply, or null to use active
+ * @returns Array of capability IDs that should be enabled
+ */
+export function resolveEnabledCapabilities(
+	config: OmniConfig,
+	profileName: string | null,
+): string[] {
+	// Determine which profile to use
+	const profile = profileName
+		? config.profiles?.[profileName]
+		: config.profiles?.[config.active_profile ?? "default"];
+
+	const profileCapabilities = profile?.capabilities ?? [];
+	const alwaysEnabled = config.always_enabled_capabilities ?? [];
+
+	// Merge always-enabled capabilities with profile capabilities (no duplicates)
+	return [...new Set([...alwaysEnabled, ...profileCapabilities])];
+}
+
+/**
+ * Load a specific profile configuration from config.toml
+ * @param profileName - Name of the profile to load
+ * @returns ProfileConfig if found, undefined otherwise
+ */
+export async function loadProfileConfig(profileName: string): Promise<ProfileConfig | undefined> {
+	const config = await loadConfig();
+	return config.profiles?.[profileName];
+}
+
+/**
+ * Set a profile configuration in config.toml
+ * @param profileName - Name of the profile to set
+ * @param profileConfig - Profile configuration
+ */
+export async function setProfile(profileName: string, profileConfig: ProfileConfig): Promise<void> {
+	const config = await loadConfig();
+	if (!config.profiles) {
+		config.profiles = {};
+	}
+	config.profiles[profileName] = profileConfig;
+	await writeConfig(config);
+}

package/src/config/provider.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { parseProviderFlag } from "./provider.js";
+
+const TEST_DIR = ".test-omni";
+
+beforeEach(() => {
+	if (existsSync(TEST_DIR)) {
+		rmSync(TEST_DIR, { recursive: true });
+	}
+	mkdirSync(TEST_DIR, { recursive: true });
+});
+
+afterEach(() => {
+	if (existsSync(TEST_DIR)) {
+		rmSync(TEST_DIR, { recursive: true });
+	}
+});
+
+describe("parseProviderFlag", () => {
+	test("parses 'claude' flag", () => {
+		expect(parseProviderFlag("claude")).toEqual(["claude"]);
+	});
+
+	test("parses 'codex' flag", () => {
+		expect(parseProviderFlag("codex")).toEqual(["codex"]);
+	});
+
+	test("parses 'both' flag", () => {
+		expect(parseProviderFlag("both")).toEqual(["claude", "codex"]);
+	});
+
+	test("handles case-insensitive input", () => {
+		expect(parseProviderFlag("CLAUDE")).toEqual(["claude"]);
+		expect(parseProviderFlag("Codex")).toEqual(["codex"]);
+		expect(parseProviderFlag("BOTH")).toEqual(["claude", "codex"]);
+	});
+
+	test("throws on invalid provider", () => {
+		expect(() => parseProviderFlag("invalid")).toThrow("Invalid provider: invalid");
+	});
+});
+
+describe("writeProviderConfig", () => {
+	test("writes single provider config", async () => {
+		const testPath = `${TEST_DIR}/provider.toml`;
+
+		// Manually write for testing
+		const lines: string[] = [];
+		lines.push("# OmniDev Provider Configuration");
+		lines.push("# Selected AI provider(s) for this project");
+		lines.push("");
+		lines.push("# Single provider");
+		lines.push('provider = "claude"');
+
+		await Bun.write(testPath, `${lines.join("\n")}\n`);
+
+		const content = await Bun.file(testPath).text();
+		expect(content).toContain('provider = "claude"');
+		expect(content).toContain("# Single provider");
+	});
+
+	test("writes multiple providers config", async () => {
+		const testPath = `${TEST_DIR}/provider.toml`;
+
+		const lines: string[] = [];
+		lines.push("# OmniDev Provider Configuration");
+		lines.push("# Selected AI provider(s) for this project");
+		lines.push("");
+		lines.push("# Multiple providers enabled");
+		lines.push('providers = ["claude", "codex"]');
+
+		await Bun.write(testPath, `${lines.join("\n")}\n`);
+
+		const content = await Bun.file(testPath).text();
+		expect(content).toContain('providers = ["claude", "codex"]');
+		expect(content).toContain("# Multiple providers");
+	});
+});

package/src/config/provider.ts

@@ -0,0 +1,55 @@
+import { existsSync } from "node:fs";
+import { parse } from "smol-toml";
+import type { Provider, ProviderConfig } from "../types/index.js";
+
+const PROVIDER_CONFIG_PATH = ".omni/provider.toml";
+
+export async function loadProviderConfig(): Promise<ProviderConfig> {
+	if (!existsSync(PROVIDER_CONFIG_PATH)) {
+		return { provider: "claude" };
+	}
+
+	const content = await Bun.file(PROVIDER_CONFIG_PATH).text();
+	const parsed = parse(content) as unknown as ProviderConfig;
+	return parsed;
+}
+
+export async function writeProviderConfig(config: ProviderConfig): Promise<void> {
+	const lines: string[] = [];
+
+	lines.push("# OmniDev Provider Configuration");
+	lines.push("# Selected AI provider(s) for this project");
+	lines.push("#");
+	lines.push("# This file controls which AI provider(s) you're using:");
+	lines.push("#   - claude: Generates .claude/claude.md instruction file");
+	lines.push("#   - codex:  Generates AGENTS.md instruction file");
+	lines.push("#   - both:   Generates both instruction files");
+	lines.push("");
+
+	if (config.providers && config.providers.length > 1) {
+		lines.push("# Multiple providers enabled");
+		lines.push(`providers = [${config.providers.map((p) => `"${p}"`).join(", ")}]`);
+	} else if (config.providers && config.providers.length === 1) {
+		lines.push("# Single provider");
+		lines.push(`provider = "${config.providers[0]}"`);
+	} else if (config.provider) {
+		lines.push("# Single provider");
+		lines.push(`provider = "${config.provider}"`);
+	} else {
+		lines.push("# Default: Claude");
+		lines.push('provider = "claude"');
+	}
+
+	await Bun.write(PROVIDER_CONFIG_PATH, `${lines.join("\n")}\n`);
+}
+
+export function parseProviderFlag(flag: string): Provider[] {
+	const lower = flag.toLowerCase();
+	if (lower === "both") {
+		return ["claude", "codex"];
+	}
+	if (lower === "claude" || lower === "codex") {
+		return [lower as Provider];
+	}
+	throw new Error(`Invalid provider: ${flag}. Must be 'claude', 'codex', or 'both'.`);
+}

package/src/debug.ts

@@ -0,0 +1,20 @@
+/**
+ * Debug logger that writes to stdout when OMNIDEV_DEBUG=1
+ */
+export function debug(message: string, data?: unknown): void {
+	if (process.env["OMNIDEV_DEBUG"] !== "1") {
+		return;
+	}
+
+	const timestamp = new Date().toISOString();
+	let logLine: string;
+
+	if (data !== undefined) {
+		logLine = `[${timestamp}] [omnidev] ${message} ${JSON.stringify(data, null, 2)}`;
+	} else {
+		logLine = `[${timestamp}] [omnidev] ${message}`;
+	}
+
+	// Write to stdout
+	console.log(logLine);
+}