@omnidev-ai/core 0.1.1 → 0.3.0

package/src/state/manifest.test.ts

@@ -1,7 +1,5 @@
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { describe, expect, test } from "bun:test";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import type { LoadedCapability } from "../types";
 import {
 	buildManifestFromCapabilities,
@@ -12,20 +10,7 @@ import {
 } from "./manifest";
 
 describe("manifest", () => {
-	let originalCwd: string;
-	let tempDir: string;
-
-	beforeEach(() => {
-		originalCwd = process.cwd();
-		tempDir = mkdtempSync(join(tmpdir(), "manifest-test-"));
-		mkdirSync(join(tempDir, ".omni"), { recursive: true });
-		process.chdir(tempDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		rmSync(tempDir, { recursive: true, force: true });
-	});
+	setupTestDir("manifest-test-", { chdir: true, createOmniDir: true });
 
 	describe("loadManifest", () => {
 		test("returns empty manifest when file does not exist", async () => {
@@ -46,6 +31,7 @@ describe("manifest", () => {
 						rules: ["rule1"],
 						commands: ["cmd1"],
 						subagents: ["agent1"],
+						mcps: [],
 					},
 				},
 			};
@@ -69,6 +55,7 @@ describe("manifest", () => {
 						rules: ["r1"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -119,6 +106,7 @@ describe("manifest", () => {
 					rules: [],
 					docs: [],
 					subagents: [],
+					mcps: [],
 					commands: [],
 					exports: {},
 				},
@@ -132,12 +120,14 @@ describe("manifest", () => {
 				rules: ["rule-a"],
 				commands: ["cmd-a"],
 				subagents: ["agent-a"],
+				mcps: [],
 			});
 			expect(manifest.capabilities.cap2).toEqual({
 				skills: [],
 				rules: [],
 				commands: [],
 				subagents: [],
+				mcps: [],
 			});
 		});
 
@@ -148,146 +138,6 @@ describe("manifest", () => {
 			expect(manifest.capabilities).toEqual({});
 			expect(manifest.syncedAt).toBeDefined();
 		});
-
-		test("includes MCP entry when capability has MCP config", () => {
-			const capabilities: LoadedCapability[] = [
-				{
-					id: "context7",
-					path: "/path/to/context7",
-					config: {
-						capability: {
-							id: "context7",
-							name: "Context7",
-							version: "1.0.0",
-							description: "",
-						},
-						mcp: {
-							command: "npx",
-							args: ["-y", "@upstash/context7-mcp"],
-						},
-					},
-					skills: [],
-					rules: [],
-					docs: [],
-					subagents: [],
-					commands: [],
-					exports: {},
-				},
-			];
-
-			const manifest = buildManifestFromCapabilities(capabilities);
-
-			expect(manifest.capabilities.context7.mcp).toEqual({
-				serverName: "omni-context7",
-				command: "npx",
-				args: ["-y", "@upstash/context7-mcp"],
-			});
-		});
-
-		test("includes MCP env when present", () => {
-			const capabilities: LoadedCapability[] = [
-				{
-					id: "my-mcp",
-					path: "/path/to/my-mcp",
-					config: {
-						capability: {
-							id: "my-mcp",
-							name: "My MCP",
-							version: "1.0.0",
-							description: "",
-						},
-						mcp: {
-							command: "node",
-							args: ["server.js"],
-							env: { API_KEY: "secret" },
-						},
-					},
-					skills: [],
-					rules: [],
-					docs: [],
-					subagents: [],
-					commands: [],
-					exports: {},
-				},
-			];
-
-			const manifest = buildManifestFromCapabilities(capabilities);
-
-			expect(manifest.capabilities["my-mcp"].mcp).toEqual({
-				serverName: "omni-my-mcp",
-				command: "node",
-				args: ["server.js"],
-				env: { API_KEY: "secret" },
-			});
-		});
-
-		test("does not include MCP entry when capability has no MCP config", () => {
-			const capabilities: LoadedCapability[] = [
-				{
-					id: "tasks",
-					path: "/path/to/tasks",
-					config: {
-						capability: { id: "tasks", name: "Tasks", version: "1.0.0", description: "" },
-					},
-					skills: [],
-					rules: [],
-					docs: [],
-					subagents: [],
-					commands: [],
-					exports: {},
-				},
-			];
-
-			const manifest = buildManifestFromCapabilities(capabilities);
-
-			expect(manifest.capabilities.tasks.mcp).toBeUndefined();
-		});
-
-		test("handles mixed capabilities with and without MCP", () => {
-			const capabilities: LoadedCapability[] = [
-				{
-					id: "tasks",
-					path: "/path/to/tasks",
-					config: {
-						capability: { id: "tasks", name: "Tasks", version: "1.0.0", description: "" },
-					},
-					skills: [],
-					rules: [],
-					docs: [],
-					subagents: [],
-					commands: [],
-					exports: {},
-				},
-				{
-					id: "context7",
-					path: "/path/to/context7",
-					config: {
-						capability: {
-							id: "context7",
-							name: "Context7",
-							version: "1.0.0",
-							description: "",
-						},
-						mcp: {
-							command: "npx",
-							args: ["context7-mcp"],
-						},
-					},
-					skills: [],
-					rules: [],
-					docs: [],
-					subagents: [],
-					commands: [],
-					exports: {},
-				},
-			];
-
-			const manifest = buildManifestFromCapabilities(capabilities);
-
-			expect(manifest.capabilities.tasks.mcp).toBeUndefined();
-			expect(manifest.capabilities.context7.mcp).toBeDefined();
-			expect(manifest.capabilities.context7.mcp?.serverName).toBe("omni-context7");
-		});
 	});
 
 	describe("saveManifest and loadManifest round-trip", () => {
@@ -296,8 +146,8 @@ describe("manifest", () => {
 				version: 1,
 				syncedAt: "2025-01-01T00:00:00.000Z",
 				capabilities: {
-					cap1: { skills: ["s1"], rules: ["r1"], commands: ["c1"], subagents: ["a1"] },
-					cap2: { skills: [], rules: [], commands: [], subagents: [] },
+					cap1: { skills: ["s1"], rules: ["r1"], commands: ["c1"], subagents: ["a1"], mcps: [] },
+					cap2: { skills: [], rules: [], commands: [], subagents: [], mcps: [] },
 				},
 			};
 
@@ -311,12 +161,16 @@ describe("manifest", () => {
 			const manifest1: ResourceManifest = {
 				version: 1,
 				syncedAt: "2025-01-01T00:00:00.000Z",
-				capabilities: { old: { skills: ["old"], rules: [], commands: [], subagents: [] } },
+				capabilities: {
+					old: { skills: ["old"], rules: [], commands: [], subagents: [], mcps: [] },
+				},
 			};
 			const manifest2: ResourceManifest = {
 				version: 1,
 				syncedAt: "2025-01-02T00:00:00.000Z",
-				capabilities: { new: { skills: ["new"], rules: [], commands: [], subagents: [] } },
+				capabilities: {
+					new: { skills: ["new"], rules: [], commands: [], subagents: [], mcps: [] },
+				},
 			};
 
 			await saveManifest(manifest1);
@@ -345,12 +199,14 @@ describe("manifest", () => {
 						rules: ["old-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 					"enabled-cap": {
 						skills: ["keep-skill"],
 						rules: ["keep-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -382,6 +238,7 @@ describe("manifest", () => {
 						rules: [],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -407,6 +264,7 @@ describe("manifest", () => {
 						rules: ["nonexistent-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -456,6 +314,7 @@ describe("manifest", () => {
 						rules: ["rule-1", "rule-2"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -491,18 +350,21 @@ describe("manifest", () => {
 						rules: ["cap1-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 					cap2: {
 						skills: ["cap2-skill"],
 						rules: ["cap2-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 					cap3: {
 						skills: ["cap3-skill"],
 						rules: [],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};
@@ -532,6 +394,7 @@ describe("manifest", () => {
 						rules: ["only-rule"],
 						commands: [],
 						subagents: [],
+						mcps: [],
 					},
 				},
 			};

package/src/state/manifest.ts

@@ -1,20 +1,6 @@
 import { existsSync, mkdirSync, rmSync } from "node:fs";
 import type { LoadedCapability } from "../types";
 
-/**
- * MCP entry for a capability
- */
-export interface McpEntry {
-	/** Server name in .mcp.json (e.g., "omni-{capabilityId}") */
-	serverName: string;
-	/** Command to run the MCP server */
-	command: string;
-	/** Arguments for the command */
-	args?: string[];
-	/** Environment variables */
-	env?: Record<string, string>;
-}
-
 /**
  * Resources provided by a single capability
  */
@@ -23,8 +9,7 @@ export interface CapabilityResources {
 	rules: string[];
 	commands: string[];
 	subagents: string[];
-	/** MCP configuration if capability has [mcp] section */
-	mcp?: McpEntry;
+	mcps: string[];
 }
 
 /**
@@ -48,6 +33,7 @@ export interface CleanupResult {
 	deletedRules: string[];
 	deletedCommands: string[];
 	deletedSubagents: string[];
+	deletedMcps: string[];
 }
 
 const MANIFEST_PATH = ".omni/state/manifest.json";
@@ -94,23 +80,9 @@ export function buildManifestFromCapabilities(capabilities: LoadedCapability[]):
 			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] : [],
 		};
 
-		// Track MCP if capability has one
-		if (cap.config.mcp) {
-			const mcpEntry: McpEntry = {
-				serverName: `omni-${cap.id}`,
-				command: cap.config.mcp.command,
-			};
-			if (cap.config.mcp.args) {
-				mcpEntry.args = cap.config.mcp.args;
-			}
-			if (cap.config.mcp.env) {
-				mcpEntry.env = cap.config.mcp.env;
-			}
-			resources.mcp = mcpEntry;
-		}
-
 		manifest.capabilities[cap.id] = resources;
 	}
 
@@ -131,6 +103,7 @@ export async function cleanupStaleResources(
 		deletedRules: [],
 		deletedCommands: [],
 		deletedSubagents: [],
+		deletedMcps: [],
 	};
 
 	for (const [capId, resources] of Object.entries(previousManifest.capabilities)) {

package/src/state/providers.test.ts

@@ -0,0 +1,125 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, rmSync } from "node:fs";
+import { tmpdir } from "../test-utils/index.js";
+import {
+	disableProvider,
+	enableProvider,
+	isProviderEnabled,
+	readEnabledProviders,
+	writeEnabledProviders,
+} from "./providers.js";
+
+describe("providers state", () => {
+	let testDir: string;
+	let originalCwd: string;
+
+	beforeEach(() => {
+		originalCwd = process.cwd();
+		testDir = tmpdir("providers-test-");
+		process.chdir(testDir);
+	});
+
+	afterEach(() => {
+		process.chdir(originalCwd);
+		if (existsSync(testDir)) {
+			rmSync(testDir, { recursive: true, force: true });
+		}
+	});
+
+	describe("readEnabledProviders", () => {
+		test("returns default providers when state file does not exist", async () => {
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["claude-code"]);
+		});
+
+		test("reads providers from state file", async () => {
+			await writeEnabledProviders(["cursor", "codex"]);
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["cursor", "codex"]);
+		});
+
+		test("returns default when state file is empty", async () => {
+			await writeEnabledProviders([]);
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["claude-code"]);
+		});
+	});
+
+	describe("writeEnabledProviders", () => {
+		test("creates state directory and writes providers", async () => {
+			await writeEnabledProviders(["claude-code", "cursor"]);
+			expect(existsSync(".omni/state/providers.json")).toBe(true);
+
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["claude-code", "cursor"]);
+		});
+
+		test("overwrites existing providers", async () => {
+			await writeEnabledProviders(["claude-code"]);
+			await writeEnabledProviders(["cursor", "codex"]);
+
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["cursor", "codex"]);
+		});
+	});
+
+	describe("enableProvider", () => {
+		test("adds provider to enabled list", async () => {
+			await writeEnabledProviders(["claude-code"]);
+			await enableProvider("cursor");
+
+			const providers = await readEnabledProviders();
+			expect(providers).toContain("claude-code");
+			expect(providers).toContain("cursor");
+		});
+
+		test("does not duplicate provider if already enabled", async () => {
+			await writeEnabledProviders(["claude-code", "cursor"]);
+			await enableProvider("cursor");
+
+			const providers = await readEnabledProviders();
+			expect(providers.filter((p) => p === "cursor").length).toBe(1);
+		});
+	});
+
+	describe("disableProvider", () => {
+		test("removes provider from enabled list", async () => {
+			await writeEnabledProviders(["claude-code", "cursor"]);
+			await disableProvider("cursor");
+
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["claude-code"]);
+		});
+
+		test("handles disabling non-existent provider gracefully", async () => {
+			await writeEnabledProviders(["claude-code"]);
+			await disableProvider("cursor");
+
+			const providers = await readEnabledProviders();
+			expect(providers).toEqual(["claude-code"]);
+		});
+	});
+
+	describe("isProviderEnabled", () => {
+		test("returns true when provider is enabled", async () => {
+			await writeEnabledProviders(["claude-code", "cursor"]);
+
+			expect(await isProviderEnabled("cursor")).toBe(true);
+		});
+
+		test("returns false when provider is not enabled", async () => {
+			await writeEnabledProviders(["claude-code"]);
+
+			expect(await isProviderEnabled("cursor")).toBe(false);
+		});
+	});
+
+	describe("round-trip", () => {
+		test("write then read returns same providers", async () => {
+			const original = ["claude-code", "cursor", "codex"];
+			await writeEnabledProviders(original);
+			const loaded = await readEnabledProviders();
+			expect(loaded).toEqual(original);
+		});
+	});
+});

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