@omnidev-ai/core 0.1.0

package/src/test-utils/helpers.ts

@@ -0,0 +1,187 @@
+/**
+ * Helper functions for testing
+ */
+
+import { expect } from "bun:test";
+
+/**
+ * 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
+ */
+export async function expectToThrowAsync(
+	fn: () => Promise<unknown>,
+	errorMatch?: string | RegExp,
+): Promise<void> {
+	let threw = false;
+	let caughtError: Error | undefined;
+
+	try {
+		await fn();
+	} catch (e) {
+		threw = true;
+		caughtError = e as Error;
+	}
+
+	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
+ */
+export async function waitForCondition(
+	condition: () => boolean | Promise<boolean>,
+	timeout = 1000,
+	interval = 50,
+): Promise<void> {
+	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
+ */
+export function delay(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Creates a spy function that records calls and arguments
+ * @returns Spy function with call tracking
+ */
+export function createSpy<TArgs extends unknown[], TReturn>(
+	implementation?: (...args: TArgs) => TReturn,
+) {
+	const calls: TArgs[] = [];
+
+	const spy = ((...args: TArgs) => {
+		calls.push(args);
+		if (implementation) {
+			return implementation(...args);
+		}
+		return undefined as TReturn;
+	}) as {
+		(...args: TArgs): TReturn;
+		calls: TArgs[];
+		callCount: number;
+		reset: () => void;
+	};
+
+	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
+ */
+export function createMockFn<T>(...returnValues: T[]): () => T {
+	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 === undefined) {
+			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
+ */
+export function createDeferredPromise<T>() {
+	let resolveRef: ((value: T) => void) | undefined;
+	let rejectRef: ((reason?: unknown) => void) | undefined;
+
+	const promise = new Promise<T>((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
+ */
+export async function captureConsole<T>(
+	fn: () => Promise<T> | T,
+): Promise<{ stdout: string[]; stderr: string[]; result: T }> {
+	const stdout: string[] = [];
+	const stderr: string[] = [];
+
+	const originalLog = console.log;
+	const originalError = console.error;
+	const originalWarn = console.warn;
+
+	console.log = (...args: unknown[]) => {
+		stdout.push(args.map(String).join(" "));
+	};
+
+	console.error = (...args: unknown[]) => {
+		stderr.push(args.map(String).join(" "));
+	};
+
+	console.warn = (...args: unknown[]) => {
+		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;
+	}
+}

package/src/test-utils/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Test utilities for OmniDev
+ *
+ * This module provides shared test utilities including:
+ * - Mock factories for creating test data
+ * - Helper functions for async testing
+ * - Spy and mock function utilities
+ */
+
+// Re-export all helper functions
+export {
+	captureConsole,
+	createDeferredPromise,
+	createMockFn,
+	createSpy,
+	delay,
+	expectToThrowAsync,
+	waitForCondition,
+} from "./helpers";
+// Re-export all mock factories
+export {
+	createMockCapability,
+	createMockConfig,
+	createMockRule,
+	createMockSkill,
+	type MockCapability,
+	type MockConfig,
+	type MockRule,
+	type MockSkill,
+} from "./mocks";

package/src/test-utils/mocks.test.ts

@@ -0,0 +1,83 @@
+import { describe, expect, test } from "bun:test";
+import { createMockCapability, createMockConfig, createMockRule, createMockSkill } from "./mocks";
+
+describe("createMockCapability", () => {
+	test("should create a mock capability with default values", () => {
+		const capability = createMockCapability();
+		expect(capability.id).toBe("test-capability");
+		expect(capability.name).toBe("Test Capability");
+		expect(capability.version).toBe("1.0.0");
+		expect(capability.enabled).toBe(true);
+	});
+
+	test("should allow overriding default values", () => {
+		const capability = createMockCapability({
+			id: "custom-id",
+			name: "Custom Name",
+			version: "2.0.0",
+			enabled: false,
+		});
+		expect(capability.id).toBe("custom-id");
+		expect(capability.name).toBe("Custom Name");
+		expect(capability.version).toBe("2.0.0");
+		expect(capability.enabled).toBe(false);
+	});
+});
+
+describe("createMockConfig", () => {
+	test("should create a mock config with default values", () => {
+		const config = createMockConfig();
+		expect(config.project).toBe("test-project");
+		expect(config.capabilities.enable).toEqual([]);
+		expect(config.capabilities.disable).toEqual([]);
+	});
+
+	test("should allow overriding default values", () => {
+		const config = createMockConfig({
+			project: "custom-project",
+			capabilities: {
+				enable: ["cap1", "cap2"],
+			},
+		});
+		expect(config.project).toBe("custom-project");
+		expect(config.capabilities.enable).toEqual(["cap1", "cap2"]);
+	});
+});
+
+describe("createMockSkill", () => {
+	test("should create a mock skill with default values", () => {
+		const skill = createMockSkill();
+		expect(skill.id).toBe("test-skill");
+		expect(skill.name).toBe("Test Skill");
+		expect(skill.description).toBe("A test skill for unit testing");
+		expect(skill.instructions).toBe("Test instructions");
+	});
+
+	test("should allow overriding default values", () => {
+		const skill = createMockSkill({
+			id: "custom-skill",
+			triggers: ["trigger1", "trigger2"],
+		});
+		expect(skill.id).toBe("custom-skill");
+		expect(skill.triggers).toEqual(["trigger1", "trigger2"]);
+	});
+});
+
+describe("createMockRule", () => {
+	test("should create a mock rule with default values", () => {
+		const rule = createMockRule();
+		expect(rule.id).toBe("test-rule");
+		expect(rule.name).toBe("Test Rule");
+		expect(rule.content).toBe("# Test Rule\n\nTest rule content");
+		expect(rule.priority).toBe(1);
+	});
+
+	test("should allow overriding default values", () => {
+		const rule = createMockRule({
+			id: "custom-rule",
+			priority: 10,
+		});
+		expect(rule.id).toBe("custom-rule");
+		expect(rule.priority).toBe(10);
+	});
+});

package/src/test-utils/mocks.ts

@@ -0,0 +1,101 @@
+/**
+ * Mock factories for creating test data
+ */
+
+export interface MockCapability {
+	id: string;
+	name: string;
+	version: string;
+	enabled?: boolean;
+	metadata?: Record<string, unknown>;
+}
+
+export interface MockConfig {
+	project: string;
+	capabilities: {
+		enable: string[];
+		disable?: string[];
+	};
+	profiles?: Record<string, unknown>;
+	env?: Record<string, string>;
+}
+
+export interface MockSkill {
+	id: string;
+	name: string;
+	description: string;
+	instructions: string;
+	triggers?: string[];
+}
+
+export 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
+ */
+export function createMockCapability(overrides: Partial<MockCapability> = {}): MockCapability {
+	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
+ */
+export function createMockConfig(overrides: Partial<MockConfig> = {}): MockConfig {
+	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
+ */
+export function createMockSkill(overrides: Partial<MockSkill> = {}): MockSkill {
+	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
+ */
+export function createMockRule(overrides: Partial<MockRule> = {}): MockRule {
+	return {
+		id: "test-rule",
+		name: "Test Rule",
+		content: "# Test Rule\n\nTest rule content",
+		priority: 1,
+		...overrides,
+	};
+}

package/src/types/capability-export.ts

@@ -0,0 +1,234 @@
+/**
+ * Capability Export Types
+ *
+ * These types define the structure that capabilities use to export their features.
+ * Capabilities should import these types from @omnidev-ai/core and use them in their index.ts.
+ */
+
+/**
+ * File content structure for programmatic file creation
+ */
+export interface FileContent {
+	/** File name (relative path within capability) */
+	name: string;
+
+	/** File content */
+	content: string;
+}
+
+/**
+ * Documentation export structure
+ */
+export interface DocExport {
+	/** Document title */
+	title: string;
+
+	/** Markdown content */
+	content: string;
+}
+
+/**
+ * Skill export structure
+ */
+export interface SkillExport {
+	/** SKILL.md content (markdown with YAML frontmatter) */
+	skillMd: string;
+
+	/** Optional: Reference files to create (files the skill needs access to) */
+	references?: FileContent[];
+
+	/** Optional: Additional files to create (templates, examples, etc.) */
+	additionalFiles?: FileContent[];
+}
+
+/**
+ * JSON Schema type for tool parameters
+ */
+export interface JSONSchema {
+	type?: string | string[];
+	properties?: Record<string, JSONSchema>;
+	required?: string[];
+	items?: JSONSchema;
+	enum?: unknown[];
+	description?: string;
+	default?: unknown;
+	[key: string]: unknown;
+}
+
+/**
+ * Subagent export structure
+ *
+ * Defines a subagent that Claude can delegate tasks to.
+ * Uses YAML frontmatter in markdown format for configuration.
+ *
+ * @example
+ * ```typescript
+ * const codeReviewer: SubagentExport = {
+ *   subagentMd: `---
+ * name: code-reviewer
+ * description: Reviews code for quality and best practices
+ * tools: Read, Glob, Grep
+ * model: sonnet
+ * ---
+ *
+ * You are a code reviewer. When invoked, analyze the code and provide
+ * specific, actionable feedback on quality, security, and best practices.`
+ * };
+ * ```
+ */
+export interface SubagentExport {
+	/** SUBAGENT.md content (markdown with YAML frontmatter) */
+	subagentMd: string;
+}
+
+/**
+ * Slash command export structure
+ *
+ * Defines a slash command that can be invoked in Claude Code.
+ * Uses YAML frontmatter in markdown format for configuration.
+ *
+ * @example
+ * ```typescript
+ * const fixIssue: CommandExport = {
+ *   commandMd: `---
+ * name: fix-issue
+ * description: Fix a GitHub issue following coding standards
+ * allowed-tools: Bash(git add:*), Bash(git commit:*)
+ * ---
+ *
+ * Fix issue #$ARGUMENTS following our coding standards.
+ *
+ * 1. Read the issue details
+ * 2. Implement the fix
+ * 3. Write tests
+ * 4. Create a commit`
+ * };
+ * ```
+ */
+export interface CommandExport {
+	/** COMMAND.md content (markdown with YAML frontmatter) */
+	commandMd: string;
+}
+
+/**
+ * Sandbox tool export structure
+ *
+ * Defines a tool that can be called from sandbox code via omni_execute.
+ * Full schema is required for proper introspection and type generation.
+ *
+ * For MCP wrapper capabilities, these are auto-discovered from the child MCP.
+ * For custom capabilities, these must be explicitly defined with full schemas.
+ *
+ * @example
+ * ```typescript
+ * const createTask: SandboxToolExport = {
+ *   name: "createTask",
+ *   description: "Create a new task",
+ *   inputSchema: {
+ *     type: "object",
+ *     properties: {
+ *       title: { type: "string", description: "Task title" },
+ *       priority: { type: "string", enum: ["low", "medium", "high"] }
+ *     },
+ *     required: ["title"]
+ *   },
+ *   outputSchema: {
+ *     type: "object",
+ *     properties: {
+ *       id: { type: "string" },
+ *       title: { type: "string" },
+ *       createdAt: { type: "string" }
+ *     }
+ *   },
+ *   specification: `/**
+ *    * Create a new task in the task management system.
+ *    * @param input.title - The title of the task (required)
+ *    * @param input.priority - Priority level (default: "medium")
+ *    * @returns The created task object with generated ID
+ *    *\/`
+ * };
+ * ```
+ */
+export interface SandboxToolExport {
+	/** Tool name (used as function name in sandbox) */
+	name: string;
+
+	/** Short description for overview listings */
+	description: string;
+
+	/** JSON Schema for input parameters (required for proper introspection) */
+	inputSchema: JSONSchema;
+
+	/** JSON Schema for output/return value */
+	outputSchema?: JSONSchema;
+
+	/**
+	 * Full specification/documentation for the tool.
+	 * Can include JSDoc, examples, detailed behavior notes.
+	 * This is shown when requesting full details for a specific tool.
+	 */
+	specification?: string;
+}
+
+/**
+ * Complete capability export structure
+ *
+ * Capabilities export this as their default export from index.ts.
+ * All content fields are OPTIONAL and PROGRAMMATIC.
+ * Capabilities can also provide content via static files in their directory.
+ * Both approaches are supported and will be merged during sync.
+ *
+ * @example
+ * ```typescript
+ * // Static files approach - just export CLI commands
+ * export default {
+ *   cliCommands: { mycap: myRoutes },
+ *   gitignore: ["mycap/"],
+ *   sync
+ * } satisfies CapabilityExport;
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Programmatic approach - generate content dynamically
+ * export default {
+ *   cliCommands: { mycap: myRoutes },
+ *   docs: [{ title: "Guide", content: "# Guide\n..." }],
+ *   rules: ["# Rule content..."],
+ *   skills: [{ skillMd: "...", references: [...] }],
+ *   gitignore: ["mycap/"],
+ *   sync
+ * } satisfies CapabilityExport;
+ * ```
+ */
+export interface CapabilityExport {
+	/** CLI commands provided by this capability */
+	cliCommands?: Record<string, unknown>; // stricli Command type
+
+	/** Sandbox tools provided by this capability (callable from omni_execute) */
+	sandboxTools?: Record<string, SandboxToolExport>;
+
+	/** Documentation (programmatic - optional, can also use docs/ directory) */
+	docs?: DocExport[];
+
+	/** Rules (programmatic - optional, can also use rules/ directory) */
+	rules?: string[]; // Array of markdown content strings
+
+	/** Skills (programmatic - optional, can also use skills/ directory) */
+	skills?: SkillExport[];
+
+	/** Subagents (programmatic - optional, can also use subagents/ directory) */
+	subagents?: SubagentExport[];
+
+	/** Commands (programmatic - optional, can also use commands/ directory) */
+	commands?: CommandExport[];
+
+	/** Gitignore patterns */
+	gitignore?: string[];
+
+	/** Custom sync hook function */
+	sync?: () => Promise<void>;
+
+	/** Additional exports for extensibility */
+	[key: string]: unknown;
+}

package/src/types/index.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, test } from "bun:test";
+import type { ProviderConfig } from "./index.js";
+import { getActiveProviders } from "./index.js";
+
+describe("getActiveProviders", () => {
+	test("returns providers array when present", () => {
+		const config: ProviderConfig = { providers: ["claude", "codex"] };
+		expect(getActiveProviders(config)).toEqual(["claude", "codex"]);
+	});
+
+	test("returns single provider as array when present", () => {
+		const config: ProviderConfig = { provider: "claude" };
+		expect(getActiveProviders(config)).toEqual(["claude"]);
+	});
+
+	test("prefers providers array over single provider", () => {
+		const config: ProviderConfig = {
+			provider: "claude",
+			providers: ["codex"],
+		};
+		expect(getActiveProviders(config)).toEqual(["codex"]);
+	});
+
+	test("returns claude as default when no provider specified", () => {
+		const config: ProviderConfig = {};
+		expect(getActiveProviders(config)).toEqual(["claude"]);
+	});
+});