@omnidev-ai/core 0.1.0

package/src/config/loader.test.ts

@@ -0,0 +1,282 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { loadConfig } from "./loader";
+
+const TEST_DIR = "/tmp/omnidev-test-loader";
+const CONFIG_PATH = "omni.toml";
+const LOCAL_CONFIG = "omni.local.toml";
+
+// Save and restore the current working directory
+let originalCwd: string;
+
+beforeEach(() => {
+	// Save original cwd
+	originalCwd = process.cwd();
+
+	// Clean up test directory
+	if (existsSync(TEST_DIR)) {
+		rmSync(TEST_DIR, { recursive: true });
+	}
+	mkdirSync(TEST_DIR, { recursive: true });
+	process.chdir(TEST_DIR);
+});
+
+afterEach(() => {
+	// Restore original cwd
+	process.chdir(originalCwd);
+
+	// Clean up test directory
+	if (existsSync(TEST_DIR)) {
+		rmSync(TEST_DIR, { recursive: true });
+	}
+});
+
+describe("loadConfig", () => {
+	test("returns empty config when no files exist", async () => {
+		const config = await loadConfig();
+		expect(config).toEqual({
+			env: {},
+			profiles: {},
+		});
+	});
+
+	test("loads config when only main config exists", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`
+project = "my-project"
+active_profile = "dev"
+
+[profiles.dev]
+capabilities = ["tasks", "git"]
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.project).toBe("my-project");
+		expect(config.active_profile).toBe("dev");
+		expect(config.profiles?.dev?.capabilities).toEqual(["tasks", "git"]);
+	});
+
+	test("loads local config when only local config exists", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			LOCAL_CONFIG,
+			`
+project = "local-project"
+
+[profiles.default]
+capabilities = ["local-only"]
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.project).toBe("local-project");
+		expect(config.profiles?.default?.capabilities).toEqual(["local-only"]);
+	});
+
+	test("merges main and local configs with local taking precedence", async () => {
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		writeFileSync(
+			CONFIG_PATH,
+			`
+project = "main-project"
+active_profile = "production"
+
+[profiles.default]
+capabilities = ["tasks"]
+
+[env]
+API_URL = "https://main-api.com"
+`,
+		);
+
+		writeFileSync(
+			LOCAL_CONFIG,
+			`
+project = "local-override"
+
+[profiles.default]
+capabilities = ["git"]
+
+[env]
+API_URL = "http://localhost:3000"
+DEBUG = "true"
+`,
+		);
+
+		const config = await loadConfig();
+
+		// Local overrides should take precedence
+		expect(config.project).toBe("local-override");
+
+		// Profile capabilities from local should override main
+		expect(config.profiles?.default?.capabilities).toEqual(["git"]);
+
+		// Env should be merged with local taking precedence
+		expect(config.env?.API_URL).toBe("http://localhost:3000");
+		expect(config.env?.DEBUG).toBe("true");
+	});
+
+	test("merges profiles with local taking precedence", async () => {
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		writeFileSync(
+			CONFIG_PATH,
+			`
+[profiles.dev]
+capabilities = ["tasks"]
+
+[profiles.prod]
+capabilities = ["git"]
+`,
+		);
+
+		writeFileSync(
+			LOCAL_CONFIG,
+			`
+[profiles.dev]
+capabilities = ["local-tasks"]
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.profiles?.dev?.capabilities).toEqual(["local-tasks"]);
+		expect(config.profiles?.prod?.capabilities).toEqual(["git"]);
+	});
+
+	test("handles empty profiles sections gracefully", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`
+project = "test"
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.profiles).toEqual({});
+	});
+
+	test("handles invalid TOML in main config", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(CONFIG_PATH, "invalid toml [[[");
+
+		await expect(loadConfig()).rejects.toThrow("Invalid TOML in config");
+	});
+
+	test("handles invalid TOML in local config", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(LOCAL_CONFIG, "invalid toml [[[");
+
+		await expect(loadConfig()).rejects.toThrow("Invalid TOML in config");
+	});
+
+	test("merges env objects correctly", async () => {
+		mkdirSync(".omni", { recursive: true });
+		mkdirSync(".omni", { recursive: true });
+
+		writeFileSync(
+			CONFIG_PATH,
+			`
+[env]
+VAR1 = "team1"
+VAR2 = "team2"
+`,
+		);
+
+		writeFileSync(
+			LOCAL_CONFIG,
+			`
+[env]
+VAR2 = "local2"
+VAR3 = "local3"
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.env?.VAR1).toBe("team1");
+		expect(config.env?.VAR2).toBe("local2");
+		expect(config.env?.VAR3).toBe("local3");
+	});
+
+	test("reads active_profile from config.toml for backwards compatibility", async () => {
+		mkdirSync(".omni", { recursive: true });
+
+		writeFileSync(
+			CONFIG_PATH,
+			`
+active_profile = "production"
+`,
+		);
+
+		const config = await loadConfig();
+		// active_profile is still readable from config.toml for backwards compatibility
+		// but new writes go to state file via setActiveProfile()
+		expect(config.active_profile).toBe("production");
+	});
+
+	test("loads sandbox_enabled = true from config", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`
+sandbox_enabled = true
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.sandbox_enabled).toBe(true);
+	});
+
+	test("loads sandbox_enabled = false from config", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`
+sandbox_enabled = false
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.sandbox_enabled).toBe(false);
+	});
+
+	test("sandbox_enabled is undefined when not specified", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			CONFIG_PATH,
+			`
+project = "test"
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.sandbox_enabled).toBeUndefined();
+	});
+
+	test("local config can override sandbox_enabled", async () => {
+		mkdirSync(".omni", { recursive: true });
+
+		writeFileSync(
+			CONFIG_PATH,
+			`
+sandbox_enabled = true
+`,
+		);
+
+		writeFileSync(
+			LOCAL_CONFIG,
+			`
+sandbox_enabled = false
+`,
+		);
+
+		const config = await loadConfig();
+		expect(config.sandbox_enabled).toBe(false);
+	});
+});

