@omnidev-ai/core 0.1.0

package/src/sync.ts

@@ -0,0 +1,213 @@
+import { spawn } from "node:child_process";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { buildCapabilityRegistry } from "./capability/registry";
+import { writeRules } from "./capability/rules";
+import { fetchAllCapabilitySources } from "./capability/sources";
+import { loadConfig } from "./config/loader";
+import { rebuildGitignore } from "./gitignore/manager";
+import { syncMcpJson } from "./mcp-json/manager";
+import {
+	buildManifestFromCapabilities,
+	cleanupStaleResources,
+	loadManifest,
+	saveManifest,
+} from "./state/manifest";
+
+export interface SyncResult {
+	capabilities: string[];
+	skillCount: number;
+	ruleCount: number;
+	docCount: number;
+}
+
+/**
+ * Install dependencies for capabilities in .omni/capabilities/
+ * Only installs for capabilities that have a package.json
+ */
+export async function installCapabilityDependencies(silent: boolean): Promise<void> {
+	const { existsSync, readdirSync } = await import("node:fs");
+	const { join } = await import("node:path");
+
+	const capabilitiesDir = ".omni/capabilities";
+
+	// Check if .omni/capabilities exists
+	if (!existsSync(capabilitiesDir)) {
+		return; // Nothing to install
+	}
+
+	const entries = readdirSync(capabilitiesDir, { withFileTypes: true });
+
+	for (const entry of entries) {
+		if (!entry.isDirectory()) {
+			continue;
+		}
+
+		const capabilityPath = join(capabilitiesDir, entry.name);
+		const packageJsonPath = join(capabilityPath, "package.json");
+
+		// Skip if no package.json
+		if (!existsSync(packageJsonPath)) {
+			continue;
+		}
+
+		if (!silent) {
+			console.log(`Installing dependencies for ${capabilityPath}...`);
+		}
+
+		// Run bun install in the capability directory
+		await new Promise<void>((resolve, reject) => {
+			const proc = spawn("bun", ["install"], {
+				cwd: capabilityPath,
+				stdio: silent ? "ignore" : "inherit",
+			});
+
+			proc.on("close", (code) => {
+				if (code === 0) {
+					resolve();
+				} else {
+					reject(new Error(`Failed to install dependencies for ${capabilityPath}`));
+				}
+			});
+
+			proc.on("error", (error) => {
+				reject(error);
+			});
+		});
+	}
+}
+
+/**
+ * Central sync function that regenerates all agent configuration files
+ * Called automatically after any config change (init, capability enable/disable, profile change)
+ */
+export async function syncAgentConfiguration(options?: { silent?: boolean }): Promise<SyncResult> {
+	const silent = options?.silent ?? false;
+
+	if (!silent) {
+		console.log("Syncing agent configuration...");
+	}
+
+	// Fetch capability sources from git repos FIRST (before discovery)
+	const config = await loadConfig();
+	await fetchAllCapabilitySources(config, { silent });
+
+	// Install capability dependencies before building registry
+	await installCapabilityDependencies(silent);
+
+	// Build registry
+	const registry = await buildCapabilityRegistry();
+	const capabilities = registry.getAllCapabilities();
+	const skills = registry.getAllSkills();
+	const rules = registry.getAllRules();
+	const docs = registry.getAllDocs();
+
+	// Load previous manifest and cleanup stale resources from disabled capabilities
+	const previousManifest = await loadManifest();
+	const currentCapabilityIds = new Set(capabilities.map((c) => c.id));
+
+	const cleanupResult = await cleanupStaleResources(previousManifest, currentCapabilityIds);
+
+	if (
+		!silent &&
+		(cleanupResult.deletedSkills.length > 0 || cleanupResult.deletedRules.length > 0)
+	) {
+		console.log("Cleaned up stale resources:");
+		if (cleanupResult.deletedSkills.length > 0) {
+			console.log(
+				`  - Removed ${cleanupResult.deletedSkills.length} skill(s): ${cleanupResult.deletedSkills.join(", ")}`,
+			);
+		}
+		if (cleanupResult.deletedRules.length > 0) {
+			console.log(
+				`  - Removed ${cleanupResult.deletedRules.length} rule(s): ${cleanupResult.deletedRules.join(", ")}`,
+			);
+		}
+	}
+
+	// Rebuild .omni/.gitignore with all enabled capability patterns
+	const gitignorePatterns = new Map<string, string[]>();
+	for (const capability of capabilities) {
+		if (capability.gitignore && capability.gitignore.length > 0) {
+			gitignorePatterns.set(capability.id, capability.gitignore);
+		}
+	}
+	await rebuildGitignore(gitignorePatterns);
+
+	// Call sync hooks for capabilities that have them
+	for (const capability of capabilities) {
+		// Check for structured export sync function first (new approach)
+		// biome-ignore lint/suspicious/noExplicitAny: Dynamic module exports need runtime type checking
+		const defaultExport = (capability.exports as any).default;
+		if (defaultExport && typeof defaultExport.sync === "function") {
+			try {
+				await defaultExport.sync();
+			} catch (error) {
+				console.error(`Error running sync hook for ${capability.id}:`, error);
+			}
+		}
+		// Fall back to TOML-based sync hook (legacy approach)
+		else if (capability.config.sync?.on_sync) {
+			const syncFnName = capability.config.sync.on_sync;
+			const syncFn = capability.exports[syncFnName];
+
+			if (typeof syncFn === "function") {
+				try {
+					await syncFn();
+				} catch (error) {
+					console.error(`Error running sync hook for ${capability.id}:`, error);
+				}
+			}
+		}
+	}
+
+	// Ensure directories exist
+	mkdirSync(".claude/skills", { recursive: true });
+	mkdirSync(".cursor/rules", { recursive: true });
+
+	// Write rules and docs to .omni/instructions.md
+	await writeRules(rules, docs);
+
+	// Write skills to .claude/skills/
+	for (const skill of skills) {
+		const skillDir = `.claude/skills/${skill.name}`;
+		mkdirSync(skillDir, { recursive: true });
+		await Bun.write(
+			join(skillDir, "SKILL.md"),
+			`---
+name: ${skill.name}
+description: "${skill.description}"
+---
+
+${skill.instructions}`,
+		);
+	}
+
+	// Write rules to .cursor/rules/
+	for (const rule of rules) {
+		await Bun.write(`.cursor/rules/omnidev-${rule.name}.mdc`, rule.content);
+	}
+
+	// Save updated manifest for future cleanup
+	const newManifest = buildManifestFromCapabilities(capabilities);
+	await saveManifest(newManifest);
+
+	// Sync .mcp.json based on sandbox mode
+	const sandboxEnabled = config.sandbox_enabled !== false;
+	await syncMcpJson(capabilities, sandboxEnabled, { silent });
+
+	if (!silent) {
+		console.log("✓ Synced:");
+		console.log("  - .omni/.gitignore (capability patterns)");
+		console.log(`  - .omni/instructions.md (${docs.length} docs, ${rules.length} rules)`);
+		console.log(`  - .claude/skills/ (${skills.length} skills)`);
+		console.log(`  - .cursor/rules/ (${rules.length} rules)`);
+	}
+
+	return {
+		capabilities: capabilities.map((c) => c.id),
+		skillCount: skills.length,
+		ruleCount: rules.length,
+		docCount: docs.length,
+	};
+}

