@omnidev-ai/core 0.1.0

package/src/config/capabilities.ts

@@ -0,0 +1,82 @@
+import { discoverCapabilities, loadCapability } from "../capability/loader.js";
+import { addCapabilityPatterns, removeCapabilityPatterns } from "../gitignore/manager.js";
+import { loadConfig, writeConfig } from "./loader.js";
+import { getActiveProfile, resolveEnabledCapabilities } from "./profiles.js";
+
+/**
+ * Get enabled capabilities for the active profile
+ * Includes both profile-specific and always-enabled capabilities
+ * @returns Array of enabled capability IDs
+ */
+export async function getEnabledCapabilities(): Promise<string[]> {
+	const config = await loadConfig();
+	const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
+	return resolveEnabledCapabilities(config, activeProfile);
+}
+
+/**
+ * Enable a capability by adding it to the active profile's capabilities list
+ * Also adds the capability's gitignore patterns to .omni/.gitignore if present
+ * @param capabilityId - The ID of the capability to enable
+ */
+export async function enableCapability(capabilityId: string): Promise<void> {
+	const config = await loadConfig();
+	const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
+
+	if (!config.profiles) {
+		config.profiles = {};
+	}
+	if (!config.profiles[activeProfile]) {
+		config.profiles[activeProfile] = { capabilities: [] };
+	}
+
+	const capabilities = new Set(config.profiles[activeProfile].capabilities ?? []);
+	capabilities.add(capabilityId);
+	config.profiles[activeProfile].capabilities = Array.from(capabilities);
+
+	await writeConfig(config);
+
+	// Add gitignore patterns if the capability exports them
+	try {
+		const capabilityPaths = await discoverCapabilities();
+		for (const path of capabilityPaths) {
+			const capability = await loadCapability(path, process.env as Record<string, string>);
+			if (capability.id === capabilityId && capability.gitignore) {
+				await addCapabilityPatterns(capabilityId, capability.gitignore);
+				break;
+			}
+		}
+	} catch (error) {
+		// If we can't load the capability or add patterns, log but don't fail
+		// This allows enabling capabilities even if gitignore management fails
+		console.warn(`Warning: Could not add gitignore patterns for ${capabilityId}:`, error);
+	}
+}
+
+/**
+ * Disable a capability by removing it from the active profile's capabilities list
+ * Also removes the capability's gitignore patterns from .omni/.gitignore
+ * @param capabilityId - The ID of the capability to disable
+ */
+export async function disableCapability(capabilityId: string): Promise<void> {
+	const config = await loadConfig();
+	const activeProfile = (await getActiveProfile()) ?? config.active_profile ?? "default";
+
+	if (!config.profiles?.[activeProfile]) {
+		return; // Nothing to disable
+	}
+
+	const capabilities = new Set(config.profiles[activeProfile].capabilities ?? []);
+	capabilities.delete(capabilityId);
+	config.profiles[activeProfile].capabilities = Array.from(capabilities);
+
+	await writeConfig(config);
+
+	// Remove gitignore patterns
+	try {
+		await removeCapabilityPatterns(capabilityId);
+	} catch (error) {
+		// If we can't remove patterns, log but don't fail
+		console.warn(`Warning: Could not remove gitignore patterns for ${capabilityId}:`, error);
+	}
+}

package/src/config/env.test.ts