package/src/config/loader.ts

@@ -0,0 +1,137 @@
+import { existsSync } from "node:fs";
+import type { OmniConfig } from "../types";
+import { parseOmniConfig } from "./parser";
+
+const CONFIG_PATH = "omni.toml";
+const LOCAL_CONFIG = "omni.local.toml";
+
+/**
+ * Deep merge two config objects, with override taking precedence
+ * @param base - The base config object
+ * @param override - The override config object
+ * @returns Merged config with override values taking precedence
+ */
+function mergeConfigs(base: OmniConfig, override: OmniConfig): OmniConfig {
+	const merged: OmniConfig = { ...base, ...override };
+
+	// Deep merge env
+	merged.env = { ...base.env, ...override.env };
+
+	// Deep merge profiles
+	merged.profiles = { ...base.profiles };
+	for (const [name, profile] of Object.entries(override.profiles || {})) {
+		merged.profiles[name] = {
+			...(base.profiles?.[name] || {}),
+			...profile,
+		};
+	}
+
+	return merged;
+}
+
+/**
+ * Load and merge config and local configuration files
+ * @returns Merged OmniConfig object
+ *
+ * Reads omni.toml (main config) and omni.local.toml (local overrides).
+ * Local config takes precedence over main config. Missing files are treated as empty configs.
+ */
+export async function loadConfig(): Promise<OmniConfig> {
+	let baseConfig: OmniConfig = {};
+	let localConfig: OmniConfig = {};
+
+	if (existsSync(CONFIG_PATH)) {
+		const content = await Bun.file(CONFIG_PATH).text();
+		baseConfig = parseOmniConfig(content);
+	}
+
+	if (existsSync(LOCAL_CONFIG)) {
+		const content = await Bun.file(LOCAL_CONFIG).text();
+		localConfig = parseOmniConfig(content);
+	}
+
+	return mergeConfigs(baseConfig, localConfig);
+}
+
+/**
+ * Write config to omni.toml at project root
+ * @param config - The config object to write
+ */
+export async function writeConfig(config: OmniConfig): Promise<void> {
+	const content = generateConfigToml(config);
+	await Bun.write(CONFIG_PATH, content);
+}
+
+/**
+ * Generate TOML content for OmniConfig
+ * @param config - The config object
+ * @returns TOML string
+ */
+function generateConfigToml(config: OmniConfig): string {
+	const lines: string[] = [];
+
+	lines.push("# OmniDev Configuration");
+	lines.push("# Main configuration for your OmniDev project");
+	lines.push("");
+
+	// Project name
+	if (config.project) {
+		lines.push(`project = "${config.project}"`);
+	}
+
+	// Note: active_profile is stored in .omni/state/active-profile, not in config.toml
+	// We still read it from config.toml for backwards compatibility, but don't write it here
+
+	// Sandbox mode
+	if (config.sandbox_enabled !== undefined) {
+		lines.push(`sandbox_enabled = ${config.sandbox_enabled}`);
+	}
+
+	lines.push("");
+
+	// Providers
+	if (config.providers?.enabled && config.providers.enabled.length > 0) {
+		lines.push("[providers]");
+		lines.push(`enabled = [${config.providers.enabled.map((p) => `"${p}"`).join(", ")}]`);
+		lines.push("");
+	}
+
+	// Environment variables
+	if (config.env && Object.keys(config.env).length > 0) {
+		lines.push("[env]");
+		for (const [key, value] of Object.entries(config.env)) {
+			lines.push(`${key} = "${value}"`);
+		}
+		lines.push("");
+	}
+
+	// Capability sources (commented examples)
+	lines.push("# =============================================================================");
+	lines.push("# Capability Sources");
+	lines.push("# =============================================================================");
+	lines.push("# Fetch capabilities from Git repositories. On sync, these are cloned/updated");
+	lines.push("# and wrapped into capabilities automatically.");
+	lines.push("#");
+	lines.push("# [capabilities.sources]");
+	lines.push("# # Simple GitHub reference (auto-wrapped if no capability.toml)");
+	lines.push('# obsidian = "github:kepano/obsidian-skills"');
+	lines.push("#");
+	lines.push("# # Full configuration with version pinning");
+	lines.push('# my-cap = { source = "github:user/repo", ref = "v1.0.0" }');
+	lines.push("#");
+	lines.push("# # Force wrap mode (generate capability.toml from discovered content)");
+	lines.push('# external = { source = "github:user/skills-repo", type = "wrap" }');
+	lines.push("");
+
+	// Profiles
+	if (config.profiles && Object.keys(config.profiles).length > 0) {
+		for (const [name, profile] of Object.entries(config.profiles)) {
+			lines.push(`[profiles.${name}]`);
+			const capabilities = profile.capabilities ?? [];
+			lines.push(`capabilities = [${capabilities.map((id) => `"${id}"`).join(", ")}]`);
+			lines.push("");
+		}
+	}
+
+	return lines.join("\n");
+}

