@omnidev-ai/core 0.1.0

package/src/gitignore/manager.test.ts

@@ -0,0 +1,219 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import {
+	addCapabilityPatterns,
+	buildGitignoreContent,
+	parseCapabilitySections,
+	readGitignore,
+	rebuildGitignore,
+	removeCapabilityPatterns,
+	writeGitignore,
+} from "./manager.js";
+
+const TEST_DIR = ".omni-test-gitignore";
+
+describe("Gitignore Manager", () => {
+	beforeEach(() => {
+		// Create test directory
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true });
+		}
+		mkdirSync(TEST_DIR, { recursive: true });
+
+		// Change working directory
+		process.chdir(TEST_DIR);
+	});
+
+	afterEach(() => {
+		// Restore working directory
+		process.chdir("..");
+
+		// Clean up test directory
+		if (existsSync(TEST_DIR)) {
+			rmSync(TEST_DIR, { recursive: true });
+		}
+	});
+
+	describe("readGitignore", () => {
+		test("returns base content when file doesn't exist", async () => {
+			const content = await readGitignore();
+			expect(content).toContain("# OmniDev working files");
+			expect(content).toContain(".env");
+			expect(content).toContain("generated/");
+		});
+
+		test("returns existing content when file exists", async () => {
+			await writeGitignore("# Custom content\n*.tmp\n");
+			const content = await readGitignore();
+			expect(content).toBe("# Custom content\n*.tmp\n");
+		});
+	});
+
+	describe("parseCapabilitySections", () => {
+		test("parses empty content", () => {
+			const sections = parseCapabilitySections("");
+			expect(sections.size).toBe(0);
+		});
+
+		test("parses single capability section", () => {
+			const content = `# Base content
+
+# tasks capability
+work/
+*.tmp
+
+# End`;
+
+			const sections = parseCapabilitySections(content);
+			expect(sections.size).toBe(1);
+			expect(sections.get("tasks")).toEqual(["work/", "*.tmp"]);
+		});
+
+		test("parses multiple capability sections", () => {
+			const content = `# Base content
+
+# tasks capability
+work/
+*.tmp
+
+# ralph capability
+progress.txt
+*.log
+
+# End`;
+
+			const sections = parseCapabilitySections(content);
+			expect(sections.size).toBe(2);
+			expect(sections.get("tasks")).toEqual(["work/", "*.tmp"]);
+			expect(sections.get("ralph")).toEqual(["progress.txt", "*.log"]);
+		});
+
+		test("handles capability with no patterns", () => {
+			const content = `# tasks capability
+
+# ralph capability
+progress.txt`;
+
+			const sections = parseCapabilitySections(content);
+			expect(sections.size).toBe(1);
+			expect(sections.get("ralph")).toEqual(["progress.txt"]);
+		});
+	});
+
+	describe("buildGitignoreContent", () => {
+		test("builds base content with no capabilities", () => {
+			const content = buildGitignoreContent(new Map());
+			expect(content).toContain("# OmniDev working files");
+			expect(content).toContain(".env");
+			expect(content).not.toContain("# tasks capability");
+		});
+
+		test("builds content with single capability", () => {
+			const sections = new Map([["tasks", ["work/", "*.tmp"]]]);
+			const content = buildGitignoreContent(sections);
+			expect(content).toContain("# tasks capability");
+			expect(content).toContain("work/");
+			expect(content).toContain("*.tmp");
+		});
+
+		test("builds content with multiple capabilities", () => {
+			const sections = new Map([
+				["tasks", ["work/", "*.tmp"]],
+				["ralph", ["progress.txt"]],
+			]);
+			const content = buildGitignoreContent(sections);
+			expect(content).toContain("# tasks capability");
+			expect(content).toContain("work/");
+			expect(content).toContain("# ralph capability");
+			expect(content).toContain("progress.txt");
+		});
+
+		test("skips capabilities with empty patterns", () => {
+			const sections = new Map([
+				["tasks", []],
+				["ralph", ["progress.txt"]],
+			]);
+			const content = buildGitignoreContent(sections);
+			expect(content).not.toContain("# tasks capability");
+			expect(content).toContain("# ralph capability");
+		});
+	});
+
+	describe("addCapabilityPatterns", () => {
+		test("adds patterns to empty file", async () => {
+			await addCapabilityPatterns("tasks", ["work/", "*.tmp"]);
+			const content = await readGitignore();
+			expect(content).toContain("# tasks capability");
+			expect(content).toContain("work/");
+			expect(content).toContain("*.tmp");
+		});
+
+		test("adds patterns to existing file", async () => {
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await addCapabilityPatterns("ralph", ["progress.txt"]);
+
+			const content = await readGitignore();
+			expect(content).toContain("# tasks capability");
+			expect(content).toContain("work/");
+			expect(content).toContain("# ralph capability");
+			expect(content).toContain("progress.txt");
+		});
+
+		test("updates existing capability patterns", async () => {
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await addCapabilityPatterns("tasks", ["work/", "*.tmp"]);
+
+			const content = await readGitignore();
+			const sections = parseCapabilitySections(content);
+			expect(sections.get("tasks")).toEqual(["work/", "*.tmp"]);
+		});
+	});
+
+	describe("removeCapabilityPatterns", () => {
+		test("removes capability patterns", async () => {
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await addCapabilityPatterns("ralph", ["progress.txt"]);
+			await removeCapabilityPatterns("tasks");
+
+			const content = await readGitignore();
+			expect(content).not.toContain("# tasks capability");
+			expect(content).toContain("# ralph capability");
+		});
+
+		test("handles removing non-existent capability", async () => {
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await removeCapabilityPatterns("nonexistent");
+
+			const content = await readGitignore();
+			expect(content).toContain("# tasks capability");
+		});
+	});
+
+	describe("rebuildGitignore", () => {
+		test("rebuilds gitignore from scratch", async () => {
+			// Add some capabilities manually
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await addCapabilityPatterns("ralph", ["progress.txt"]);
+
+			// Rebuild with only one capability
+			const newSections = new Map([["tasks", ["new-work/", "*.new"]]]);
+			await rebuildGitignore(newSections);
+
+			const content = await readGitignore();
+			expect(content).toContain("# tasks capability");
+			expect(content).toContain("new-work/");
+			expect(content).toContain("*.new");
+			expect(content).not.toContain("# ralph capability");
+			expect(content).not.toContain("progress.txt");
+		});
+
+		test("rebuilds empty gitignore", async () => {
+			await addCapabilityPatterns("tasks", ["work/"]);
+			await rebuildGitignore(new Map());
+
+			const content = await readGitignore();
+			expect(content).not.toContain("# tasks capability");
+			expect(content).toContain("# OmniDev working files");
+		});
+	});
+});