@@ -0,0 +1,286 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import type { EnvDeclaration } from "../types";
+import { isSecretEnvVar, loadEnvironment, validateEnv } from "./env";
+
+describe("loadEnvironment", () => {
+	const originalCwd = process.cwd();
+	const testDir = "/tmp/omnidev-test-env";
+
+	beforeEach(() => {
+		// Clean up and create test directory
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true });
+		}
+		mkdirSync(testDir, { recursive: true });
+		process.chdir(testDir);
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true });
+		}
+	});
+
+	test("returns empty object when no .omni/.env file exists", async () => {
+		const env = await loadEnvironment();
+		// Should only contain process.env vars, no custom ones
+		expect(env).toBeDefined();
+	});
+
+	test("loads environment variables from .omni/.env", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "TEST_VAR=test_value\nANOTHER_VAR=another_value");
+
+		const env = await loadEnvironment();
+
+		expect(env.TEST_VAR).toBe("test_value");
+		expect(env.ANOTHER_VAR).toBe("another_value");
+	});
+
+	test("skips empty lines in .env file", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "VAR1=value1\n\n\nVAR2=value2");
+
+		const env = await loadEnvironment();
+
+		expect(env.VAR1).toBe("value1");
+		expect(env.VAR2).toBe("value2");
+	});
+
+	test("skips comment lines in .env file", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "# This is a comment\nVAR1=value1\n# Another comment\nVAR2=value2");
+
+		const env = await loadEnvironment();
+
+		expect(env.VAR1).toBe("value1");
+		expect(env.VAR2).toBe("value2");
+		expect(env["# This is a comment"]).toBeUndefined();
+	});
+
+	test("handles values with equals signs", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "DATABASE_URL=postgres://user:pass@localhost:5432/db?param=value");
+
+		const env = await loadEnvironment();
+
+		expect(env.DATABASE_URL).toBe("postgres://user:pass@localhost:5432/db?param=value");
+	});
+
+	test("handles quoted values", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			".omni/.env",
+			"SINGLE_QUOTED='single value'\nDOUBLE_QUOTED=\"double value\"\nUNQUOTED=unquoted value",
+		);
+
+		const env = await loadEnvironment();
+
+		expect(env.SINGLE_QUOTED).toBe("single value");
+		expect(env.DOUBLE_QUOTED).toBe("double value");
+		expect(env.UNQUOTED).toBe("unquoted value");
+	});
+
+	test("trims whitespace around keys and values", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "  VAR1  =  value1  \n\tVAR2\t=\tvalue2\t");
+
+		const env = await loadEnvironment();
+
+		expect(env.VAR1).toBe("value1");
+		expect(env.VAR2).toBe("value2");
+	});
+
+	test("process.env takes precedence over .env file", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(".omni/.env", "TEST_VAR=file_value");
+
+		// Set process env
+		process.env.TEST_VAR = "process_value";
+
+		const env = await loadEnvironment();
+
+		expect(env.TEST_VAR).toBe("process_value");
+
+		// Clean up
+		delete process.env.TEST_VAR;
+	});
+
+	test("includes all process.env variables", async () => {
+		process.env.CUSTOM_VAR = "custom_value";
+
+		const env = await loadEnvironment();
+
+		expect(env.CUSTOM_VAR).toBe("custom_value");
+
+		// Clean up
+		delete process.env.CUSTOM_VAR;
+	});
+
+	test("handles malformed lines gracefully", async () => {
+		mkdirSync(".omni", { recursive: true });
+		writeFileSync(
+			".omni/.env",
+			"VALID_VAR=value\nMALFORMED_LINE_NO_EQUALS\n=NO_KEY\nANOTHER_VAR=value2",
+		);
+
+		const env = await loadEnvironment();
+
+		expect(env.VALID_VAR).toBe("value");
+		expect(env.ANOTHER_VAR).toBe("value2");
+		expect(env.MALFORMED_LINE_NO_EQUALS).toBeUndefined();
+		expect(env[""]).toBeUndefined();
+	});
+});
+
+describe("validateEnv", () => {
+	test("passes validation when all required vars are present", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			API_KEY: { required: true },
+			DATABASE_URL: { required: true },
+		};
+
+		const env = {
+			API_KEY: "test-key",
+			DATABASE_URL: "postgres://localhost",
+		};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+
+	test("passes validation when required var has default value", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			PORT: { required: true, default: "3000" },
+		};
+
+		const env = {};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+
+	test("throws error when required var is missing", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			API_KEY: { required: true },
+		};
+
+		const env = {};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).toThrow(
+			'Missing required environment variable for capability "test-capability": API_KEY. Set it in .omni/.env or as environment variable.',
+		);
+	});
+
+	test("throws error with multiple missing vars", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			API_KEY: { required: true },
+			DATABASE_URL: { required: true },
+			SECRET_KEY: { required: true },
+		};
+
+		const env = {};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).toThrow(
+			'Missing required environment variables for capability "test-capability": API_KEY, DATABASE_URL, SECRET_KEY',
+		);
+	});
+
+	test("passes validation when optional vars are missing", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			API_KEY: { required: true },
+			OPTIONAL_VAR: { required: false },
+		};
+
+		const env = {
+			API_KEY: "test-key",
+		};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+
+	test("passes validation when no declarations are provided", () => {
+		const declarations: Record<string, EnvDeclaration> = {};
+		const env = {};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+
+	test("handles empty object declarations", () => {
+		const declarations: Record<string, EnvDeclaration | Record<string, never>> = {
+			VAR1: {},
+			VAR2: { required: true },
+		};
+
+		const env = {
+			VAR2: "value",
+		};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+
+	test("uses default value when env var is missing", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			PORT: { required: true, default: "3000" },
+			HOST: { required: true, default: "localhost" },
+		};
+
+		const env = {
+			PORT: "8080", // Override default
+		};
+
+		expect(() => validateEnv(declarations, env, "test-capability")).not.toThrow();
+	});
+});
+
+describe("isSecretEnvVar", () => {
+	test("returns true when var is marked as secret", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			API_KEY: { secret: true },
+		};
+
+		expect(isSecretEnvVar("API_KEY", declarations)).toBe(true);
+	});
+
+	test("returns false when var is not marked as secret", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			PORT: { secret: false },
+		};
+
+		expect(isSecretEnvVar("PORT", declarations)).toBe(false);
+	});
+
+	test("returns false when var is not declared", () => {
+		const declarations: Record<string, EnvDeclaration> = {};
+
+		expect(isSecretEnvVar("UNKNOWN_VAR", declarations)).toBe(false);
+	});
+
+	test("returns false when secret field is not set", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			DATABASE_URL: { required: true },
+		};
+
+		expect(isSecretEnvVar("DATABASE_URL", declarations)).toBe(false);
+	});
+
+	test("handles empty object declarations", () => {
+		const declarations: Record<string, EnvDeclaration | Record<string, never>> = {
+			VAR1: {},
+		};
+
+		expect(isSecretEnvVar("VAR1", declarations)).toBe(false);
+	});
+
+	test("returns true only when secret is explicitly true", () => {
+		const declarations: Record<string, EnvDeclaration> = {
+			SECRET_KEY: { secret: true, required: true },
+			API_KEY: { required: true },
+			PORT: { secret: false },
+		};
+
+		expect(isSecretEnvVar("SECRET_KEY", declarations)).toBe(true);
+		expect(isSecretEnvVar("API_KEY", declarations)).toBe(false);
+		expect(isSecretEnvVar("PORT", declarations)).toBe(false);
+	});
+});

