@omnidev-ai/core 0.3.0 → 0.4.0

package/dist/test-utils/index.d.ts

@@ -0,0 +1,142 @@
+//#region src/test-utils/helpers.d.ts
+/**
+ * Helper functions for testing
+ */
+/**
+ * Expects an async function to throw an error
+ * @param fn - Async function that should throw
+ * @param errorMatch - Optional string or regex to match against error message
+ * @throws If the function doesn't throw
+ */
+declare function expectToThrowAsync(fn: () => Promise<unknown>, errorMatch?: string | RegExp): Promise<void>;
+/**
+ * Waits for a condition to be true
+ * @param condition - Function that returns true when condition is met
+ * @param timeout - Maximum time to wait in milliseconds (default: 1000)
+ * @param interval - Check interval in milliseconds (default: 50)
+ * @throws If timeout is reached before condition is met
+ */
+declare function waitForCondition(condition: () => boolean | Promise<boolean>, timeout?: number, interval?: number): Promise<void>;
+/**
+ * Delays execution for a specified amount of time
+ * @param ms - Milliseconds to delay
+ */
+declare function delay(ms: number): Promise<void>;
+/**
+ * Creates a spy function that records calls and arguments
+ * @returns Spy function with call tracking
+ */
+declare function createSpy<TArgs extends unknown[], TReturn>(implementation?: (...args: TArgs) => TReturn): {
+  (...args: TArgs): TReturn;
+  calls: TArgs[];
+  callCount: number;
+  reset: () => void;
+};
+/**
+ * Creates a mock function that returns predefined values
+ * @param returnValues - Array of values to return on consecutive calls
+ * @returns Mock function
+ */
+declare function createMockFn<T>(...returnValues: T[]): () => T;
+/**
+ * Creates a mock promise that can be resolved or rejected manually
+ * @returns Object with promise and resolve/reject functions
+ */
+declare function createDeferredPromise<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason?: unknown) => void;
+};
+/**
+ * Captures console output during test execution
+ * @param fn - Function to execute while capturing output
+ * @returns Object with stdout and stderr arrays
+ */
+declare function captureConsole<T>(fn: () => Promise<T> | T): Promise<{
+  stdout: string[];
+  stderr: string[];
+  result: T;
+}>;
+/**
+ * Creates a unique temporary directory for tests in /tmp
+ * @param prefix - Optional prefix for the directory name (default: "omnidev-test-")
+ * @returns Path to the created temporary directory
+ */
+declare function tmpdir(prefix?: string): string;
+type TestDirOptions = {
+  chdir?: boolean;
+  createOmniDir?: boolean;
+};
+type TestDirController = {
+  readonly path: string;
+  readonly originalCwd: string;
+  setPath: (path: string, options?: TestDirOptions) => void;
+  reset: (prefix?: string, options?: TestDirOptions & {
+    cleanupPrevious?: boolean;
+  }) => string;
+};
+/**
+ * Sets up a temporary directory for each test and cleans it up automatically.
+ * Registers beforeEach/afterEach hooks on call.
+ */
+declare function setupTestDir(prefix?: string, options?: TestDirOptions): TestDirController;
+//#endregion
+//#region src/test-utils/mocks.d.ts
+/**
+ * Mock factories for creating test data
+ */
+interface MockCapability {
+  id: string;
+  name: string;
+  version: string;
+  enabled?: boolean;
+  metadata?: Record<string, unknown>;
+}
+interface MockConfig {
+  project: string;
+  capabilities: {
+    enable: string[];
+    disable?: string[];
+  };
+  profiles?: Record<string, unknown>;
+  env?: Record<string, string>;
+}
+interface MockSkill {
+  id: string;
+  name: string;
+  description: string;
+  instructions: string;
+  triggers?: string[];
+}
+interface MockRule {
+  id: string;
+  name: string;
+  content: string;
+  priority?: number;
+}
+/**
+ * Creates a mock capability with default values
+ * @param overrides - Partial capability object to override defaults
+ * @returns Mock capability object
+ */
+declare function createMockCapability(overrides?: Partial<MockCapability>): MockCapability;
+/**
+ * Creates a mock config with default values
+ * @param overrides - Partial config object to override defaults
+ * @returns Mock config object
+ */
+declare function createMockConfig(overrides?: Partial<MockConfig>): MockConfig;
+/**
+ * Creates a mock skill with default values
+ * @param overrides - Partial skill object to override defaults
+ * @returns Mock skill object
+ */
+declare function createMockSkill(overrides?: Partial<MockSkill>): MockSkill;
+/**
+ * Creates a mock rule with default values
+ * @param overrides - Partial rule object to override defaults
+ * @returns Mock rule object
+ */
+declare function createMockRule(overrides?: Partial<MockRule>): MockRule;
+//#endregion
+export { type MockCapability, type MockConfig, type MockRule, type MockSkill, type TestDirController, type TestDirOptions, captureConsole, createDeferredPromise, createMockCapability, createMockConfig, createMockFn, createMockRule, createMockSkill, createSpy, delay, expectToThrowAsync, setupTestDir, tmpdir, waitForCondition };

