@omnidev-ai/core 0.1.1 → 0.3.0

package/src/capability/subagents.test.ts

@@ -1,22 +1,18 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { beforeEach, describe, expect, test } from "bun:test";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { loadSubagents } from "./subagents";
 
 describe("loadSubagents", () => {
-	const testDir = join(process.cwd(), "test-subagents-temp");
-	const capabilityPath = join(testDir, "test-capability");
+	const testDir = setupTestDir("capability-subagents-test-");
+	let capabilityPath: string;
 
 	beforeEach(() => {
+		capabilityPath = join(testDir.path, "test-capability");
 		mkdirSync(capabilityPath, { recursive: true });
 	});
 
-	afterEach(() => {
-		if (testDir) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
 	test("returns empty array when subagents directory does not exist", async () => {
 		const subagents = await loadSubagents(capabilityPath, "test-cap");
 		expect(subagents).toEqual([]);
@@ -167,7 +163,7 @@ tools: Read, Glob, Grep, Bash
 disallowedTools: Write, Edit
 model: sonnet
 permissionMode: acceptEdits
-skills: prd, ralph, mcp-builder
+skills: prd, ralph, capability-builder
 ---
 
 You are a fully configured subagent.`;
@@ -183,7 +179,7 @@ You are a fully configured subagent.`;
 		expect(subagents[0]?.disallowedTools).toEqual(["Write", "Edit"]);
 		expect(subagents[0]?.model).toBe("sonnet");
 		expect(subagents[0]?.permissionMode).toBe("acceptEdits");
-		expect(subagents[0]?.skills).toEqual(["prd", "ralph", "mcp-builder"]);
+		expect(subagents[0]?.skills).toEqual(["prd", "ralph", "capability-builder"]);
 		expect(subagents[0]?.systemPrompt).toBe("You are a fully configured subagent.");
 	});
 

package/src/capability/subagents.ts

@@ -29,7 +29,9 @@ export async function loadSubagents(
 	}
 
 	const subagents: Subagent[] = [];
-	const entries = readdirSync(subagentsDir, { withFileTypes: true });
+	const entries = readdirSync(subagentsDir, { withFileTypes: true }).sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
 
 	for (const entry of entries) {
 		if (entry.isDirectory()) {

package/src/capability/wrapping-integration.test.ts

@@ -0,0 +1,412 @@
+import { describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
+import type { CapabilityConfig, OmniConfig } from "../types/index.js";
+import { generateMcpCapabilities } from "./sources.js";
+
+describe("wrapping integration - expo-like structure", () => {
+	const testDir = setupTestDir("test-expo-", { chdir: true });
+
+	test("wraps expo-like plugin with .claude-plugin/plugin.json", () => {
+		// Simulate Expo skills structure: plugins/expo-app-design/
+		const pluginDir = join(testDir.path, "plugins", "expo-app-design");
+		mkdirSync(join(pluginDir, ".claude-plugin"), { recursive: true });
+		mkdirSync(join(pluginDir, "skills"));
+
+		// Create plugin.json (like Expo has)
+		writeFileSync(
+			join(pluginDir, ".claude-plugin", "plugin.json"),
+			JSON.stringify({
+				name: "expo-app-design",
+				version: "1.0.0",
+				description: "Build robust, productivity apps with Expo",
+				author: {
+					name: "Evan Bacon",
+					email: "bacon@expo.io",
+				},
+			}),
+		);
+
+		// Create README
+		writeFileSync(
+			join(pluginDir, "README.md"),
+			`# Expo App Design
+
+Design amazing Expo applications with best practices.
+
+This plugin provides tools for building production-ready Expo apps.`,
+		);
+
+		// Create a skill
+		const skillDir = join(pluginDir, "skills");
+		writeFileSync(
+			join(skillDir, "example-skill.md"),
+			`---
+name: example-skill
+description: Example skill for testing
+---
+
+# Example Skill
+
+This is an example skill.`,
+		);
+
+		// Verify structure exists
+		expect(existsSync(join(pluginDir, ".claude-plugin", "plugin.json"))).toBe(true);
+		expect(existsSync(join(pluginDir, "README.md"))).toBe(true);
+		expect(existsSync(join(pluginDir, "skills", "example-skill.md"))).toBe(true);
+		expect(existsSync(join(pluginDir, "capability.toml"))).toBe(false);
+
+		// This should be detected as needing wrapping
+		// When fetchGitCapabilitySource runs, it will:
+		// 1. Check for capability.toml (not found)
+		// 2. Call shouldWrapDirectory
+		// 3. Find .claude-plugin/plugin.json
+		// 4. Generate capability.toml with metadata from plugin.json
+	});
+
+	test("wraps plugin with only directory structure (no plugin.json)", () => {
+		const pluginDir = join(testDir.path, "plugins", "simple-plugin");
+		mkdirSync(join(pluginDir, "skills"), { recursive: true });
+
+		// Create README
+		writeFileSync(
+			join(pluginDir, "README.md"),
+			`# Simple Plugin
+
+A simple plugin without plugin.json metadata.
+
+This demonstrates wrapping based on directory structure alone.`,
+		);
+
+		// Create a skill
+		writeFileSync(
+			join(pluginDir, "skills", "test-skill.md"),
+			`---
+name: test-skill
+description: Test skill
+---
+
+# Test Skill
+
+Content here.`,
+		);
+
+		// Verify structure exists
+		expect(existsSync(join(pluginDir, ".claude-plugin"))).toBe(false);
+		expect(existsSync(join(pluginDir, "skills"))).toBe(true);
+		expect(existsSync(join(pluginDir, "capability.toml"))).toBe(false);
+
+		// Should still be detected for wrapping due to skills/ directory
+	});
+
+	test("does not wrap when capability.toml already exists", () => {
+		const pluginDir = join(testDir.path, "plugins", "proper-capability");
+		mkdirSync(join(pluginDir, "skills"), { recursive: true });
+
+		// Create proper capability.toml
+		writeFileSync(
+			join(pluginDir, "capability.toml"),
+			`[capability]
+id = "proper-capability"
+name = "Proper Capability"
+version = "1.0.0"
+description = "This is a proper capability with its own TOML"
+`,
+		);
+
+		// Create a skill
+		writeFileSync(join(pluginDir, "skills", "skill.md"), "# Skill\n");
+
+		// Verify capability.toml exists
+		expect(existsSync(join(pluginDir, "capability.toml"))).toBe(true);
+		expect(existsSync(join(pluginDir, "skills"))).toBe(true);
+
+		// Should NOT be wrapped - already has capability.toml
+	});
+
+	test("multiple plugins in monorepo structure", () => {
+		// Simulate full Expo skills structure
+		const plugins = ["expo-app-design", "expo-deployment", "upgrading-expo"];
+
+		for (const pluginName of plugins) {
+			const pluginDir = join(testDir.path, "plugins", pluginName);
+			mkdirSync(join(pluginDir, ".claude-plugin"), { recursive: true });
+			mkdirSync(join(pluginDir, "skills"), { recursive: true });
+
+			writeFileSync(
+				join(pluginDir, ".claude-plugin", "plugin.json"),
+				JSON.stringify({
+					name: pluginName,
+					version: "1.0.0",
+					description: `${pluginName} plugin`,
+				}),
+			);
+
+			writeFileSync(join(pluginDir, "README.md"), `# ${pluginName}\n\nDescription here.`);
+			writeFileSync(join(pluginDir, "skills", "example.md"), "# Skill\n");
+		}
+
+		// Verify all three plugins have correct structure
+		for (const pluginName of plugins) {
+			const pluginDir = join(testDir.path, "plugins", pluginName);
+			expect(existsSync(join(pluginDir, ".claude-plugin", "plugin.json"))).toBe(true);
+			expect(existsSync(join(pluginDir, "skills"))).toBe(true);
+			expect(existsSync(join(pluginDir, "capability.toml"))).toBe(false);
+		}
+
+		// Each plugin would be loaded separately with:
+		// expo-app-design = { source = "github:expo/skills", path = "plugins/expo-app-design" }
+		// expo-deployment = { source = "github:expo/skills", path = "plugins/expo-deployment" }
+		// upgrading-expo = { source = "github:expo/skills", path = "plugins/upgrading-expo" }
+	});
+});
+
+describe("MCP capability generation", () => {
+	const _testDir = setupTestDir("mcp-wrapping-test-", { chdir: true });
+
+	test("generates capability from omni.toml [mcps] section", async () => {
+		const config: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+					transport: "stdio",
+					env: {
+						// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing literal env var syntax
+						API_KEY: "${CONTEXT7_API_KEY}",
+					},
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config);
+
+		const capabilityDir = join(".omni", "capabilities", "context7");
+		expect(existsSync(capabilityDir)).toBe(true);
+
+		const tomlPath = join(capabilityDir, "capability.toml");
+		expect(existsSync(tomlPath)).toBe(true);
+
+		const tomlContent = await readFile(tomlPath, "utf-8");
+		const parsed = parseToml(tomlContent) as unknown as CapabilityConfig;
+
+		expect(parsed.capability.id).toBe("context7");
+		expect(parsed.capability.name).toBe("context7 (MCP)");
+		expect(parsed.capability.version).toBe("1.0.0");
+		expect(parsed.capability.metadata?.wrapped).toBe(true);
+		expect(parsed.capability.metadata?.generated_from_omni_toml).toBe(true);
+
+		expect(parsed.mcp?.command).toBe("npx");
+		expect(parsed.mcp?.args).toEqual(["-y", "@upstash/context7-mcp"]);
+		expect(parsed.mcp?.transport).toBe("stdio");
+		// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing literal env var syntax
+		expect(parsed.mcp?.env?.API_KEY).toBe("${CONTEXT7_API_KEY}");
+	});
+
+	test("generates multiple MCP capabilities", async () => {
+		const config: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+				filesystem: {
+					command: "node",
+					args: ["server.js"],
+					cwd: "./mcp-servers/filesystem",
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config);
+
+		const context7Dir = join(".omni", "capabilities", "context7");
+		const filesystemDir = join(".omni", "capabilities", "filesystem");
+
+		expect(existsSync(context7Dir)).toBe(true);
+		expect(existsSync(filesystemDir)).toBe(true);
+
+		const context7TomlPath = join(context7Dir, "capability.toml");
+		const filesystemTomlPath = join(filesystemDir, "capability.toml");
+
+		expect(existsSync(context7TomlPath)).toBe(true);
+		expect(existsSync(filesystemTomlPath)).toBe(true);
+
+		const filesystemToml = await readFile(filesystemTomlPath, "utf-8");
+		const parsed = parseToml(filesystemToml) as unknown as CapabilityConfig;
+
+		expect(parsed.capability.id).toBe("filesystem");
+		expect(parsed.mcp?.cwd).toBe("./mcp-servers/filesystem");
+	});
+
+	test("cleans up stale MCP capabilities", async () => {
+		// First generation with two MCPs
+		const config1: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+				filesystem: {
+					command: "node",
+					args: ["server.js"],
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config1);
+
+		const context7Dir = join(".omni", "capabilities", "context7");
+		const filesystemDir = join(".omni", "capabilities", "filesystem");
+
+		expect(existsSync(context7Dir)).toBe(true);
+		expect(existsSync(filesystemDir)).toBe(true);
+
+		// Second generation with only one MCP
+		const config2: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config2);
+
+		// context7 should still exist
+		expect(existsSync(context7Dir)).toBe(true);
+
+		// filesystem should be removed
+		expect(existsSync(filesystemDir)).toBe(false);
+	});
+
+	test("cleans up all MCP capabilities when mcps section is empty", async () => {
+		// First generation with MCPs
+		const config1: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config1);
+
+		const context7Dir = join(".omni", "capabilities", "context7");
+		expect(existsSync(context7Dir)).toBe(true);
+
+		// Second generation with no MCPs
+		const config2: OmniConfig = {
+			mcps: {},
+		};
+
+		await generateMcpCapabilities(config2);
+
+		// All MCP capabilities should be removed
+		expect(existsSync(context7Dir)).toBe(false);
+	});
+
+	test("cleans up all MCP capabilities when mcps is undefined", async () => {
+		// First generation with MCPs
+		const config1: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config1);
+
+		const context7Dir = join(".omni", "capabilities", "context7");
+		expect(existsSync(context7Dir)).toBe(true);
+
+		// Second generation with undefined mcps
+		const config2: OmniConfig = {};
+
+		await generateMcpCapabilities(config2);
+
+		// All MCP capabilities should be removed
+		expect(existsSync(context7Dir)).toBe(false);
+	});
+
+	test("generates capability without optional fields", async () => {
+		const config: OmniConfig = {
+			mcps: {
+				simple: {
+					command: "simple-mcp",
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config);
+
+		const capabilityDir = join(".omni", "capabilities", "simple");
+		expect(existsSync(capabilityDir)).toBe(true);
+
+		const tomlPath = join(capabilityDir, "capability.toml");
+		const tomlContent = await readFile(tomlPath, "utf-8");
+		const parsed = parseToml(tomlContent) as unknown as CapabilityConfig;
+
+		expect(parsed.capability.id).toBe("simple");
+		expect(parsed.mcp?.command).toBe("simple-mcp");
+		expect(parsed.mcp?.args).toBeUndefined();
+		expect(parsed.mcp?.env).toBeUndefined();
+		expect(parsed.mcp?.cwd).toBeUndefined();
+		expect(parsed.mcp?.transport).toBeUndefined();
+	});
+
+	test("merges MCP env variables correctly", async () => {
+		const config: OmniConfig = {
+			mcps: {
+				github: {
+					command: "npx",
+					args: ["-y", "@modelcontextprotocol/server-github"],
+					env: {
+						// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing literal env var syntax
+						GITHUB_TOKEN: "${GITHUB_TOKEN}",
+						GITHUB_API_URL: "https://api.github.com",
+					},
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config);
+
+		const tomlPath = join(".omni", "capabilities", "github", "capability.toml");
+		const tomlContent = await readFile(tomlPath, "utf-8");
+		const parsed = parseToml(tomlContent) as unknown as CapabilityConfig;
+
+		// biome-ignore lint/suspicious/noTemplateCurlyInString: Testing literal env var syntax
+		expect(parsed.mcp?.env?.GITHUB_TOKEN).toBe("${GITHUB_TOKEN}");
+		expect(parsed.mcp?.env?.GITHUB_API_URL).toBe("https://api.github.com");
+	});
+
+	test("does not affect non-MCP capabilities", async () => {
+		// Create a non-MCP capability directory
+		const nonMcpDir = join(".omni", "capabilities", "my-capability");
+		mkdirSync(nonMcpDir, { recursive: true });
+		writeFileSync(join(nonMcpDir, "capability.toml"), "# test");
+
+		const config: OmniConfig = {
+			mcps: {
+				context7: {
+					command: "npx",
+					args: ["-y", "@upstash/context7-mcp"],
+				},
+			},
+		};
+
+		await generateMcpCapabilities(config);
+
+		// Non-MCP capability should still exist
+		expect(existsSync(nonMcpDir)).toBe(true);
+	});
+});

package/src/config/capabilities.ts

@@ -1,5 +1,3 @@
-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";
 
@@ -16,7 +14,6 @@ export async function getEnabledCapabilities(): Promise<string[]> {
 
 /**
  * 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> {
@@ -35,27 +32,10 @@ export async function enableCapability(capabilityId: string): Promise<void> {
 	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> {
@@ -71,12 +51,4 @@ export async function disableCapability(capabilityId: string): Promise<void> {
 	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

@@ -1,25 +1,11 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "../test-utils/index.js";
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import type { EnvDeclaration } from "../types";
 import { isSecretEnvVar, loadEnvironment, validateEnv } from "./env";
 
 describe("loadEnvironment", () => {
-	const originalCwd = process.cwd();
-	let testDir: string;
-
-	beforeEach(() => {
-		// Create test directory in /tmp
-		testDir = tmpdir("env-test-");
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true });
-		}
-	});
+	setupTestDir("env-test-", { chdir: true });
 
 	test("returns empty object when no .omni/.env file exists", async () => {
 		const env = await loadEnvironment();

package/src/config/loader.test.ts

@@ -1,35 +1,13 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "../test-utils/index.js";
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { loadConfig } from "./loader";
 
 const CONFIG_PATH = "omni.toml";
 const LOCAL_CONFIG = "omni.local.toml";
 
-// Save and restore the current working directory
-let originalCwd: string;
-let TEST_DIR: string;
-
-beforeEach(() => {
-	// Save original cwd
-	originalCwd = process.cwd();
-
-	// Create test directory in /tmp
-	TEST_DIR = tmpdir("loader-test-");
-	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", () => {
+	setupTestDir("loader-test-", { chdir: true });
 	test("returns empty config when no files exist", async () => {
 		const config = await loadConfig();
 		expect(config).toEqual({
@@ -217,64 +195,4 @@ active_profile = "production"
 		// 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);
-	});
 });