package/src/config/parser.test.ts

@@ -0,0 +1,281 @@
+import { describe, expect, test } from "bun:test";
+import { parseCapabilityConfig, parseOmniConfig } from "./parser";
+
+describe("parseOmniConfig", () => {
+	test("parses valid TOML with all fields", () => {
+		const toml = `
+project = "my-project"
+default_profile = "dev"
+
+[capabilities]
+enable = ["tasks", "git"]
+disable = ["docker"]
+
+[env]
+API_URL = "https://api.example.com"
+
+[profiles.dev]
+enable = ["debug"]
+disable = []
+
+[profiles.prod]
+enable = []
+disable = ["debug"]
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect(config.project).toBe("my-project");
+		expect(config.default_profile).toBe("dev");
+		expect(config.capabilities?.enable).toEqual(["tasks", "git"]);
+		expect(config.capabilities?.disable).toEqual(["docker"]);
+		expect(config.env?.API_URL).toBe("https://api.example.com");
+		expect(config.profiles?.dev?.enable).toEqual(["debug"]);
+		expect(config.profiles?.prod?.disable).toEqual(["debug"]);
+	});
+
+	test("parses minimal TOML", () => {
+		const toml = `
+project = "minimal"
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect(config.project).toBe("minimal");
+		expect(config.capabilities).toBeUndefined();
+		expect(config.profiles).toBeUndefined();
+	});
+
+	test("parses empty TOML", () => {
+		const config = parseOmniConfig("");
+
+		expect(config).toEqual({});
+	});
+
+	test("parses TOML with arrays", () => {
+		const toml = `
+[capabilities]
+enable = ["cap1", "cap2", "cap3"]
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect(config.capabilities?.enable).toEqual(["cap1", "cap2", "cap3"]);
+	});
+
+	test("parses TOML with nested tables", () => {
+		const toml = `
+[profiles.dev]
+enable = ["debug"]
+
+[profiles.prod]
+disable = ["debug"]
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect(config.profiles?.dev?.enable).toEqual(["debug"]);
+		expect(config.profiles?.prod?.disable).toEqual(["debug"]);
+	});
+
+	test("throws error for invalid TOML syntax", () => {
+		const toml = `
+project = "test
+[invalid
+		`;
+
+		expect(() => parseOmniConfig(toml)).toThrow(/Invalid TOML in config:/);
+	});
+
+	test("throws error for duplicate keys", () => {
+		const toml = `
+project = "test"
+project = "duplicate"
+		`;
+
+		expect(() => parseOmniConfig(toml)).toThrow(/Invalid TOML in config:/);
+	});
+
+	test("handles boolean values", () => {
+		const toml = `
+[capabilities]
+debug = true
+production = false
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect((config.capabilities as Record<string, unknown>)?.debug).toBe(true);
+		expect((config.capabilities as Record<string, unknown>)?.production).toBe(false);
+	});
+
+	test("handles numeric values", () => {
+		const toml = `
+timeout = 30
+max_retries = 5
+		`;
+
+		const config = parseOmniConfig(toml);
+
+		expect((config as Record<string, unknown>).timeout).toBe(30);
+		expect((config as Record<string, unknown>).max_retries).toBe(5);
+	});
+});
+
+describe("parseCapabilityConfig", () => {
+	test("parses valid capability.toml with all required fields", () => {
+		const toml = `
+[capability]
+id = "tasks"
+name = "Task Management"
+version = "1.0.0"
+description = "Manage tasks and workflows"
+		`;
+
+		const config = parseCapabilityConfig(toml);
+
+		expect(config.capability.id).toBe("tasks");
+		expect(config.capability.name).toBe("Task Management");
+		expect(config.capability.version).toBe("1.0.0");
+		expect(config.capability.description).toBe("Manage tasks and workflows");
+	});
+
+	test("parses capability with exports", () => {
+		const toml = `
+[capability]
+id = "tasks"
+name = "Task Management"
+version = "1.0.0"
+description = "Manage tasks"
+
+[exports]
+module = "index.ts"
+		`;
+
+		const config = parseCapabilityConfig(toml);
+
+		expect(config.exports?.module).toBe("index.ts");
+	});
+
+	test("parses capability with env declarations", () => {
+		const toml = `
+[capability]
+id = "api"
+name = "API Client"
+version = "1.0.0"
+description = "API access"
+
+[env.API_KEY]
+required = true
+secret = true
+
+[env.API_URL]
+required = false
+default = "https://api.example.com"
+		`;
+
+		const config = parseCapabilityConfig(toml);
+
+		expect(config.env?.API_KEY).toEqual({ required: true, secret: true });
+		expect(config.env?.API_URL).toEqual({
+			required: false,
+			default: "https://api.example.com",
+		});
+	});
+
+	test("parses capability with MCP config", () => {
+		const toml = `
+[capability]
+id = "custom"
+name = "Custom Capability"
+version = "1.0.0"
+description = "Custom MCP"
+
+[mcp]
+command = "node"
+args = ["server.js"]
+transport = "stdio"
+
+[mcp.env]
+PORT = "3000"
+		`;
+
+		const config = parseCapabilityConfig(toml);
+
+		expect(config.mcp?.command).toBe("node");
+		expect(config.mcp?.args).toEqual(["server.js"]);
+		expect(config.mcp?.transport).toBe("stdio");
+		expect(config.mcp?.env?.PORT).toBe("3000");
+	});
+
+	test("throws error when capability.id is missing", () => {
+		const toml = `
+[capability]
+name = "Test"
+version = "1.0.0"
+		`;
+
+		expect(() => parseCapabilityConfig(toml)).toThrow(
+			/capability.id is required in capability.toml/,
+		);
+	});
+
+	test("throws error when capability.name is missing", () => {
+		const toml = `
+[capability]
+id = "test"
+version = "1.0.0"
+		`;
+
+		expect(() => parseCapabilityConfig(toml)).toThrow(
+			/capability.name is required in capability.toml/,
+		);
+	});
+
+	test("throws error when capability.version is missing", () => {
+		const toml = `
+[capability]
+id = "test"
+name = "Test"
+		`;
+
+		expect(() => parseCapabilityConfig(toml)).toThrow(
+			/capability.version is required in capability.toml/,
+		);
+	});
+
+	test("throws error when capability table is missing", () => {
+		const toml = `
+project = "test"
+		`;
+
+		expect(() => parseCapabilityConfig(toml)).toThrow(
+			/capability.id is required in capability.toml/,
+		);
+	});
+
+	test("throws error for invalid TOML syntax", () => {
+		const toml = `
+[capability
+id = "test"
+		`;
+
+		expect(() => parseCapabilityConfig(toml)).toThrow(/Invalid capability.toml:/);
+	});
+
+	test("handles empty env declarations", () => {
+		const toml = `
+[capability]
+id = "test"
+name = "Test"
+version = "1.0.0"
+description = "Test"
+
+[env.SIMPLE_VAR]
+		`;
+
+		const config = parseCapabilityConfig(toml);
+
+		expect(config.env?.SIMPLE_VAR).toEqual({});
+	});
+});