@omnidev-ai/core 0.1.1 → 0.3.0

package/src/capability/rules.test.ts

@@ -1,39 +1,29 @@
-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 { loadRules } from "./rules";
 
 describe("loadRules", () => {
-	let testDir: string;
-
-	beforeEach(() => {
-		testDir = join(process.cwd(), "test-capability-rules");
-		mkdirSync(testDir, { recursive: true });
-	});
-
-	afterEach(() => {
-		if (testDir) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
+	const testDir = setupTestDir("capability-rules-test-");
 
 	test("returns empty array when rules directory does not exist", async () => {
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toEqual([]);
 	});
 
 	test("returns empty array when rules directory is empty", async () => {
-		mkdirSync(join(testDir, "rules"));
-		const rules = await loadRules(testDir, "test-cap");
+		mkdirSync(join(testDir.path, "rules"));
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toEqual([]);
 	});
 
 	test("loads single rule from rules directory", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "test-rule.md"), "# Test Rule\n\nThis is a test rule.");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.name).toBe("test-rule");
 		expect(rules[0]?.content).toBe("# Test Rule\n\nThis is a test rule.");
@@ -41,13 +31,13 @@ describe("loadRules", () => {
 	});
 
 	test("loads multiple rules from rules directory", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "rule-one.md"), "# Rule One");
 		writeFileSync(join(rulesDir, "rule-two.md"), "# Rule Two");
 		writeFileSync(join(rulesDir, "rule-three.md"), "# Rule Three");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(3);
 
 		const names = rules.map((r) => r.name).sort();
@@ -55,40 +45,40 @@ describe("loadRules", () => {
 	});
 
 	test("trims whitespace from rule content", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "trimmed.md"), "\n\n  # Trimmed Rule\n\nContent here.\n\n  ");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.content).toBe("# Trimmed Rule\n\nContent here.");
 	});
 
 	test("ignores non-markdown files in rules directory", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "rule.md"), "# Rule");
 		writeFileSync(join(rulesDir, "readme.txt"), "Not a markdown file");
 		writeFileSync(join(rulesDir, "config.json"), "{}");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.name).toBe("rule");
 	});
 
 	test("ignores directories in rules directory", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		mkdirSync(join(rulesDir, "subdir"));
 		writeFileSync(join(rulesDir, "rule.md"), "# Rule");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.name).toBe("rule");
 	});
 
 	test("handles rules with complex markdown formatting", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		const complexMarkdown = `# Complex Rule
 
@@ -105,38 +95,38 @@ const code = "example";
 
 		writeFileSync(join(rulesDir, "complex.md"), complexMarkdown);
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.content).toBe(complexMarkdown);
 	});
 
 	test("handles empty rule files", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "empty.md"), "");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.content).toBe("");
 	});
 
 	test("handles rules with only whitespace", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "whitespace.md"), "   \n\n   ");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(1);
 		expect(rules[0]?.content).toBe("");
 	});
 
 	test("handles rule names with hyphens and underscores", async () => {
-		const rulesDir = join(testDir, "rules");
+		const rulesDir = join(testDir.path, "rules");
 		mkdirSync(rulesDir);
 		writeFileSync(join(rulesDir, "my-rule-name.md"), "Content");
 		writeFileSync(join(rulesDir, "another_rule_name.md"), "Content");
 
-		const rules = await loadRules(testDir, "test-cap");
+		const rules = await loadRules(testDir.path, "test-cap");
 		expect(rules).toHaveLength(2);
 
 		const names = rules.map((r) => r.name).sort();

package/src/capability/rules.ts

@@ -16,7 +16,9 @@ export async function loadRules(capabilityPath: string, capabilityId: string): P
 	}
 
 	const rules: Rule[] = [];
-	const entries = readdirSync(rulesDir, { withFileTypes: true });
+	const entries = readdirSync(rulesDir, { 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/skills.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 { loadSkills } from "./skills";
 
 describe("loadSkills", () => {
-	const testDir = join(process.cwd(), "test-skills-temp");
-	const capabilityPath = join(testDir, "test-capability");
+	const testDir = setupTestDir("capability-skills-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 skills directory does not exist", async () => {
 		const skills = await loadSkills(capabilityPath, "test-cap");
 		expect(skills).toEqual([]);

package/src/capability/sources.test.ts

@@ -1,7 +1,7 @@
-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 { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { setupTestDir } from "@omnidev-ai/core/test-utils";
 import {
 	parseSourceConfig,
 	sourceToGitUrl,
@@ -61,12 +61,10 @@ describe("parseSourceConfig", () => {
 		const config = parseSourceConfig({
 			source: "github:user/repo",
 			ref: "v2.0.0",
-			type: "wrap",
 		}) as GitCapabilitySourceConfig;
 
 		expect(config.source).toBe("github:user/repo");
 		expect(config.ref).toBe("v2.0.0");
-		expect(config.type).toBe("wrap");
 	});
 
 	test("passes through config with path", () => {
@@ -135,23 +133,7 @@ describe("getLockFilePath", () => {
 });
 
 describe("loadLockFile", () => {
-	let testDir: string;
-	let originalCwd: string;
-
-	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = mkdtempSync(join(tmpdir(), "test-lock-file-"));
-		mkdirSync(join(testDir, ".omni"), { recursive: true });
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
+	setupTestDir("test-lock-file-", { chdir: true, createOmniDir: true });
 	test("returns empty capabilities when lock file does not exist", async () => {
 		const lockFile = await loadLockFile();
 
@@ -213,23 +195,7 @@ updated_at = "2026-01-02T00:00:00Z"
 });
 
 describe("saveLockFile", () => {
-	let testDir: string;
-	let originalCwd: string;
-
-	beforeEach(() => {
-		originalCwd = process.cwd();
-		testDir = mkdtempSync(join(tmpdir(), "test-save-lock-"));
-		mkdirSync(join(testDir, ".omni"), { recursive: true });
-		process.chdir(testDir);
-	});
-
-	afterEach(() => {
-		process.chdir(originalCwd);
-		if (existsSync(testDir)) {
-			rmSync(testDir, { recursive: true, force: true });
-		}
-	});
-
+	setupTestDir("test-save-lock-", { chdir: true, createOmniDir: true });
 	test("creates lock file with single capability", async () => {
 		const lockFile: CapabilitiesLockFile = {
 			capabilities: {
@@ -332,7 +298,142 @@ describe("saveLockFile", () => {
 	});
 });
 
-// Note: Tests for fetchCapabilitySource and fetchAllCapabilitySources require
-// network access and git operations. These should be tested via integration tests
+describe("wrapping detection", () => {
+	const testDir = setupTestDir("test-wrapping-", { chdir: true, createOmniDir: true });
+
+	beforeEach(() => {
+		mkdirSync(join(testDir.path, ".omni", "capabilities"), { recursive: true });
+	});
+	test("detects wrapping needed when .claude-plugin/plugin.json exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, ".claude-plugin"), { recursive: true });
+
+		writeFileSync(
+			join(capDir, ".claude-plugin", "plugin.json"),
+			JSON.stringify({
+				name: "test-capability",
+				version: "1.0.0",
+				description: "Test capability",
+				author: {
+					name: "Test Author",
+					email: "test@example.com",
+				},
+			}),
+		);
+
+		// Should be detected as needing wrapping since no capability.toml exists
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, ".claude-plugin", "plugin.json"))).toBe(true);
+	});
+
+	test("detects wrapping needed when skills directory exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "skills"), { recursive: true });
+
+		writeFileSync(join(capDir, "skills", "example-skill.md"), "# Example Skill\n");
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, "skills"))).toBe(true);
+	});
+
+	test("detects wrapping needed when agents directory exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "agents"), { recursive: true });
+
+		writeFileSync(join(capDir, "agents", "example-agent.md"), "# Example Agent\n");
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, "agents"))).toBe(true);
+	});
+
+	test("detects wrapping needed when commands directory exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "commands"), { recursive: true });
+
+		writeFileSync(join(capDir, "commands", "example-command.md"), "# Example Command\n");
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, "commands"))).toBe(true);
+	});
+
+	test("detects wrapping needed when rules directory exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "rules"), { recursive: true });
+
+		writeFileSync(join(capDir, "rules", "example-rule.md"), "# Example Rule\n");
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, "rules"))).toBe(true);
+	});
+
+	test("detects wrapping needed when docs directory exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "docs"), { recursive: true });
+
+		writeFileSync(join(capDir, "docs", "getting-started.md"), "# Getting Started\n");
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, "docs"))).toBe(true);
+	});
+
+	test("does not wrap when capability.toml exists", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "skills"), { recursive: true });
+
+		writeFileSync(
+			join(capDir, "capability.toml"),
+			`[capability]
+id = "test-cap"
+name = "Test Capability"
+version = "1.0.0"
+description = "Test"
+`,
+		);
+
+		writeFileSync(join(capDir, "skills", "example-skill.md"), "# Example Skill\n");
+
+		// Has capability.toml, so should NOT be wrapped even with skills dir
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(true);
+		expect(existsSync(join(capDir, "skills"))).toBe(true);
+	});
+
+	test("does not wrap directory with no recognized structure", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(capDir, { recursive: true });
+
+		// Create some random files/dirs that shouldn't trigger wrapping
+		writeFileSync(join(capDir, "README.md"), "# Test\n");
+		writeFileSync(join(capDir, "package.json"), "{}");
+		mkdirSync(join(capDir, "src"));
+
+		expect(existsSync(join(capDir, "capability.toml"))).toBe(false);
+		expect(existsSync(join(capDir, ".claude-plugin"))).toBe(false);
+		expect(existsSync(join(capDir, "skills"))).toBe(false);
+		// Should not trigger wrapping
+	});
+
+	test("recognizes singular directory names", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "skill"), { recursive: true });
+
+		writeFileSync(join(capDir, "skill", "example.md"), "# Example\n");
+
+		// Singular 'skill' should also be detected
+		expect(existsSync(join(capDir, "skill"))).toBe(true);
+	});
+
+	test("recognizes alternative directory names", () => {
+		const capDir = join(testDir.path, ".omni", "capabilities", "test-cap");
+		mkdirSync(join(capDir, "subagents"), { recursive: true });
+
+		writeFileSync(join(capDir, "subagents", "example.md"), "# Example\n");
+
+		// 'subagents' should also be detected as agent dir
+		expect(existsSync(join(capDir, "subagents"))).toBe(true);
+	});
+});
+
+// Note: Tests for fetchCapabilitySource and fetchAllCapabilitySources with actual
+// git operations require network access. These should be tested via integration tests
 // or with mocked git commands. The manual test in /tmp/omni-test verified the
 // full flow works correctly with the real obsidian-skills repository.