package/src/templates/agents.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, test } from "bun:test";
+import { generateAgentsTemplate } from "./agents";
+
+describe("generateAgentsTemplate", () => {
+	test("generates AGENTS.md template with reference to instructions", () => {
+		const template = generateAgentsTemplate();
+
+		expect(template).toContain("# Project Instructions");
+		expect(template).toContain("@import .omni/instructions.md");
+	});
+
+	test("includes placeholder for project-specific instructions", () => {
+		const template = generateAgentsTemplate();
+
+		expect(template).toContain("<!-- Add your project-specific instructions here -->");
+	});
+
+	test("includes OmniDev section", () => {
+		const template = generateAgentsTemplate();
+
+		expect(template).toContain("## OmniDev");
+	});
+});

package/src/templates/agents.ts

@@ -0,0 +1,14 @@
+/**
+ * Template for AGENTS.md (Codex provider)
+ * Creates a minimal file with reference to OmniDev instructions
+ */
+export function generateAgentsTemplate(): string {
+	return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}

package/src/templates/claude.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from "bun:test";
+import { generateClaudeTemplate, generateInstructionsTemplate } from "./claude";
+
+describe("generateClaudeTemplate", () => {
+	test("generates CLAUDE.md template with reference to instructions", () => {
+		const template = generateClaudeTemplate();
+
+		expect(template).toContain("# Project Instructions");
+		expect(template).toContain("@import .omni/instructions.md");
+	});
+
+	test("includes placeholder for project-specific instructions", () => {
+		const template = generateClaudeTemplate();
+
+		expect(template).toContain("<!-- Add your project-specific instructions here -->");
+	});
+
+	test("includes OmniDev section", () => {
+		const template = generateClaudeTemplate();
+
+		expect(template).toContain("## OmniDev");
+	});
+});
+
+describe("generateInstructionsTemplate", () => {
+	test("generates instructions with project description placeholder", () => {
+		const template = generateInstructionsTemplate();
+
+		expect(template).toContain("# OmniDev Instructions");
+		expect(template).toContain("## Project Description");
+		expect(template).toContain("<!-- TODO: Add 2-3 sentences describing your project -->");
+		expect(template).toContain("[Describe what this project does and its main purpose]");
+	});
+
+	test("includes capabilities section with placeholder", () => {
+		const template = generateInstructionsTemplate();
+
+		expect(template).toContain("## Capabilities");
+		expect(template).toContain("No capabilities enabled yet");
+	});
+
+	test("includes BEGIN/END markers for generated content", () => {
+		const template = generateInstructionsTemplate();
+
+		expect(template).toContain("BEGIN OMNIDEV GENERATED CONTENT");
+		expect(template).toContain("END OMNIDEV GENERATED CONTENT");
+	});
+});

