@omnidev-ai/core 0.8.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnidev-ai/core",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "license": "MIT",
   "repository": {

package/src/capability/loader.ts

@@ -3,6 +3,7 @@ import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { validateEnv } from "../config/env";
 import { parseCapabilityConfig } from "../config/parser";
+import { loadCapabilityHooks } from "../hooks/loader.js";
 import type {
 	CapabilityConfig,
 	Command,
@@ -405,6 +406,9 @@ export async function loadCapability(
 			? (exportsAny.gitignore as string[])
 			: undefined;
 
+	// Load hooks from hooks/hooks.toml if present
+	const hooks = loadCapabilityHooks(id, capabilityPath);
+
 	// Build result object with explicit handling for optional typeDefinitions
 	const result: LoadedCapability = {
 		id,
@@ -428,5 +432,10 @@ export async function loadCapability(
 		result.gitignore = gitignore;
 	}
 
+	// Only add hooks if found
+	if (hooks !== null) {
+		result.hooks = hooks;
+	}
+
 	return result;
 }

package/src/capability/registry.ts

@@ -1,6 +1,7 @@
 import { getEnabledCapabilities } from "../config/capabilities";
 import { loadEnvironment } from "../config/env";
-import type { Doc, LoadedCapability, Rule, Skill } from "../types";
+import { mergeHooksConfigs } from "../hooks/merger.js";
+import type { HooksConfig, CapabilityHooks, Doc, LoadedCapability, Rule, Skill } from "../types";
 import { discoverCapabilities, loadCapability } from "./loader";
 
 /**
@@ -13,6 +14,10 @@ export interface CapabilityRegistry {
 	getAllSkills(): Skill[];
 	getAllRules(): Rule[];
 	getAllDocs(): Doc[];
+	/** Get all capability hooks metadata */
+	getAllCapabilityHooks(): CapabilityHooks[];
+	/** Get merged hooks from all capabilities */
+	getMergedHooks(): HooksConfig;
 }
 
 /**
@@ -44,6 +49,17 @@ export async function buildCapabilityRegistry(): Promise<CapabilityRegistry> {
 		}
 	}
 
+	// Helper to get all capability hooks
+	const getAllCapabilityHooks = (): CapabilityHooks[] => {
+		const hooks: CapabilityHooks[] = [];
+		for (const cap of capabilities.values()) {
+			if (cap.hooks) {
+				hooks.push(cap.hooks);
+			}
+		}
+		return hooks;
+	};
+
 	return {
 		capabilities,
 		getCapability: (id: string) => capabilities.get(id),
@@ -51,5 +67,7 @@ export async function buildCapabilityRegistry(): Promise<CapabilityRegistry> {
 		getAllSkills: () => [...capabilities.values()].flatMap((c) => c.skills),
 		getAllRules: () => [...capabilities.values()].flatMap((c) => c.rules),
 		getAllDocs: () => [...capabilities.values()].flatMap((c) => c.docs),
+		getAllCapabilityHooks,
+		getMergedHooks: () => mergeHooksConfigs(getAllCapabilityHooks()),
 	};
 }

package/src/capability/sources.ts

@@ -10,7 +10,7 @@
 
 import { existsSync } from "node:fs";
 import { spawn } from "node:child_process";
-import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
+import { cp, mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { parse as parseToml } from "smol-toml";
 import type {
@@ -500,6 +500,38 @@ export interface DiscoveredContent {
 	docsDir: string | null;
 }
 
+/**
+ * Rename singular folder names to plural for consistency
+ * skill -> skills, command -> commands, rule -> rules, agent -> agents
+ */
+export async function normalizeFolderNames(repoPath: string): Promise<void> {
+	const renameMappings = [
+		{ from: "skill", to: "skills" },
+		{ from: "command", to: "commands" },
+		{ from: "rule", to: "rules" },
+		{ from: "agent", to: "agents" },
+		{ from: "subagent", to: "subagents" },
+	];
+
+	for (const { from, to } of renameMappings) {
+		const fromPath = join(repoPath, from);
+		const toPath = join(repoPath, to);
+
+		// Only rename if singular exists and plural doesn't
+		if (existsSync(fromPath) && !existsSync(toPath)) {
+			try {
+				const stats = await stat(fromPath);
+				if (stats.isDirectory()) {
+					await rename(fromPath, toPath);
+				}
+			} catch (error) {
+				// Ignore rename errors (might be permissions, etc.)
+				console.warn(`Failed to rename ${from} to ${to}:`, error);
+			}
+		}
+	}
+}
+
 async function discoverContent(repoPath: string): Promise<DiscoveredContent> {
 	const result: DiscoveredContent = {
 		skills: [],
@@ -694,6 +726,9 @@ async function fetchGitCapabilitySource(
 	}
 
 	if (needsWrap) {
+		// Normalize folder names (singular -> plural)
+		await normalizeFolderNames(repoPath);
+
 		// Discover content and generate capability.toml
 		const content = await discoverContent(repoPath);
 		await generateCapabilityToml(id, repoPath, config.source, commit, content);

package/src/config/capabilities.ts

@@ -1,4 +1,4 @@
-import { loadBaseConfig, loadConfig, writeConfig } from "./loader.js";
+import { loadBaseConfig, loadConfig, writeConfig } from "./config.js";
 import { getActiveProfile, resolveEnabledCapabilities } from "./profiles.js";
 
 /**

package/src/config/{loader.ts → config.ts}

@@ -173,6 +173,31 @@ function generateConfigToml(config: OmniConfig): string {
 	}
 	lines.push("");
 
+	// Capability groups
+	lines.push("# =============================================================================");
+	lines.push("# Capability Groups");
+	lines.push("# =============================================================================");
+	lines.push("# Bundle multiple capabilities under a single name for cleaner profiles.");
+	lines.push('# Reference groups in profiles with the "group:" prefix.');
+	lines.push("#");
+
+	const groups = config.capabilities?.groups;
+	if (groups && Object.keys(groups).length > 0) {
+		lines.push("[capabilities.groups]");
+		for (const [name, caps] of Object.entries(groups)) {
+			const capsStr = caps.map((c) => `"${c}"`).join(", ");
+			lines.push(`${name} = [${capsStr}]`);
+		}
+	} else {
+		lines.push("# [capabilities.groups]");
+		lines.push('# expo = ["expo-app-design", "expo-deployment", "upgrading-expo"]');
+		lines.push('# backend = ["cloudflare", "database-tools"]');
+		lines.push("#");
+		lines.push("# [profiles.mobile]");
+		lines.push('# capabilities = ["group:expo", "react-native-tools"]');
+	}
+	lines.push("");
+
 	// MCP servers
 	lines.push("# =============================================================================");
 	lines.push("# MCP Servers");

package/src/config/index.ts

@@ -1,6 +1,7 @@
 export * from "./capabilities";
 export * from "./env";
-export * from "./loader";
+export * from "./config";
 export * from "./parser";
 export * from "./profiles";
 export * from "./provider";
+export * from "./toml-patcher";

package/src/config/profiles.ts

@@ -1,6 +1,6 @@
 import { readActiveProfileState, writeActiveProfileState } from "../state/active-profile.js";
 import type { OmniConfig, ProfileConfig } from "../types/index.js";
-import { loadConfig, writeConfig } from "./loader.js";
+import { loadConfig, writeConfig } from "./config.js";
 
 /**
  * Gets the name of the currently active profile.
@@ -45,9 +45,29 @@ export function resolveEnabledCapabilities(
 
 	const profileCapabilities = profile?.capabilities ?? [];
 	const alwaysEnabled = config.always_enabled_capabilities ?? [];
+	const groups = config.capabilities?.groups ?? {};
 
-	// Merge always-enabled capabilities with profile capabilities (no duplicates)
-	return [...new Set([...alwaysEnabled, ...profileCapabilities])];
+	// Expand group references (group:name -> constituent capabilities)
+	const expandCapabilities = (caps: string[]): string[] => {
+		return caps.flatMap((cap) => {
+			if (cap.startsWith("group:")) {
+				const groupName = cap.slice(6);
+				const groupCaps = groups[groupName];
+				if (!groupCaps) {
+					console.warn(`Unknown capability group: ${groupName}`);
+					return [];
+				}
+				return groupCaps;
+			}
+			return cap;
+		});
+	};
+
+	const expandedAlways = expandCapabilities(alwaysEnabled);
+	const expandedProfile = expandCapabilities(profileCapabilities);
+
+	// Merge always-enabled capabilities with profile capabilities (deduplicated)
+	return [...new Set([...expandedAlways, ...expandedProfile])];
 }
 
 /**

package/src/config/toml-patcher.ts

@@ -0,0 +1,309 @@
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import type { CapabilitySourceConfig, McpConfig } from "../types/index.js";
+
+const CONFIG_PATH = "omni.toml";
+
+/**
+ * Read the raw TOML file content
+ */
+async function readConfigFile(): Promise<string> {
+	if (!existsSync(CONFIG_PATH)) {
+		return "";
+	}
+	return readFile(CONFIG_PATH, "utf-8");
+}
+
+/**
+ * Write content to the config file
+ */
+async function writeConfigFile(content: string): Promise<void> {
+	await writeFile(CONFIG_PATH, content, "utf-8");
+}
+
+/**
+ * Find the line index where a TOML section starts
+ * @returns The line index or -1 if not found
+ */
+function findSection(lines: string[], sectionPattern: RegExp): number {
+	return lines.findIndex((line) => sectionPattern.test(line.trim()));
+}
+
+/**
+ * Find the end of a TOML section (next section start or end of file)
+ */
+function findSectionEnd(lines: string[], startIndex: number): number {
+	// Look for the next section header after the start
+	for (let i = startIndex + 1; i < lines.length; i++) {
+		const line = lines[i];
+		if (line === undefined) continue;
+		const trimmed = line.trim();
+		// Check if this is a new section (but not a subsection of current)
+		if (/^\[(?!\[)/.test(trimmed) && !trimmed.startsWith("#")) {
+			return i;
+		}
+	}
+	return lines.length;
+}
+
+/**
+ * Format a capability source for TOML
+ */
+function formatCapabilitySource(name: string, source: CapabilitySourceConfig): string {
+	if (typeof source === "string") {
+		return `${name} = "${source}"`;
+	}
+	if (source.path) {
+		return `${name} = { source = "${source.source}", path = "${source.path}" }`;
+	}
+	return `${name} = "${source.source}"`;
+}
+
+/**
+ * Add a capability source to [capabilities.sources]
+ */
+export async function patchAddCapabilitySource(
+	name: string,
+	source: CapabilitySourceConfig,
+): Promise<void> {
+	let content = await readConfigFile();
+	const lines = content.split("\n");
+
+	// Find [capabilities.sources] section
+	const sectionIndex = findSection(lines, /^\[capabilities\.sources\]$/);
+
+	const newEntry = formatCapabilitySource(name, source);
+
+	if (sectionIndex !== -1) {
+		// Section exists, add entry after section header
+		const sectionEnd = findSectionEnd(lines, sectionIndex);
+		// Insert before the end of section (or before blank lines at end)
+		let insertIndex = sectionEnd;
+		// Find a good insertion point (after last non-blank, non-comment line in section)
+		for (let i = sectionEnd - 1; i > sectionIndex; i--) {
+			const line = lines[i];
+			if (line === undefined) continue;
+			const trimmed = line.trim();
+			if (trimmed && !trimmed.startsWith("#")) {
+				insertIndex = i + 1;
+				break;
+			}
+		}
+		// If we only found the header, insert right after it
+		if (insertIndex === sectionEnd && sectionIndex + 1 < lines.length) {
+			insertIndex = sectionIndex + 1;
+		}
+		lines.splice(insertIndex, 0, newEntry);
+	} else {
+		// Section doesn't exist, need to create it
+		// Try to find [capabilities] section first
+		const capabilitiesIndex = findSection(lines, /^\[capabilities\]$/);
+
+		if (capabilitiesIndex !== -1) {
+			// Insert after [capabilities] section
+			const capEnd = findSectionEnd(lines, capabilitiesIndex);
+			lines.splice(capEnd, 0, "", "[capabilities.sources]", newEntry);
+		} else {
+			// No capabilities section at all, add at end
+			// Find a good place - after mcps or at end
+			const mcpsIndex = findSection(lines, /^\[mcps/);
+			if (mcpsIndex !== -1) {
+				// Insert before mcps
+				lines.splice(mcpsIndex, 0, "[capabilities.sources]", newEntry, "");
+			} else {
+				// Just append at end
+				lines.push("", "[capabilities.sources]", newEntry);
+			}
+		}
+	}
+
+	content = lines.join("\n");
+	await writeConfigFile(content);
+}
+
+/**
+ * Format an MCP config as TOML lines
+ */
+function formatMcpConfig(name: string, config: McpConfig): string[] {
+	const lines: string[] = [];
+	lines.push(`[mcps.${name}]`);
+
+	// Transport (only if not stdio, since stdio is default)
+	if (config.transport && config.transport !== "stdio") {
+		lines.push(`transport = "${config.transport}"`);
+	}
+
+	// For stdio transport
+	if (config.command) {
+		lines.push(`command = "${config.command}"`);
+	}
+	if (config.args && config.args.length > 0) {
+		const argsStr = config.args.map((a) => `"${a}"`).join(", ");
+		lines.push(`args = [${argsStr}]`);
+	}
+	if (config.cwd) {
+		lines.push(`cwd = "${config.cwd}"`);
+	}
+
+	// For http/sse transport
+	if (config.url) {
+		lines.push(`url = "${config.url}"`);
+	}
+
+	// Environment variables
+	if (config.env && Object.keys(config.env).length > 0) {
+		lines.push(`[mcps.${name}.env]`);
+		for (const [key, value] of Object.entries(config.env)) {
+			lines.push(`${key} = "${value}"`);
+		}
+	}
+
+	// Headers
+	if (config.headers && Object.keys(config.headers).length > 0) {
+		lines.push(`[mcps.${name}.headers]`);
+		for (const [key, value] of Object.entries(config.headers)) {
+			lines.push(`${key} = "${value}"`);
+		}
+	}
+
+	return lines;
+}
+
+/**
+ * Add an MCP server configuration
+ */
+export async function patchAddMcp(name: string, config: McpConfig): Promise<void> {
+	let content = await readConfigFile();
+	const lines = content.split("\n");
+
+	const mcpLines = formatMcpConfig(name, config);
+
+	// Find any existing [mcps.*] section to add near it
+	const existingMcpIndex = findSection(lines, /^\[mcps\./);
+
+	if (existingMcpIndex !== -1) {
+		// Find the end of all mcp sections
+		let lastMcpEnd = existingMcpIndex;
+		for (let i = existingMcpIndex; i < lines.length; i++) {
+			const line = lines[i];
+			if (line === undefined) continue;
+			const trimmed = line.trim();
+			if (/^\[mcps\./.test(trimmed)) {
+				lastMcpEnd = findSectionEnd(lines, i);
+			} else if (/^\[(?!mcps\.)/.test(trimmed) && !trimmed.startsWith("#")) {
+				break;
+			}
+		}
+		// Insert after the last mcp section
+		lines.splice(lastMcpEnd, 0, "", ...mcpLines);
+	} else {
+		// No mcp sections exist, add after profiles or at end
+		const profilesIndex = findSection(lines, /^\[profiles\./);
+		if (profilesIndex !== -1) {
+			// Insert before profiles
+			lines.splice(profilesIndex, 0, ...mcpLines, "");
+		} else {
+			// Just append at end
+			lines.push("", ...mcpLines);
+		}
+	}
+
+	content = lines.join("\n");
+	await writeConfigFile(content);
+}
+
+/**
+ * Add a capability to a profile's capabilities array
+ */
+export async function patchAddToProfile(
+	profileName: string,
+	capabilityName: string,
+): Promise<void> {
+	let content = await readConfigFile();
+	const lines = content.split("\n");
+
+	// Find the profile section
+	const profilePattern = new RegExp(`^\\[profiles\\.${escapeRegExp(profileName)}\\]$`);
+	const profileIndex = findSection(lines, profilePattern);
+
+	if (profileIndex !== -1) {
+		// Profile exists, find and modify capabilities line
+		const profileEnd = findSectionEnd(lines, profileIndex);
+
+		let capabilitiesLineIndex = -1;
+		for (let i = profileIndex + 1; i < profileEnd; i++) {
+			const line = lines[i];
+			if (line === undefined) continue;
+			const trimmed = line.trim();
+			if (trimmed.startsWith("capabilities")) {
+				capabilitiesLineIndex = i;
+				break;
+			}
+		}
+
+		if (capabilitiesLineIndex !== -1) {
+			// Parse and modify the existing capabilities array
+			const line = lines[capabilitiesLineIndex];
+			if (line !== undefined) {
+				const match = line.match(/capabilities\s*=\s*\[(.*)\]/);
+				if (match && match[1] !== undefined) {
+					const existingCaps = match[1]
+						.split(",")
+						.map((s) => s.trim())
+						.filter((s) => s.length > 0);
+
+					// Check if capability already exists
+					const quotedCap = `"${capabilityName}"`;
+					if (!existingCaps.includes(quotedCap)) {
+						existingCaps.push(quotedCap);
+						const indent = line.match(/^(\s*)/)?.[1] ?? "";
+						lines[capabilitiesLineIndex] = `${indent}capabilities = [${existingCaps.join(", ")}]`;
+					}
+				}
+			}
+		} else {
+			// No capabilities line, add one after profile header
+			lines.splice(profileIndex + 1, 0, `capabilities = ["${capabilityName}"]`);
+		}
+	} else {
+		// Profile doesn't exist, create it
+		// Find where to insert (after other profiles or at end)
+		const anyProfileIndex = findSection(lines, /^\[profiles\./);
+
+		if (anyProfileIndex !== -1) {
+			// Find end of all profiles sections
+			let lastProfileEnd = anyProfileIndex;
+			for (let i = anyProfileIndex; i < lines.length; i++) {
+				const line = lines[i];
+				if (line === undefined) continue;
+				const trimmed = line.trim();
+				if (/^\[profiles\./.test(trimmed)) {
+					lastProfileEnd = findSectionEnd(lines, i);
+				} else if (/^\[(?!profiles\.)/.test(trimmed) && !trimmed.startsWith("#")) {
+					break;
+				}
+			}
+			// Insert after the last profile
+			lines.splice(
+				lastProfileEnd,
+				0,
+				"",
+				`[profiles.${profileName}]`,
+				`capabilities = ["${capabilityName}"]`,
+			);
+		} else {
+			// No profiles at all, add at end
+			lines.push("", `[profiles.${profileName}]`, `capabilities = ["${capabilityName}"]`);
+		}
+	}
+
+	content = lines.join("\n");
+	await writeConfigFile(content);
+}
+
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegExp(str: string): string {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/src/hooks/constants.ts

@@ -0,0 +1,100 @@
+/**
+ * Hook system constants
+ *
+ * All constants are defined as readonly arrays/objects to enable
+ * TypeScript literal type inference.
+ */
+
+/** All supported hook events */
+export const HOOK_EVENTS = [
+	"PreToolUse",
+	"PostToolUse",
+	"PermissionRequest",
+	"UserPromptSubmit",
+	"Stop",
+	"SubagentStop",
+	"Notification",
+	"SessionStart",
+	"SessionEnd",
+	"PreCompact",
+] as const;
+
+/** Events that support matchers (regex patterns to filter tool names) */
+export const MATCHER_EVENTS = [
+	"PreToolUse",
+	"PostToolUse",
+	"PermissionRequest",
+	"Notification",
+	"SessionStart",
+	"PreCompact",
+] as const;
+
+/** Events that support prompt-type hooks (LLM evaluation) */
+export const PROMPT_HOOK_EVENTS = [
+	"Stop",
+	"SubagentStop",
+	"UserPromptSubmit",
+	"PreToolUse",
+	"PermissionRequest",
+] as const;
+
+/** Hook execution types */
+export const HOOK_TYPES = ["command", "prompt"] as const;
+
+/**
+ * Common tool matchers (for validation hints, not exhaustive)
+ * These are the tools available in Claude Code that hooks commonly target.
+ */
+export const COMMON_TOOL_MATCHERS = [
+	"Bash",
+	"Read",
+	"Write",
+	"Edit",
+	"Glob",
+	"Grep",
+	"Task",
+	"WebFetch",
+	"WebSearch",
+	"NotebookEdit",
+	"LSP",
+	"TodoWrite",
+	"AskUserQuestion",
+] as const;
+
+/** Notification type matchers */
+export const NOTIFICATION_MATCHERS = [
+	"permission_prompt",
+	"idle_prompt",
+	"auth_success",
+	"elicitation_dialog",
+] as const;
+
+/** SessionStart source matchers */
+export const SESSION_START_MATCHERS = ["startup", "resume", "clear", "compact"] as const;
+
+/** PreCompact trigger matchers */
+export const PRE_COMPACT_MATCHERS = ["manual", "auto"] as const;
+
+/** Default timeout for command hooks (in seconds) */
+export const DEFAULT_COMMAND_TIMEOUT = 60;
+
+/** Default timeout for prompt hooks (in seconds) */
+export const DEFAULT_PROMPT_TIMEOUT = 30;
+
+/**
+ * Environment variable mappings between OmniDev and Claude Code
+ *
+ * When capabilities define hooks, they use OMNIDEV_ prefixed variables.
+ * When writing to .claude/settings.json, these are transformed to CLAUDE_ variables.
+ * When importing external capabilities, CLAUDE_ variables are transformed to OMNIDEV_.
+ */
+export const VARIABLE_MAPPINGS = {
+	OMNIDEV_CAPABILITY_ROOT: "CLAUDE_PLUGIN_ROOT",
+	OMNIDEV_PROJECT_DIR: "CLAUDE_PROJECT_DIR",
+} as const;
+
+/** The hooks configuration filename within a capability */
+export const HOOKS_CONFIG_FILENAME = "hooks.toml";
+
+/** The hooks directory name within a capability */
+export const HOOKS_DIRECTORY = "hooks";