@omnidev-ai/core 0.4.0 → 0.5.1

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.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);
+}

package/src/index.ts

@@ -0,0 +1,37 @@
+/**
+ * @omnidev-ai/core - Core functionality for OmniDev
+ *
+ * This package contains shared types, utilities, and core logic
+ * used across the CLI and capability tooling packages.
+ */
+
+// Re-export @stricli/core for capabilities to use
+// This ensures all capabilities use the same @stricli/core instance as the CLI
+export { buildCommand, buildRouteMap } from "@stricli/core";
+
+export const version = "0.1.0";
+
+export function getVersion(): string {
+	return version;
+}
+
+// Export capability system
+export * from "./capability";
+
+// Export config functionality
+export * from "./config";
+// Export MCP JSON management
+export * from "./mcp-json";
+// Export state management
+export * from "./state";
+// Export sync functionality
+export * from "./sync";
+
+// Export templates
+export * from "./templates/agents";
+export * from "./templates/claude";
+// Export core types
+export * from "./types";
+
+// Export debug utilities
+export * from "./debug";

package/src/mcp-json/index.ts

@@ -0,0 +1 @@
+export * from "./manager";

package/src/mcp-json/manager.ts

@@ -0,0 +1,106 @@
+import { existsSync } from "node:fs";
+import type { LoadedCapability, McpConfig } from "../types";
+import type { ResourceManifest } from "../state/manifest";
+
+/**
+ * MCP server configuration in .mcp.json
+ */
+export interface McpServerConfig {
+	command: string;
+	args?: string[];
+	env?: Record<string, string>;
+}
+
+/**
+ * Structure of .mcp.json file
+ */
+export interface McpJsonConfig {
+	mcpServers: Record<string, McpServerConfig>;
+}
+
+const MCP_JSON_PATH = ".mcp.json";
+
+/**
+ * Read .mcp.json or return empty config if doesn't exist
+ */
+export async function readMcpJson(): Promise<McpJsonConfig> {
+	if (!existsSync(MCP_JSON_PATH)) {
+		return { mcpServers: {} };
+	}
+
+	try {
+		const content = await Bun.file(MCP_JSON_PATH).text();
+		const parsed = JSON.parse(content);
+		return {
+			mcpServers: parsed.mcpServers || {},
+		};
+	} catch {
+		// If file is invalid JSON, return empty config
+		return { mcpServers: {} };
+	}
+}
+
+/**
+ * Write .mcp.json, preserving non-OmniDev entries
+ */
+export async function writeMcpJson(config: McpJsonConfig): Promise<void> {
+	await Bun.write(MCP_JSON_PATH, JSON.stringify(config, null, 2));
+}
+
+/**
+ * Build MCP server config from capability's mcp section
+ */
+function buildMcpServerConfig(mcp: McpConfig): McpServerConfig {
+	const config: McpServerConfig = {
+		command: mcp.command,
+	};
+	if (mcp.args) {
+		config.args = mcp.args;
+	}
+	if (mcp.env) {
+		config.env = mcp.env;
+	}
+	return config;
+}
+
+/**
+ * Sync .mcp.json with enabled capability MCP servers
+ *
+ * Each capability with an [mcp] section is registered using its capability ID.
+ * Uses the previous manifest to track which MCPs were managed by OmniDev.
+ */
+export async function syncMcpJson(
+	capabilities: LoadedCapability[],
+	previousManifest: ResourceManifest,
+	options: { silent?: boolean } = {},
+): Promise<void> {
+	const mcpJson = await readMcpJson();
+
+	// Collect all MCP server names from previous manifest
+	const previouslyManagedMcps = new Set<string>();
+	for (const resources of Object.values(previousManifest.capabilities)) {
+		for (const mcpName of resources.mcps) {
+			previouslyManagedMcps.add(mcpName);
+		}
+	}
+
+	// Remove previously managed MCPs
+	for (const serverName of previouslyManagedMcps) {
+		delete mcpJson.mcpServers[serverName];
+	}
+
+	// Add MCPs from all enabled capabilities
+	let addedCount = 0;
+	for (const cap of capabilities) {
+		if (cap.config.mcp) {
+			mcpJson.mcpServers[cap.id] = buildMcpServerConfig(cap.config.mcp);
+			addedCount++;
+		}
+	}
+
+	await writeMcpJson(mcpJson);
+
+	if (!options.silent) {
+		console.log(`  - .mcp.json (${addedCount} MCP server(s))`);
+	}
+}