package/dist/test-utils/index.js

@@ -0,0 +1,261 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { afterEach, beforeEach, expect } from "bun:test";
+import { tmpdir as tmpdir$1 } from "node:os";
+
+//#region src/test-utils/helpers.ts
+/**
+* Expects an async function to throw an error
+* @param fn - Async function that should throw
+* @param errorMatch - Optional string or regex to match against error message
+* @throws If the function doesn't throw
+*/
+async function expectToThrowAsync(fn, errorMatch) {
+	let threw = false;
+	let caughtError;
+	try {
+		await fn();
+	} catch (e) {
+		threw = true;
+		caughtError = e;
+	}
+	expect(threw).toBe(true);
+	if (errorMatch && caughtError) if (typeof errorMatch === "string") expect(caughtError.message).toContain(errorMatch);
+	else expect(caughtError.message).toMatch(errorMatch);
+}
+/**
+* Waits for a condition to be true
+* @param condition - Function that returns true when condition is met
+* @param timeout - Maximum time to wait in milliseconds (default: 1000)
+* @param interval - Check interval in milliseconds (default: 50)
+* @throws If timeout is reached before condition is met
+*/
+async function waitForCondition(condition, timeout = 1e3, interval = 50) {
+	const startTime = Date.now();
+	while (Date.now() - startTime < timeout) {
+		const result = await condition();
+		if (result) return;
+		await delay(interval);
+	}
+	throw new Error(`Condition not met within ${timeout}ms`);
+}
+/**
+* Delays execution for a specified amount of time
+* @param ms - Milliseconds to delay
+*/
+function delay(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+* Creates a spy function that records calls and arguments
+* @returns Spy function with call tracking
+*/
+function createSpy(implementation) {
+	const calls = [];
+	const spy = (...args) => {
+		calls.push(args);
+		if (implementation) return implementation(...args);
+		return void 0;
+	};
+	Object.defineProperty(spy, "calls", { get: () => calls });
+	Object.defineProperty(spy, "callCount", { get: () => calls.length });
+	spy.reset = () => {
+		calls.length = 0;
+	};
+	return spy;
+}
+/**
+* Creates a mock function that returns predefined values
+* @param returnValues - Array of values to return on consecutive calls
+* @returns Mock function
+*/
+function createMockFn(...returnValues) {
+	let callIndex = 0;
+	return () => {
+		if (callIndex >= returnValues.length) throw new Error("Mock function called more times than return values provided");
+		const value = returnValues[callIndex++];
+		if (value === void 0) throw new Error("Mock function returned undefined");
+		return value;
+	};
+}
+/**
+* Creates a mock promise that can be resolved or rejected manually
+* @returns Object with promise and resolve/reject functions
+*/
+function createDeferredPromise() {
+	let resolveRef;
+	let rejectRef;
+	const promise = new Promise((res, rej) => {
+		resolveRef = res;
+		rejectRef = rej;
+	});
+	if (!resolveRef || !rejectRef) throw new Error("Promise executor did not initialize resolve/reject");
+	return {
+		promise,
+		resolve: resolveRef,
+		reject: rejectRef
+	};
+}
+/**
+* Captures console output during test execution
+* @param fn - Function to execute while capturing output
+* @returns Object with stdout and stderr arrays
+*/
+async function captureConsole(fn) {
+	const stdout = [];
+	const stderr = [];
+	const originalLog = console.log;
+	const originalError = console.error;
+	const originalWarn = console.warn;
+	console.log = (...args) => {
+		stdout.push(args.map(String).join(" "));
+	};
+	console.error = (...args) => {
+		stderr.push(args.map(String).join(" "));
+	};
+	console.warn = (...args) => {
+		stderr.push(args.map(String).join(" "));
+	};
+	try {
+		const result = await fn();
+		return {
+			stdout,
+			stderr,
+			result
+		};
+	} finally {
+		console.log = originalLog;
+		console.error = originalError;
+		console.warn = originalWarn;
+	}
+}
+/**
+* Creates a unique temporary directory for tests in /tmp
+* @param prefix - Optional prefix for the directory name (default: "omnidev-test-")
+* @returns Path to the created temporary directory
+*/
+function tmpdir(prefix = "omnidev-test-") {
+	return mkdtempSync(join(tmpdir$1(), prefix));
+}
+/**
+* Sets up a temporary directory for each test and cleans it up automatically.
+* Registers beforeEach/afterEach hooks on call.
+*/
+function setupTestDir(prefix = "omnidev-test-", options = {}) {
+	let currentDir = "";
+	let originalCwd = "";
+	let shouldChdir = options.chdir ?? false;
+	let shouldCreateOmniDir = options.createOmniDir ?? false;
+	const applyOptions = (dir, nextOptions) => {
+		if (nextOptions) {
+			if (typeof nextOptions.chdir === "boolean") shouldChdir = nextOptions.chdir;
+			if (typeof nextOptions.createOmniDir === "boolean") shouldCreateOmniDir = nextOptions.createOmniDir;
+		}
+		if (shouldCreateOmniDir) mkdirSync(join(dir, ".omni"), { recursive: true });
+		if (shouldChdir) process.chdir(dir);
+	};
+	beforeEach(() => {
+		originalCwd = process.cwd();
+		currentDir = tmpdir(prefix);
+		applyOptions(currentDir);
+	});
+	afterEach(() => {
+		if (shouldChdir) process.chdir(originalCwd);
+		if (currentDir && existsSync(currentDir)) rmSync(currentDir, {
+			recursive: true,
+			force: true
+		});
+	});
+	return {
+		get path() {
+			return currentDir;
+		},
+		get originalCwd() {
+			return originalCwd;
+		},
+		setPath(path, nextOptions) {
+			currentDir = path;
+			applyOptions(currentDir, nextOptions);
+		},
+		reset(nextPrefix = prefix, nextOptions) {
+			const cleanupPrevious = nextOptions?.cleanupPrevious ?? true;
+			if (cleanupPrevious && currentDir && existsSync(currentDir)) {
+				if (shouldChdir) process.chdir(originalCwd);
+				rmSync(currentDir, {
+					recursive: true,
+					force: true
+				});
+			}
+			currentDir = tmpdir(nextPrefix);
+			applyOptions(currentDir, nextOptions);
+			return currentDir;
+		}
+	};
+}
+
+//#endregion
+//#region src/test-utils/mocks.ts
+/**
+* Creates a mock capability with default values
+* @param overrides - Partial capability object to override defaults
+* @returns Mock capability object
+*/
+function createMockCapability(overrides = {}) {
+	return {
+		id: "test-capability",
+		name: "Test Capability",
+		version: "1.0.0",
+		enabled: true,
+		metadata: {},
+		...overrides
+	};
+}
+/**
+* Creates a mock config with default values
+* @param overrides - Partial config object to override defaults
+* @returns Mock config object
+*/
+function createMockConfig(overrides = {}) {
+	return {
+		project: "test-project",
+		capabilities: {
+			enable: [],
+			disable: []
+		},
+		profiles: {},
+		env: {},
+		...overrides
+	};
+}
+/**
+* Creates a mock skill with default values
+* @param overrides - Partial skill object to override defaults
+* @returns Mock skill object
+*/
+function createMockSkill(overrides = {}) {
+	return {
+		id: "test-skill",
+		name: "Test Skill",
+		description: "A test skill for unit testing",
+		instructions: "Test instructions",
+		triggers: [],
+		...overrides
+	};
+}
+/**
+* Creates a mock rule with default values
+* @param overrides - Partial rule object to override defaults
+* @returns Mock rule object
+*/
+function createMockRule(overrides = {}) {
+	return {
+		id: "test-rule",
+		name: "Test Rule",
+		content: "# Test Rule\n\nTest rule content",
+		priority: 1,
+		...overrides
+	};
+}
+
+//#endregion
+export { captureConsole, createDeferredPromise, createMockCapability, createMockConfig, createMockFn, createMockRule, createMockSkill, createSpy, delay, expectToThrowAsync, setupTestDir, tmpdir, waitForCondition };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@omnidev-ai/core",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"type": "module",
 	"license": "MIT",
 	"repository": {
@@ -9,11 +9,19 @@
 		"directory": "packages/core"
 	},
 	"exports": {
-		".": "./src/index.ts",
-		"./test-utils": "./src/test-utils/index.ts"
+		".": {
+			"types": "./dist/index.d.ts",
+			"bun": "./src/index.ts",
+			"default": "./dist/index.js"
+		},
+		"./test-utils": {
+			"types": "./dist/test-utils/index.d.ts",
+			"bun": "./src/test-utils/index.ts",
+			"default": "./dist/test-utils/index.js"
+		}
 	},
 	"files": [
-		"src",
+		"dist",
 		"README.md"
 	],
 	"publishConfig": {
@@ -22,11 +30,13 @@
 	},
 	"scripts": {
 		"typecheck": "tsc --noEmit",
-		"build": "echo 'Build not needed for Bun runtime'"
+		"build": "tsdown"
 	},
 	"dependencies": {
 		"@stricli/core": "^1.2.5",
 		"smol-toml": "^1.6.0"
 	},
-	"devDependencies": {}
+	"devDependencies": {
+		"tsdown": "^0.12.5"
+	}
 }