package/src/gitignore/manager.ts

@@ -0,0 +1,167 @@
+import { existsSync } from "node:fs";
+
+const GITIGNORE_PATH = ".omni/.gitignore";
+
+/**
+ * Base gitignore patterns that are always present
+ */
+function getBaseGitignore(): string {
+	return `# OmniDev working files - always ignored
+# These files change frequently and are machine-specific
+
+# Secrets
+.env
+
+# Generated content (rebuilt on sync)
+generated/
+
+# Runtime state
+state/
+
+# Sandbox execution
+sandbox/
+
+# Logs
+*.log
+
+# ============================================
+# Capability-specific patterns (auto-managed)
+# ============================================
+`;
+}
+
+/**
+ * Read the current .omni/.gitignore file
+ * @returns Current gitignore content or base content if file doesn't exist
+ */
+export async function readGitignore(): Promise<string> {
+	if (!existsSync(GITIGNORE_PATH)) {
+		return getBaseGitignore();
+	}
+	return Bun.file(GITIGNORE_PATH).text();
+}
+
+/**
+ * Write content to .omni/.gitignore
+ * @param content - Content to write
+ */
+export async function writeGitignore(content: string): Promise<void> {
+	await Bun.write(GITIGNORE_PATH, content);
+}
+
+/**
+ * Parse gitignore content and extract capability sections
+ * @param content - The gitignore file content
+ * @returns Map of capability names to their patterns
+ */
+export function parseCapabilitySections(content: string): Map<string, string[]> {
+	const sections = new Map<string, string[]>();
+	const lines = content.split("\n");
+
+	let currentCapability: string | null = null;
+	const patterns: string[] = [];
+
+	for (const line of lines) {
+		// Check for capability header (e.g., "# tasks capability")
+		const headerMatch = line.match(/^# (\S+) capability$/);
+		if (headerMatch?.[1]) {
+			// Save previous capability if exists
+			if (currentCapability !== null) {
+				sections.set(currentCapability, [...patterns]);
+				patterns.length = 0;
+			}
+			currentCapability = headerMatch[1];
+			continue;
+		}
+
+		// If we're in a capability section, collect patterns
+		if (currentCapability !== null) {
+			// Stop at the next comment or empty line after patterns
+			if (line.trim() === "" || (line.startsWith("#") && !line.match(/^# \S+ capability$/))) {
+				// Only save if we have patterns
+				if (patterns.length > 0) {
+					sections.set(currentCapability, [...patterns]);
+				}
+				patterns.length = 0;
+				currentCapability = null;
+				continue;
+			}
+
+			// Add pattern if it's not a comment
+			if (line.trim() !== "" && !line.startsWith("#")) {
+				patterns.push(line);
+			}
+		}
+	}
+
+	// Save last capability if exists
+	if (currentCapability !== null && patterns.length > 0) {
+		sections.set(currentCapability, patterns);
+	}
+
+	return sections;
+}
+
+/**
+ * Build gitignore content from base + capability sections
+ * @param capabilitySections - Map of capability names to their patterns
+ * @returns Full gitignore content
+ */
+export function buildGitignoreContent(capabilitySections: Map<string, string[]>): string {
+	let content = getBaseGitignore();
+
+	// Add each capability section
+	for (const [capability, patterns] of capabilitySections) {
+		if (patterns.length > 0) {
+			content += `\n# ${capability} capability\n`;
+			for (const pattern of patterns) {
+				content += `${pattern}\n`;
+			}
+		}
+	}
+
+	return content;
+}
+
+/**
+ * Add gitignore patterns for a capability
+ * @param capabilityId - The capability ID
+ * @param patterns - Array of gitignore patterns
+ */
+export async function addCapabilityPatterns(
+	capabilityId: string,
+	patterns: string[],
+): Promise<void> {
+	const content = await readGitignore();
+	const sections = parseCapabilitySections(content);
+
+	// Add or update the capability section
+	sections.set(capabilityId, patterns);
+
+	const newContent = buildGitignoreContent(sections);
+	await writeGitignore(newContent);
+}
+
+/**
+ * Remove gitignore patterns for a capability
+ * @param capabilityId - The capability ID
+ */
+export async function removeCapabilityPatterns(capabilityId: string): Promise<void> {
+	const content = await readGitignore();
+	const sections = parseCapabilitySections(content);
+
+	// Remove the capability section
+	sections.delete(capabilityId);
+
+	const newContent = buildGitignoreContent(sections);
+	await writeGitignore(newContent);
+}
+
+/**
+ * Rebuild the entire .omni/.gitignore from enabled capabilities
+ * @param enabledCapabilities - Map of enabled capability IDs to their gitignore patterns
+ */
+export async function rebuildGitignore(enabledCapabilities: Map<string, string[]>): Promise<void> {
+	const newContent = buildGitignoreContent(enabledCapabilities);
+	await writeGitignore(newContent);
+}

package/src/index.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+import { getVersion, version } from "./index";
+
+describe("@omnidev-ai/core", () => {
+	describe("version", () => {
+		test("should be defined as a string", () => {
+			expect(typeof version).toBe("string");
+		});
+
+		test("should follow semantic versioning format", () => {
+			expect(version).toMatch(/^\d+\.\d+\.\d+$/);
+		});
+	});
+
+	describe("getVersion", () => {
+		test("should return the version string", () => {
+			const result = getVersion();
+			expect(result).toBe(version);
+		});
+
+		test("should return a non-empty string", () => {
+			const result = getVersion();
+			expect(result.length).toBeGreaterThan(0);
+		});
+	});
+});

package/src/index.ts

@@ -0,0 +1,39 @@
+/**
+ * @omnidev-ai/core - Core functionality for OmniDev
+ *
+ * This package contains shared types, utilities, and core logic
+ * used across the CLI and MCP server packages.
+ */
+
+// Re-export @stricli/core for capabilities to use
+// This ensures all capabilities use the same @stricli/core instance as the CLI
+export { buildCommand, buildRouteMap } from "@stricli/core";
+
+export const version = "0.1.0";
+
+export function getVersion(): string {
+	return version;
+}
+
+// Export capability system
+export * from "./capability";
+
+// Export config functionality
+export * from "./config";
+// Export gitignore management
+export * from "./gitignore/manager";
+// Export MCP JSON management
+export * from "./mcp-json";
+// Export state management
+export * from "./state";
+// Export sync functionality
+export * from "./sync";
+
+// Export templates
+export * from "./templates/agents";
+export * from "./templates/claude";
+// Export core types
+export * from "./types";
+
+// Export debug utilities
+export * from "./debug";

package/src/mcp-json/index.ts

@@ -0,0 +1 @@
+export * from "./manager";