package/src/state/active-profile.ts

@@ -0,0 +1,41 @@
+import { existsSync, mkdirSync } from "node:fs";
+
+const STATE_DIR = ".omni/state";
+const ACTIVE_PROFILE_PATH = `${STATE_DIR}/active-profile`;
+
+/**
+ * Read the active profile from state file.
+ * Returns null if no active profile is set in state.
+ */
+export async function readActiveProfileState(): Promise<string | null> {
+	if (!existsSync(ACTIVE_PROFILE_PATH)) {
+		return null;
+	}
+
+	try {
+		const content = await Bun.file(ACTIVE_PROFILE_PATH).text();
+		const trimmed = content.trim();
+		return trimmed || null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Write the active profile to state file.
+ * @param profileName - The name of the profile to set as active
+ */
+export async function writeActiveProfileState(profileName: string): Promise<void> {
+	mkdirSync(STATE_DIR, { recursive: true });
+	await Bun.write(ACTIVE_PROFILE_PATH, profileName);
+}
+
+/**
+ * Clear the active profile state (delete the state file).
+ */
+export async function clearActiveProfileState(): Promise<void> {
+	if (existsSync(ACTIVE_PROFILE_PATH)) {
+		const file = Bun.file(ACTIVE_PROFILE_PATH);
+		await file.delete();
+	}
+}

package/src/state/index.ts

@@ -0,0 +1,3 @@
+export * from "./active-profile";
+export * from "./manifest";
+export * from "./providers";

package/src/state/manifest.ts

@@ -0,0 +1,137 @@
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import type { LoadedCapability } from "../types";
+
+/**
+ * Resources provided by a single capability
+ */
+export interface CapabilityResources {
+	skills: string[];
+	rules: string[];
+	commands: string[];
+	subagents: string[];
+	mcps: string[];
+}
+
+/**
+ * Manifest tracking which resources each capability provides.
+ * Used to clean up stale resources when capabilities are disabled.
+ */
+export interface ResourceManifest {
+	/** Schema version for future migrations */
+	version: 1;
+	/** Last sync timestamp (ISO 8601) */
+	syncedAt: string;
+	/** Map of capability ID → resources it provides */
+	capabilities: Record<string, CapabilityResources>;
+}
+
+/**
+ * Result of cleaning up stale resources
+ */
+export interface CleanupResult {
+	deletedSkills: string[];
+	deletedRules: string[];
+	deletedCommands: string[];
+	deletedSubagents: string[];
+	deletedMcps: string[];
+}
+
+const MANIFEST_PATH = ".omni/state/manifest.json";
+const CURRENT_VERSION = 1;
+
+/**
+ * Load the previous manifest from disk.
+ * Returns an empty manifest if the file doesn't exist.
+ */
+export async function loadManifest(): Promise<ResourceManifest> {
+	if (!existsSync(MANIFEST_PATH)) {
+		return {
+			version: CURRENT_VERSION,
+			syncedAt: new Date().toISOString(),
+			capabilities: {},
+		};
+	}
+
+	const content = await Bun.file(MANIFEST_PATH).text();
+	return JSON.parse(content) as ResourceManifest;
+}
+
+/**
+ * Save the manifest to disk.
+ */
+export async function saveManifest(manifest: ResourceManifest): Promise<void> {
+	mkdirSync(".omni/state", { recursive: true });
+	await Bun.write(MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+
+/**
+ * Build a manifest from the current registry capabilities.
+ */
+export function buildManifestFromCapabilities(capabilities: LoadedCapability[]): ResourceManifest {
+	const manifest: ResourceManifest = {
+		version: CURRENT_VERSION,
+		syncedAt: new Date().toISOString(),
+		capabilities: {},
+	};
+
+	for (const cap of capabilities) {
+		const resources: CapabilityResources = {
+			skills: cap.skills.map((s) => s.name),
+			rules: cap.rules.map((r) => r.name),
+			commands: cap.commands.map((c) => c.name),
+			subagents: cap.subagents.map((s) => s.name),
+			mcps: cap.config.mcp ? [cap.id] : [],
+		};
+
+		manifest.capabilities[cap.id] = resources;
+	}
+
+	return manifest;
+}
+
+/**
+ * Delete resources for capabilities that are no longer enabled.
+ * Compares the previous manifest against current capability IDs
+ * and removes files/directories for capabilities not in the current set.
+ */
+export async function cleanupStaleResources(
+	previousManifest: ResourceManifest,
+	currentCapabilityIds: Set<string>,
+): Promise<CleanupResult> {
+	const result: CleanupResult = {
+		deletedSkills: [],
+		deletedRules: [],
+		deletedCommands: [],
+		deletedSubagents: [],
+		deletedMcps: [],
+	};
+
+	for (const [capId, resources] of Object.entries(previousManifest.capabilities)) {
+		// Skip if capability is still enabled
+		if (currentCapabilityIds.has(capId)) {
+			continue;
+		}
+
+		// Delete skills (directories)
+		for (const skillName of resources.skills) {
+			const skillDir = `.claude/skills/${skillName}`;
+			if (existsSync(skillDir)) {
+				rmSync(skillDir, { recursive: true });
+				result.deletedSkills.push(skillName);
+			}
+		}
+
+		// Delete rules (individual files)
+		for (const ruleName of resources.rules) {
+			const rulePath = `.cursor/rules/omnidev-${ruleName}.mdc`;
+			if (existsSync(rulePath)) {
+				rmSync(rulePath);
+				result.deletedRules.push(ruleName);
+			}
+		}
+
+		// Future: Delete commands and subagents if they become file-based
+	}
+
+	return result;
+}

package/src/state/providers.ts

@@ -0,0 +1,69 @@
+import { existsSync, mkdirSync } from "node:fs";
+import type { ProviderId } from "../types/index.js";
+
+const STATE_DIR = ".omni/state";
+const PROVIDERS_PATH = `${STATE_DIR}/providers.json`;
+
+export interface ProvidersState {
+	enabled: ProviderId[];
+}
+
+const DEFAULT_PROVIDERS: ProviderId[] = ["claude-code"];
+
+/**
+ * Read the enabled providers from local state.
+ * Returns default providers if no state file exists.
+ */
+export async function readEnabledProviders(): Promise<ProviderId[]> {
+	if (!existsSync(PROVIDERS_PATH)) {
+		return DEFAULT_PROVIDERS;
+	}
+
+	try {
+		const content = await Bun.file(PROVIDERS_PATH).text();
+		const state = JSON.parse(content) as ProvidersState;
+		return state.enabled.length > 0 ? state.enabled : DEFAULT_PROVIDERS;
+	} catch {
+		return DEFAULT_PROVIDERS;
+	}
+}
+
+/**
+ * Write enabled providers to local state.
+ * @param providers - List of provider IDs to enable
+ */
+export async function writeEnabledProviders(providers: ProviderId[]): Promise<void> {
+	mkdirSync(STATE_DIR, { recursive: true });
+	const state: ProvidersState = { enabled: providers };
+	await Bun.write(PROVIDERS_PATH, JSON.stringify(state, null, 2));
+}
+
+/**
+ * Enable a specific provider.
+ * @param providerId - The provider to enable
+ */
+export async function enableProvider(providerId: ProviderId): Promise<void> {
+	const current = await readEnabledProviders();
+	if (!current.includes(providerId)) {
+		await writeEnabledProviders([...current, providerId]);
+	}
+}
+
+/**
+ * Disable a specific provider.
+ * @param providerId - The provider to disable
+ */
+export async function disableProvider(providerId: ProviderId): Promise<void> {
+	const current = await readEnabledProviders();
+	const filtered = current.filter((p) => p !== providerId);
+	await writeEnabledProviders(filtered);
+}
+
+/**
+ * Check if a provider is enabled.
+ * @param providerId - The provider to check
+ */
+export async function isProviderEnabled(providerId: ProviderId): Promise<boolean> {
+	const current = await readEnabledProviders();
+	return current.includes(providerId);
+}