package/src/config/env.ts

@@ -0,0 +1,96 @@
+import { existsSync } from "node:fs";
+import type { EnvDeclaration } from "../types";
+
+const ENV_FILE = ".omni/.env";
+
+/**
+ * Load environment variables from .omni/.env file and merge with process.env.
+ * Process environment variables take precedence over file values.
+ *
+ * @returns Merged environment variables
+ */
+export async function loadEnvironment(): Promise<Record<string, string>> {
+	const env: Record<string, string> = {};
+
+	// Load from .omni/.env
+	if (existsSync(ENV_FILE)) {
+		const content = await Bun.file(ENV_FILE).text();
+		for (const line of content.split("\n")) {
+			const trimmed = line.trim();
+			// Skip empty lines and comments
+			if (trimmed && !trimmed.startsWith("#")) {
+				const eqIndex = trimmed.indexOf("=");
+				if (eqIndex > 0) {
+					const key = trimmed.slice(0, eqIndex).trim();
+					const value = trimmed.slice(eqIndex + 1).trim();
+					// Remove quotes if present
+					const unquotedValue =
+						(value.startsWith('"') && value.endsWith('"')) ||
+						(value.startsWith("'") && value.endsWith("'"))
+							? value.slice(1, -1)
+							: value;
+					env[key] = unquotedValue;
+				}
+			}
+		}
+	}
+
+	// Process env takes precedence - filter out undefined values
+	const processEnv: Record<string, string> = {};
+	for (const [key, value] of Object.entries(process.env)) {
+		if (value !== undefined) {
+			processEnv[key] = value;
+		}
+	}
+
+	return { ...env, ...processEnv };
+}
+
+/**
+ * Validate that all required environment variables are present.
+ * Checks declarations from capability config and throws descriptive errors for missing vars.
+ *
+ * @param declarations - Environment variable declarations from capability.toml
+ * @param env - Loaded environment variables
+ * @param capabilityId - ID of the capability being validated
+ * @throws Error if required environment variables are missing
+ */
+export function validateEnv(
+	declarations: Record<string, EnvDeclaration | Record<string, never>>,
+	env: Record<string, string | undefined>,
+	capabilityId: string,
+): void {
+	const missing: string[] = [];
+
+	for (const [key, decl] of Object.entries(declarations)) {
+		const declaration = decl as EnvDeclaration;
+		const value = env[key] ?? declaration.default;
+
+		if (declaration.required && !value) {
+			missing.push(key);
+		}
+	}
+
+	if (missing.length > 0) {
+		throw new Error(
+			`Missing required environment variable${missing.length > 1 ? "s" : ""} for capability "${capabilityId}": ${missing.join(", ")}. ` +
+				`Set ${missing.length > 1 ? "them" : "it"} in .omni/.env or as environment variable${missing.length > 1 ? "s" : ""}.`,
+		);
+	}
+}
+
+/**
+ * Check if an environment variable should be treated as a secret.
+ * Secrets should be masked in logs and error messages.
+ *
+ * @param key - Environment variable name
+ * @param declarations - Environment variable declarations from capability.toml
+ * @returns true if the variable is marked as secret
+ */
+export function isSecretEnvVar(
+	key: string,
+	declarations: Record<string, EnvDeclaration | Record<string, never>>,
+): boolean {
+	const decl = declarations[key] as EnvDeclaration | undefined;
+	return decl?.secret === true;
+}

package/src/config/index.ts

@@ -0,0 +1,6 @@
+export * from "./capabilities";
+export * from "./env";
+export * from "./loader";
+export * from "./parser";
+export * from "./profiles";
+export * from "./provider";