package/src/templates/claude.ts

@@ -0,0 +1,122 @@
+/**
+ * Template for CLAUDE.md (Claude provider)
+ * Creates a minimal file with reference to OmniDev instructions
+ */
+export function generateClaudeTemplate(): string {
+	return `# Project Instructions
+
+<!-- Add your project-specific instructions here -->
+
+## OmniDev
+
+@import .omni/instructions.md
+`;
+}
+
+/**
+ * Template for .omni/instructions.md
+ * Contains OmniDev-specific instructions and capability rules
+ */
+export function generateInstructionsTemplate(): string {
+	return `# OmniDev Instructions
+
+## Project Description
+<!-- TODO: Add 2-3 sentences describing your project -->
+[Describe what this project does and its main purpose]
+
+## How OmniDev Works
+
+OmniDev provides **three MCP tools** that give you programmatic access to capabilities:
+
+### \`omni_query\` - Search and Discovery
+
+Search across enabled capabilities, documentation, skills, and rules.
+
+\`\`\`json
+{
+  "query": "search query"  // Empty query returns summary of enabled capabilities
+}
+\`\`\`
+
+Returns short snippets with source tags. Use for finding relevant capabilities and documentation.
+
+### \`omni_sandbox_environment\` - Tool Introspection
+
+Discover available sandbox tools with three levels of detail:
+
+\`\`\`json
+// Level 1: Overview of all modules
+{}
+
+// Level 2: Module details with schemas
+{ "capability": "my-capability" }
+
+// Level 3: Full tool specification
+{ "capability": "my-capability", "tool": "myTool" }
+\`\`\`
+
+Use this to discover what tools are available and how to call them.
+
+### \`omni_execute\` - Programmatic Execution
+
+Execute TypeScript code in a sandboxed environment with access to all enabled capabilities.
+
+\`\`\`json
+{
+  "code": "full contents of main.ts file"
+}
+\`\`\`
+
+Write complete TypeScript programs that import capability modules:
+
+\`\`\`typescript
+import * as myCapability from 'my-capability';
+import * as fs from 'fs';
+
+export async function main(): Promise<number> {
+  // Your code here
+  console.log('Hello from OmniDev sandbox!');
+
+  return 0; // Success
+}
+\`\`\`
+
+**Response includes:**
+- \`stdout\` - Standard output
+- \`stderr\` - Standard error
+- \`exit_code\` - Exit code (0 = success)
+- \`changed_files\` - List of files modified
+- \`diff_stat\` - Summary of changes
+
+## The Sandbox
+
+The sandbox is a TypeScript execution environment located in \`.omni/sandbox/\`. It provides:
+
+1. **Isolated Execution** - Code runs in a controlled environment
+2. **Capability Access** - Import enabled capabilities as TypeScript modules
+3. **File System Access** - Read and write files in the project
+4. **Type Safety** - Full TypeScript support with IntelliSense
+
+**Key features:**
+- Runs using Bun runtime for speed
+- Auto-generated module wrappers for MCP capabilities
+- Direct symlinks to native capability code
+- All capability tools are available as typed functions
+
+**Example workflow:**
+1. Use \`omni_query\` (empty query) to see what capabilities are enabled
+2. Use \`omni_sandbox_environment\` to discover available tools and their schemas
+3. Use \`omni_sandbox_environment\` with capability + tool params for detailed specs
+4. Write TypeScript code that imports and uses capability tools
+5. Execute with \`omni_execute\`
+
+<!-- BEGIN OMNIDEV GENERATED CONTENT - DO NOT EDIT BELOW THIS LINE -->
+<!-- This section is automatically updated by 'omnidev agents sync' -->
+
+## Capabilities
+
+No capabilities enabled yet. Run \`omnidev capability enable <name>\` to enable capabilities.
+
+<!-- END OMNIDEV GENERATED CONTENT -->
+`;
+}

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