package/src/capability/AGENTS.md

@@ -1,58 +0,0 @@
-# PROJECT KNOWLEDGE BASE
-
-**Generated:** 2026-01-12
-**Commit:** (not specified)
-**Branch:** (not specified)
-
-## OVERVIEW
-Core capability loading system: discovers capabilities from .omni/capabilities/ & capabilities/, validates TOML configs, loads TypeScript exports (skills/rules/docs/commands/subagents), and builds runtime registry.
-
-## WHERE TO LOOK
-| Task | Location | Notes |
-|------|----------|-------|
-| Capability discovery | loader.ts | Scans .omni/capabilities/ & capabilities/ for capability.toml |
-| Load TOML config | loader.ts | Validates required fields, checks reserved names |
-| Dynamic imports | loader.ts | Imports index.ts exports, handles missing deps gracefully |
-| Registry build | registry.ts | Filters by enabled caps, aggregates all content types |
-| Skills loading | skills.ts | Parses SKILL.md with YAML frontmatter |
-| Rules loading | rules.ts | Loads *.md from rules/ directory |
-| Docs loading | docs.ts | Loads definition.md + docs/*.md |
-| Commands loading | commands.ts | Parses COMMAND.md with YAML frontmatter |
-| Subagents loading | subagents.ts | Parses SUBAGENT.md, supports tools/skills/models |
-| Remote sources | sources.ts | Git clone/fetch, wrap external repos, lock file mgmt |
-
-## CONVENTIONS
-
-**Capability Structure:**
-- Must have capability.toml in root
-- Optional: index.ts (exports: skills/rules/docs/commands/subagents/gitignore)
-- Optional directories: skills/, rules/, docs/, commands/, subagents/
-- Optional types.d.ts (for LLM type hints)
-
-**YAML Frontmatter Format:**
-- Skills/Commands: name, description (required)
-- Subagents: name, description + optional tools/disallowedTools/model/permissionMode/skills
-- Supports kebab-case keys (converted to camelCase)
-
-**Content Loading Priority:**
-- Programmatic exports (index.ts) take precedence over file-based content
-- Loader converts both old and new export formats automatically
-
-**Reserved Names:**
-- Node builtins (fs, path, http, crypto, os, etc.)
-- Common libs (react, vue, lodash, axios, express, typescript)
-- Prevents import conflicts with capability modules
-
-**Remote Capability Sources:**
-- Shorthand: "github:user/repo#ref"
-- Lock file: .omni/capabilities.lock.toml (tracks versions/commits)
-- Wrap mode: discovers skills/agents/commands in repo without capability.toml
-- Version: from package.json if available, else short commit hash
-
-## ANTI-PATTERNS (THIS MODULE)
-
-- **NEVER** use reserved capability names (fs, path, react, typescript, etc.)
-- **NEVER** commit capabilities.lock.toml modifications - auto-generated
-- **NEVER** skip YAML frontmatter validation - name/description required
-- **NEVER** modify generated capability.toml in wrapped repos
-- **NEVER** assume index.ts exists - loader returns empty object if missing