@omnidev-ai/core 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/core",
-	"version": "0.1.0",
+	"version": "0.3.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {
@@ -9,7 +9,8 @@
 		"directory": "packages/core"
 	},
 	"exports": {
-		".": "./src/index.ts"
+		".": "./src/index.ts",
+		"./test-utils": "./src/test-utils/index.ts"
 	},
 	"files": [
 		"src",

package/src/capability/commands.test.ts

@@ -1,22 +1,18 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { loadCommands } from "./commands";
 
 describe("loadCommands", () => {
-	const testDir = join(process.cwd(), "test-commands-temp");
-	const capabilityPath = join(testDir, "test-capability");
+	const testDir = setupTestDir("capability-commands-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 commands directory does not exist", async () => {
 		const commands = await loadCommands(capabilityPath, "test-cap");
 		expect(commands).toEqual([]);

package/src/capability/commands.ts

@@ -24,7 +24,9 @@ export async function loadCommands(
 	}
 
 	const commands: Command[] = [];
-	const entries = readdirSync(commandsDir, { withFileTypes: true });
+	const entries = readdirSync(commandsDir, { withFileTypes: true }).sort((a, b) =>
+		a.name.localeCompare(b.name),
+	);
 
 	for (const entry of entries) {
 		if (entry.isDirectory()) {

package/src/capability/docs.test.ts

@@ -1,31 +1,24 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import { loadDocs } from "./docs";
 
 describe("loadDocs", () => {
-	let testDir: string;
-
-	beforeEach(() => {
-		testDir = join(process.cwd(), "test-capability-docs");
-		mkdirSync(testDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (testDir) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
+	const testDir = setupTestDir("capability-docs-test-");
 
 	test("returns empty array when no docs exist", async () => {
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toEqual([]);
 	});
 
 	test("loads only definition.md when docs directory does not exist", async () => {
-		writeFileSync(join(testDir, "definition.md"), "# Test Capability\n\nThis is the definition.");
+		writeFileSync(
+			join(testDir.path, "definition.md"),
+			"# Test Capability\n\nThis is the definition.",
+		);
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.name).toBe("definition");
 		expect(docs[0]?.content).toBe("# Test Capability\n\nThis is the definition.");
@@ -33,11 +26,11 @@ describe("loadDocs", () => {
 	});
 
 	test("loads only docs from docs directory when definition.md does not exist", async () => {
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "# Guide\n\nGuide content.");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.name).toBe("guide");
 		expect(docs[0]?.content).toBe("# Guide\n\nGuide content.");
@@ -45,14 +38,14 @@ describe("loadDocs", () => {
 	});
 
 	test("loads both definition.md and docs from docs directory", async () => {
-		writeFileSync(join(testDir, "definition.md"), "# Definition");
+		writeFileSync(join(testDir.path, "definition.md"), "# Definition");
 
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "# Guide");
 		writeFileSync(join(docsDir, "examples.md"), "# Examples");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(3);
 
 		const names = docs.map((d) => d.name).sort();
@@ -60,37 +53,37 @@ describe("loadDocs", () => {
 	});
 
 	test("trims whitespace from doc content", async () => {
-		writeFileSync(join(testDir, "definition.md"), "\n\n  # Definition\n\nContent.\n\n  ");
+		writeFileSync(join(testDir.path, "definition.md"), "\n\n  # Definition\n\nContent.\n\n  ");
 
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "  \n# Guide\n\nGuide content.\n  ");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(2);
 		expect(docs[0]?.content).toBe("# Definition\n\nContent.");
 		expect(docs[1]?.content).toBe("# Guide\n\nGuide content.");
 	});
 
 	test("ignores non-markdown files in docs directory", async () => {
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "# Guide");
 		writeFileSync(join(docsDir, "readme.txt"), "Not markdown");
 		writeFileSync(join(docsDir, "config.json"), "{}");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.name).toBe("guide");
 	});
 
 	test("ignores directories in docs directory", async () => {
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		mkdirSync(join(docsDir, "subdir"));
 		writeFileSync(join(docsDir, "guide.md"), "# Guide");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.name).toBe("guide");
 	});
@@ -115,46 +108,46 @@ const code = "example";
 |----------|----------|
 | Cell 1   | Cell 2   |`;
 
-		writeFileSync(join(testDir, "definition.md"), complexMarkdown);
+		writeFileSync(join(testDir.path, "definition.md"), complexMarkdown);
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.content).toBe(complexMarkdown);
 	});
 
 	test("handles empty doc files", async () => {
-		writeFileSync(join(testDir, "definition.md"), "");
+		writeFileSync(join(testDir.path, "definition.md"), "");
 
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(2);
 		expect(docs[0]?.content).toBe("");
 		expect(docs[1]?.content).toBe("");
 	});
 
 	test("handles docs with only whitespace", async () => {
-		writeFileSync(join(testDir, "definition.md"), "   \n\n   ");
+		writeFileSync(join(testDir.path, "definition.md"), "   \n\n   ");
 
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "guide.md"), "\n\n\n");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(2);
 		expect(docs[0]?.content).toBe("");
 		expect(docs[1]?.content).toBe("");
 	});
 
 	test("handles doc names with hyphens and underscores", async () => {
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "api-reference.md"), "Content");
 		writeFileSync(join(docsDir, "getting_started.md"), "Content");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(2);
 
 		const names = docs.map((d) => d.name).sort();
@@ -162,15 +155,15 @@ const code = "example";
 	});
 
 	test("loads multiple docs in consistent order", async () => {
-		writeFileSync(join(testDir, "definition.md"), "Definition");
+		writeFileSync(join(testDir.path, "definition.md"), "Definition");
 
-		const docsDir = join(testDir, "docs");
+		const docsDir = join(testDir.path, "docs");
 		mkdirSync(docsDir);
 		writeFileSync(join(docsDir, "aaa.md"), "AAA");
 		writeFileSync(join(docsDir, "zzz.md"), "ZZZ");
 		writeFileSync(join(docsDir, "mmm.md"), "MMM");
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(4);
 
 		// definition.md should be first, then docs in filesystem order
@@ -183,16 +176,16 @@ const code = "example";
 	});
 
 	test("returns empty array when docs directory is empty", async () => {
-		mkdirSync(join(testDir, "docs"));
-		const docs = await loadDocs(testDir, "test-cap");
+		mkdirSync(join(testDir.path, "docs"));
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toEqual([]);
 	});
 
 	test("handles very long doc content", async () => {
 		const longContent = `# Long Document\n\n${"Content line.\n".repeat(1000)}`;
-		writeFileSync(join(testDir, "definition.md"), longContent);
+		writeFileSync(join(testDir.path, "definition.md"), longContent);
 
-		const docs = await loadDocs(testDir, "test-cap");
+		const docs = await loadDocs(testDir.path, "test-cap");
 		expect(docs).toHaveLength(1);
 		expect(docs[0]?.content).toBe(longContent.trim());
 	});

package/src/capability/docs.ts

@@ -26,7 +26,9 @@ export async function loadDocs(capabilityPath: string, capabilityId: string): Pr
 	// Load docs/*.md
 	const docsDir = join(capabilityPath, "docs");
 	if (existsSync(docsDir)) {
-		const entries = readdirSync(docsDir, { withFileTypes: true });
+		const entries = readdirSync(docsDir, { withFileTypes: true }).sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
 
 		for (const entry of entries) {
 			if (entry.isFile() && entry.name.endsWith(".md")) {

package/src/capability/loader.test.ts

@@ -1,35 +1,17 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
+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 { discoverCapabilities, loadCapability, loadCapabilityConfig } from "./loader";
 
 describe("discoverCapabilities", () => {
-	let testDir: string;
+	const testDir = setupTestDir("test-capabilities-", { chdir: true });
 	let capabilitiesDir: string;
-	let originalCwd: string;
 
 	beforeEach(() => {
-		// Save current working directory
-		originalCwd = process.cwd();
-
 		// Create test directory in os temp dir
-		testDir = mkdtempSync(join(tmpdir(), "test-capabilities-"));
-		capabilitiesDir = join(testDir, "omni", "capabilities");
+		capabilitiesDir = join(testDir.path, "omni", "capabilities");
 		mkdirSync(capabilitiesDir, { recursive: true });
-
-		// Change to test directory
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		// Restore working directory
-		process.chdir(originalCwd);
-
-		// Cleanup
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("returns empty array when capabilities directory does not exist", async () => {
@@ -143,31 +125,13 @@ describe("discoverCapabilities", () => {
 });
 
 describe("loadCapabilityConfig", () => {
-	let testDir: string;
+	const testDir = setupTestDir("test-capability-config-", { chdir: true });
 	let capabilitiesDir: string;
-	let originalCwd: string;
 
 	beforeEach(() => {
-		// Save current working directory
-		originalCwd = process.cwd();
-
 		// Create test directory in os temp dir
-		testDir = mkdtempSync(join(tmpdir(), "test-capability-config-"));
-		capabilitiesDir = join(testDir, ".omni", "capabilities");
+		capabilitiesDir = join(testDir.path, ".omni", "capabilities");
 		mkdirSync(capabilitiesDir, { recursive: true });
-
-		// Change to test directory
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		// Restore working directory
-		process.chdir(originalCwd);
-
-		// Cleanup
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("loads valid capability config with all required fields", async () => {
@@ -238,78 +202,6 @@ secret = true`,
 		expect(config.env?.[0]?.secret).toBe(true);
 	});
 
-	test("loads capability config with optional mcp field", async () => {
-		const capPath = join(".omni", "capabilities", "with-mcp");
-		mkdirSync(capPath, { recursive: true });
-		writeFileSync(
-			join(capPath, "capability.toml"),
-			`[capability]
-id = "with-mcp"
-name = "With MCP"
-version = "1.0.0"
-description = "Has MCP tools"
-
-[mcp]
-tools = ["test_tool"]`,
-		);
-
-		const config = await loadCapabilityConfig(capPath);
-
-		expect(config.capability.id).toBe("with-mcp");
-		expect(config.mcp?.tools).toEqual(["test_tool"]);
-	});
-
-	test("throws error for reserved capability name (fs)", async () => {
-		const capPath = join(".omni", "capabilities", "fs");
-		mkdirSync(capPath, { recursive: true });
-		writeFileSync(
-			join(capPath, "capability.toml"),
-			`[capability]
-id = "fs"
-name = "File System"
-version = "1.0.0"
-description = "Reserved name"`,
-		);
-
-		expect(async () => await loadCapabilityConfig(capPath)).toThrow(
-			'Capability name "fs" is reserved. Choose a different name.',
-		);
-	});
-
-	test("throws error for reserved capability name (react)", async () => {
-		const capPath = join(".omni", "capabilities", "react-cap");
-		mkdirSync(capPath, { recursive: true });
-		writeFileSync(
-			join(capPath, "capability.toml"),
-			`[capability]
-id = "react"
-name = "React"
-version = "1.0.0"
-description = "Reserved name"`,
-		);
-
-		expect(async () => await loadCapabilityConfig(capPath)).toThrow(
-			'Capability name "react" is reserved. Choose a different name.',
-		);
-	});
-
-	test("throws error for reserved capability name (typescript)", async () => {
-		const capPath = join(".omni", "capabilities", "ts-cap");
-		mkdirSync(capPath, { recursive: true });
-		writeFileSync(
-			join(capPath, "capability.toml"),
-			`[capability]
-id = "typescript"
-name = "TypeScript"
-version = "1.0.0"
-description = "Reserved name"`,
-		);
-
-		expect(async () => await loadCapabilityConfig(capPath)).toThrow(
-			'Capability name "typescript" is reserved. Choose a different name.',
-		);
-	});
-
 	test("throws error when capability.toml is missing", async () => {
 		const capPath = join(".omni", "capabilities", "missing-config");
 		mkdirSync(capPath, { recursive: true });
@@ -345,24 +237,6 @@ id = "bad-toml"
 		expect(async () => await loadCapabilityConfig(capPath)).toThrow();
 	});
 
-	test("allows non-reserved capability names", async () => {
-		const capPath = join(".omni", "capabilities", "my-custom-capability");
-		mkdirSync(capPath, { recursive: true });
-		writeFileSync(
-			join(capPath, "capability.toml"),
-			`[capability]
-id = "my-custom-capability"
-name = "My Custom Capability"
-version = "2.1.0"
-description = "A custom capability"`,
-		);
-
-		const config = await loadCapabilityConfig(capPath);
-
-		expect(config.capability.id).toBe("my-custom-capability");
-		expect(config.capability.name).toBe("My Custom Capability");
-	});
-
 	test("handles capability config with all optional fields defined", async () => {
 		const capPath = join(".omni", "capabilities", "complete-cap");
 		mkdirSync(capPath, { recursive: true });
@@ -388,9 +262,7 @@ key = "VAR2"
 description = "Variable 2"
 required = false
 secret = true
-
-[mcp]
-tools = ["tool1", "tool2"]`,
+`,
 		);
 
 		const config = await loadCapabilityConfig(capPath);
@@ -398,36 +270,17 @@ tools = ["tool1", "tool2"]`,
 		expect(config.capability.id).toBe("complete-cap");
 		expect(config.exports?.functions).toEqual(["fn1", "fn2"]);
 		expect(config.env).toHaveLength(2);
-		expect(config.mcp?.tools).toEqual(["tool1", "tool2"]);
 	});
 });
 
 describe("loadCapability", () => {
-	let testDir: string;
+	const testDir = setupTestDir("test-load-capability-", { chdir: true });
 	let capabilitiesDir: string;
-	let originalCwd: string;
 
 	beforeEach(() => {
-		// Save current working directory
-		originalCwd = process.cwd();
-
 		// Create test directory in os temp dir
-		testDir = mkdtempSync(join(tmpdir(), "test-load-capability-"));
-		capabilitiesDir = join(testDir, "omni", "capabilities");
+		capabilitiesDir = join(testDir.path, "omni", "capabilities");
 		mkdirSync(capabilitiesDir, { recursive: true });
-
-		// Change to test directory
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		// Restore working directory
-		process.chdir(originalCwd);
-
-		// Cleanup
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
 	});
 
 	test("loads capability with minimal config (no optional fields)", async () => {

package/src/capability/loader.ts

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { validateEnv } from "../config/env";
 import { parseCapabilityConfig } from "../config/parser";
@@ -24,78 +24,24 @@ import { loadSkills } from "./skills";
 import { loadSubagents } from "./subagents";
 
 const CAPABILITIES_DIR = ".omni/capabilities";
-const BUILTIN_CAPABILITIES_DIR = "capabilities";
-
-/**
- * Reserved capability names that cannot be used.
- * These are common package names that might conflict with imports.
- */
-const RESERVED_NAMES = [
-	"fs",
-	"path",
-	"http",
-	"https",
-	"crypto",
-	"os",
-	"child_process",
-	"stream",
-	"buffer",
-	"util",
-	"events",
-	"net",
-	"url",
-	"querystring",
-	"react",
-	"vue",
-	"lodash",
-	"axios",
-	"express",
-	"typescript",
-];
-
-/**
- * Check if a path is a directory (follows symlinks)
- */
-function isDirectoryOrSymlink(path: string): boolean {
-	try {
-		return statSync(path).isDirectory();
-	} catch {
-		return false;
-	}
-}
 
 /**
  * Discovers capabilities by scanning the .omni/capabilities directory.
  * A directory is considered a capability if it contains a capability.toml file.
- * Follows symlinks to support linked capability directories.
  *
  * @returns Array of capability directory paths
  */
 export async function discoverCapabilities(): Promise<string[]> {
 	const capabilities: string[] = [];
 
-	// Discover built-in capabilities (from capabilities/ directory)
-	if (existsSync(BUILTIN_CAPABILITIES_DIR)) {
-		const entries = readdirSync(BUILTIN_CAPABILITIES_DIR, { withFileTypes: true });
-
-		for (const entry of entries) {
-			const entryPath = join(BUILTIN_CAPABILITIES_DIR, entry.name);
-			if (entry.isDirectory() || (entry.isSymbolicLink() && isDirectoryOrSymlink(entryPath))) {
-				const configPath = join(entryPath, "capability.toml");
-				if (existsSync(configPath)) {
-					capabilities.push(entryPath);
-				}
-			}
-		}
-	}
-
-	// Discover project-specific capabilities (from .omni/capabilities/)
 	if (existsSync(CAPABILITIES_DIR)) {
-		const entries = readdirSync(CAPABILITIES_DIR, { withFileTypes: true });
+		const entries = readdirSync(CAPABILITIES_DIR, { withFileTypes: true }).sort((a, b) =>
+			a.name.localeCompare(b.name),
+		);
 
 		for (const entry of entries) {
-			const entryPath = join(CAPABILITIES_DIR, entry.name);
-			if (entry.isDirectory() || (entry.isSymbolicLink() && isDirectoryOrSymlink(entryPath))) {
+			if (entry.isDirectory()) {
+				const entryPath = join(CAPABILITIES_DIR, entry.name);
 				const configPath = join(entryPath, "capability.toml");
 				if (existsSync(configPath)) {
 					capabilities.push(entryPath);
@@ -109,24 +55,17 @@ export async function discoverCapabilities(): Promise<string[]> {
 
 /**
  * Loads and parses a capability configuration file.
- * Validates required fields and checks for reserved names.
+ * Validates required fields.
  *
  * @param capabilityPath - Path to the capability directory
  * @returns Parsed capability configuration
- * @throws Error if the config is invalid or uses a reserved name
+ * @throws Error if the config is invalid
  */
 export async function loadCapabilityConfig(capabilityPath: string): Promise<CapabilityConfig> {
 	const configPath = join(capabilityPath, "capability.toml");
 	const content = await Bun.file(configPath).text();
 	const config = parseCapabilityConfig(content);
 
-	// Validate name is not reserved
-	if (RESERVED_NAMES.includes(config.capability.id)) {
-		throw new Error(
-			`Capability name "${config.capability.id}" is reserved. Choose a different name.`,
-		);
-	}
-
 	return config;
 }