@@ -0,0 +1,196 @@
+import { describe, expect, test } from "bun:test";
+import {
+	captureConsole,
+	createDeferredPromise,
+	createMockFn,
+	createSpy,
+	delay,
+	expectToThrowAsync,
+	waitForCondition,
+} from "./helpers";
+
+describe("expectToThrowAsync", () => {
+	test("should pass when function throws", async () => {
+		await expectToThrowAsync(async () => {
+			throw new Error("Test error");
+		});
+	});
+
+	test("should match error message with string", async () => {
+		await expectToThrowAsync(async () => {
+			throw new Error("Test error message");
+		}, "Test error");
+	});
+
+	test("should match error message with regex", async () => {
+		await expectToThrowAsync(async () => {
+			throw new Error("Test error message");
+		}, /error/);
+	});
+
+	test("should fail when function does not throw", async () => {
+		let failed = false;
+		try {
+			await expectToThrowAsync(async () => {
+				// Does not throw
+			});
+		} catch {
+			failed = true;
+		}
+		expect(failed).toBe(true);
+	});
+});
+
+describe("waitForCondition", () => {
+	test("should resolve when condition is met immediately", async () => {
+		await waitForCondition(() => true);
+	});
+
+	test("should resolve when condition becomes true", async () => {
+		let counter = 0;
+		await waitForCondition(() => {
+			counter++;
+			return counter > 2;
+		});
+		expect(counter).toBeGreaterThan(2);
+	});
+
+	test("should timeout when condition is never met", async () => {
+		await expectToThrowAsync(async () => {
+			await waitForCondition(() => false, 100);
+		}, "Condition not met within 100ms");
+	});
+});
+
+describe("delay", () => {
+	test("should delay execution", async () => {
+		const start = Date.now();
+		await delay(50);
+		const elapsed = Date.now() - start;
+		expect(elapsed).toBeGreaterThanOrEqual(45); // Small tolerance
+	});
+});
+
+describe("createSpy", () => {
+	test("should track function calls", () => {
+		const spy = createSpy<[number, string], void>();
+		spy(1, "test");
+		spy(2, "test2");
+
+		expect(spy.callCount).toBe(2);
+		expect(spy.calls).toEqual([
+			[1, "test"],
+			[2, "test2"],
+		]);
+	});
+
+	test("should support custom implementation", () => {
+		const spy = createSpy((a: number, b: number) => a + b);
+		const result = spy(1, 2);
+
+		expect(result).toBe(3);
+		expect(spy.callCount).toBe(1);
+	});
+
+	test("should support reset", () => {
+		const spy = createSpy<[number], void>();
+		spy(1);
+		spy(2);
+		expect(spy.callCount).toBe(2);
+
+		spy.reset();
+		expect(spy.callCount).toBe(0);
+		expect(spy.calls).toEqual([]);
+	});
+});
+
+describe("createMockFn", () => {
+	test("should return values in order", () => {
+		const mock = createMockFn("first", "second", "third");
+		expect(mock()).toBe("first");
+		expect(mock()).toBe("second");
+		expect(mock()).toBe("third");
+	});
+
+	test("should throw when called more times than values", () => {
+		const mock = createMockFn("only");
+		mock();
+		expect(() => mock()).toThrow("Mock function called more times than return values provided");
+	});
+});
+
+describe("createDeferredPromise", () => {
+	test("should allow manual resolution", async () => {
+		const deferred = createDeferredPromise<string>();
+		deferred.resolve("test");
+		const result = await deferred.promise;
+		expect(result).toBe("test");
+	});
+
+	test("should allow manual rejection", async () => {
+		const deferred = createDeferredPromise<string>();
+		deferred.reject(new Error("test error"));
+		await expectToThrowAsync(async () => {
+			await deferred.promise;
+		}, "test error");
+	});
+});
+
+describe("captureConsole", () => {
+	test("should capture console.log output", async () => {
+		const { stdout, result } = await captureConsole(() => {
+			console.log("test message");
+			return "return value";
+		});
+
+		expect(stdout).toEqual(["test message"]);
+		expect(result).toBe("return value");
+	});
+
+	test("should capture console.error output", async () => {
+		const { stderr } = await captureConsole(() => {
+			console.error("error message");
+		});
+
+		expect(stderr).toEqual(["error message"]);
+	});
+
+	test("should capture console.warn output", async () => {
+		const { stderr } = await captureConsole(() => {
+			console.warn("warning message");
+		});
+
+		expect(stderr).toEqual(["warning message"]);
+	});
+
+	test("should work with async functions", async () => {
+		const { stdout, result } = await captureConsole(async () => {
+			await delay(10);
+			console.log("async message");
+			return 42;
+		});
+
+		expect(stdout).toEqual(["async message"]);
+		expect(result).toBe(42);
+	});
+
+	test("should restore console after execution", async () => {
+		const originalLog = console.log;
+		await captureConsole(() => {
+			console.log("test");
+		});
+		expect(console.log).toBe(originalLog);
+	});
+
+	test("should restore console even if function throws", async () => {
+		const originalLog = console.log;
+		try {
+			await captureConsole(() => {
+				throw new Error("test");
+			});
+		} catch {
+			// Expected
+		}
+		expect(console.log).toBe(originalLog);
+	});
+});