aicm 0.18.0 → 0.19.1

package/dist/utils/config.d.ts

@@ -1,20 +1,17 @@
 import { CosmiconfigResult } from "cosmiconfig";
+import { HooksJson, HookFile } from "./hooks";
 export interface RawConfig {
-    rulesDir?: string;
-    commandsDir?: string;
+    rootDir?: string;
     targets?: string[];
     presets?: string[];
-    overrides?: Record<string, string | false>;
     mcpServers?: MCPServers;
     workspaces?: boolean;
     skipInstall?: boolean;
 }
 export interface Config {
-    rulesDir?: string;
-    commandsDir?: string;
+    rootDir?: string;
     targets: string[];
     presets?: string[];
-    overrides?: Record<string, string | false>;
     mcpServers?: MCPServers;
     workspaces?: boolean;
     skipInstall?: boolean;
@@ -58,30 +55,42 @@ export interface ResolvedConfig {
     commands: CommandFile[];
     assets: AssetFile[];
     mcpServers: MCPServers;
+    hooks: HooksJson;
+    hookFiles: HookFile[];
 }
-export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "commandsDir", "targets", "presets", "overrides", "mcpServers", "workspaces", "skipInstall"];
+export declare const ALLOWED_CONFIG_KEYS: readonly ["rootDir", "targets", "presets", "mcpServers", "workspaces", "skipInstall"];
 export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex", "claude"];
 export type SupportedTarget = (typeof SUPPORTED_TARGETS)[number];
 export declare function detectWorkspacesFromPackageJson(cwd: string): boolean;
 export declare function resolveWorkspaces(config: unknown, configFilePath: string, cwd: string): boolean;
 export declare function applyDefaults(config: RawConfig, workspaces: boolean): Config;
 export declare function validateConfig(config: unknown, configFilePath: string, cwd: string, isWorkspaceMode?: boolean): asserts config is Config;
-export declare function loadRulesFromDirectory(rulesDir: string, source: "local" | "preset", presetName?: string): Promise<RuleFile[]>;
-export declare function loadCommandsFromDirectory(commandsDir: string, source: "local" | "preset", presetName?: string): Promise<CommandFile[]>;
-export declare function loadAssetsFromDirectory(rulesDir: string, source: "local" | "preset", presetName?: string): Promise<AssetFile[]>;
+export declare function loadRulesFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<RuleFile[]>;
+export declare function loadCommandsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<CommandFile[]>;
+export declare function loadAssetsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<AssetFile[]>;
+/**
+ * Extract namespace from preset path for directory structure
+ * Handles both npm packages and local paths consistently
+ */
+export declare function extractNamespaceFromPresetPath(presetPath: string): string[];
 export declare function resolvePresetPath(presetPath: string, cwd: string): string | null;
 export declare function loadPreset(presetPath: string, cwd: string): Promise<{
     config: Config;
-    rulesDir?: string;
-    commandsDir?: string;
+    rootDir: string;
 }>;
 export declare function loadAllRules(config: Config, cwd: string): Promise<{
     rules: RuleFile[];
     commands: CommandFile[];
     assets: AssetFile[];
     mcpServers: MCPServers;
+    hooks: HooksJson;
+    hookFiles: HookFile[];
 }>;
-export declare function applyOverrides<T extends ManagedFile>(files: T[], overrides: Record<string, string | false>, cwd: string): T[];
 export declare function loadConfigFile(searchFrom?: string): Promise<CosmiconfigResult>;
+/**
+ * Check if workspaces mode is enabled without loading all rules/presets
+ * This is useful for commands that only need to know the workspace setting
+ */
+export declare function checkWorkspacesEnabled(cwd?: string): Promise<boolean>;
 export declare function loadConfig(cwd?: string): Promise<ResolvedConfig | null>;
 export declare function saveConfig(config: Config, cwd?: string): boolean;

package/dist/utils/config.js

@@ -11,23 +11,23 @@ exports.validateConfig = validateConfig;
 exports.loadRulesFromDirectory = loadRulesFromDirectory;
 exports.loadCommandsFromDirectory = loadCommandsFromDirectory;
 exports.loadAssetsFromDirectory = loadAssetsFromDirectory;
+exports.extractNamespaceFromPresetPath = extractNamespaceFromPresetPath;
 exports.resolvePresetPath = resolvePresetPath;
 exports.loadPreset = loadPreset;
 exports.loadAllRules = loadAllRules;
-exports.applyOverrides = applyOverrides;
 exports.loadConfigFile = loadConfigFile;
+exports.checkWorkspacesEnabled = checkWorkspacesEnabled;
 exports.loadConfig = loadConfig;
 exports.saveConfig = saveConfig;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const cosmiconfig_1 = require("cosmiconfig");
 const fast_glob_1 = __importDefault(require("fast-glob"));
+const hooks_1 = require("./hooks");
 exports.ALLOWED_CONFIG_KEYS = [
-    "rulesDir",
-    "commandsDir",
+    "rootDir",
     "targets",
     "presets",
-    "overrides",
     "mcpServers",
     "workspaces",
     "skipInstall",
@@ -63,11 +63,9 @@ function resolveWorkspaces(config, configFilePath, cwd) {
 }
 function applyDefaults(config, workspaces) {
     return {
-        rulesDir: config.rulesDir,
-        commandsDir: config.commandsDir,
+        rootDir: config.rootDir,
         targets: config.targets || ["cursor"],
         presets: config.presets || [],
-        overrides: config.overrides || {},
         mcpServers: config.mcpServers || {},
         workspaces,
         skipInstall: config.skipInstall || false,
@@ -81,36 +79,37 @@ function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
     if (unknownKeys.length > 0) {
         throw new Error(`Invalid configuration at ${configFilePath}: unknown keys: ${unknownKeys.join(", ")}`);
     }
-    // Validate that either rulesDir or presets is provided
-    const hasRulesDir = "rulesDir" in config && typeof config.rulesDir === "string";
-    const hasCommandsDir = "commandsDir" in config && typeof config.commandsDir === "string";
+    // Validate rootDir
+    const hasRootDir = "rootDir" in config && typeof config.rootDir === "string";
     const hasPresets = "presets" in config &&
         Array.isArray(config.presets) &&
         config.presets.length > 0;
-    // In workspace mode, root config doesn't need rulesDir or presets
-    // since packages will have their own configurations
-    if (!isWorkspaceMode && !hasRulesDir && !hasPresets && !hasCommandsDir) {
-        throw new Error(`At least one of rulesDir, commandsDir, or presets must be specified in config at ${configFilePath}`);
-    }
-    // Validate rulesDir if provided
-    if (hasRulesDir) {
-        const rulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
-        if (!fs_extra_1.default.existsSync(rulesPath)) {
-            throw new Error(`Rules directory does not exist: ${rulesPath}`);
+    if (hasRootDir) {
+        const rootPath = node_path_1.default.resolve(cwd, config.rootDir);
+        if (!fs_extra_1.default.existsSync(rootPath)) {
+            throw new Error(`Root directory does not exist: ${rootPath}`);
         }
-        if (!fs_extra_1.default.statSync(rulesPath).isDirectory()) {
-            throw new Error(`Rules path is not a directory: ${rulesPath}`);
+        if (!fs_extra_1.default.statSync(rootPath).isDirectory()) {
+            throw new Error(`Root path is not a directory: ${rootPath}`);
         }
-    }
-    if (hasCommandsDir) {
-        const commandsPath = node_path_1.default.resolve(cwd, config.commandsDir);
-        if (!fs_extra_1.default.existsSync(commandsPath)) {
-            throw new Error(`Commands directory does not exist: ${commandsPath}`);
-        }
-        if (!fs_extra_1.default.statSync(commandsPath).isDirectory()) {
-            throw new Error(`Commands path is not a directory: ${commandsPath}`);
+        // Check for at least one valid subdirectory or file
+        const hasRules = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "rules"));
+        const hasCommands = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "commands"));
+        const hasHooks = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "hooks.json"));
+        // In workspace mode, root config doesn't need these directories
+        // since packages will have their own configurations
+        if (!isWorkspaceMode &&
+            !hasRules &&
+            !hasCommands &&
+            !hasHooks &&
+            !hasPresets) {
+            throw new Error(`Root directory must contain at least one of: rules/, commands/, hooks.json, or have presets configured`);
         }
     }
+    else if (!isWorkspaceMode && !hasPresets) {
+        // If no rootDir specified and not in workspace mode, must have presets
+        throw new Error(`At least one of rootDir or presets must be specified in config at ${configFilePath}`);
+    }
     if ("targets" in config) {
         if (!Array.isArray(config.targets)) {
             throw new Error(`targets must be an array in config at ${configFilePath}`);
@@ -124,22 +123,21 @@ function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
             }
         }
     }
-    // Validate override rule names will be checked after rule resolution
 }
-async function loadRulesFromDirectory(rulesDir, source, presetName) {
+async function loadRulesFromDirectory(directoryPath, source, presetName) {
     const rules = [];
-    if (!fs_extra_1.default.existsSync(rulesDir)) {
+    if (!fs_extra_1.default.existsSync(directoryPath)) {
         return rules;
     }
-    const pattern = node_path_1.default.join(rulesDir, "**/*.mdc").replace(/\\/g, "/");
+    const pattern = node_path_1.default.join(directoryPath, "**/*.mdc").replace(/\\/g, "/");
     const filePaths = await (0, fast_glob_1.default)(pattern, {
         onlyFiles: true,
         absolute: true,
     });
     for (const filePath of filePaths) {
         const content = await fs_extra_1.default.readFile(filePath, "utf8");
-        // Preserve directory structure by using relative path from rulesDir
-        const relativePath = node_path_1.default.relative(rulesDir, filePath);
+        // Preserve directory structure by using relative path from source directory
+        const relativePath = node_path_1.default.relative(directoryPath, filePath);
         const ruleName = relativePath.replace(/\.mdc$/, "").replace(/\\/g, "/");
         rules.push({
             name: ruleName,
@@ -151,12 +149,12 @@ async function loadRulesFromDirectory(rulesDir, source, presetName) {
     }
     return rules;
 }
-async function loadCommandsFromDirectory(commandsDir, source, presetName) {
+async function loadCommandsFromDirectory(directoryPath, source, presetName) {
     const commands = [];
-    if (!fs_extra_1.default.existsSync(commandsDir)) {
+    if (!fs_extra_1.default.existsSync(directoryPath)) {
         return commands;
     }
-    const pattern = node_path_1.default.join(commandsDir, "**/*.md").replace(/\\/g, "/");
+    const pattern = node_path_1.default.join(directoryPath, "**/*.md").replace(/\\/g, "/");
     const filePaths = await (0, fast_glob_1.default)(pattern, {
         onlyFiles: true,
         absolute: true,
@@ -164,7 +162,7 @@ async function loadCommandsFromDirectory(commandsDir, source, presetName) {
     filePaths.sort();
     for (const filePath of filePaths) {
         const content = await fs_extra_1.default.readFile(filePath, "utf8");
-        const relativePath = node_path_1.default.relative(commandsDir, filePath);
+        const relativePath = node_path_1.default.relative(directoryPath, filePath);
         const commandName = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
         commands.push({
             name: commandName,
@@ -176,13 +174,13 @@ async function loadCommandsFromDirectory(commandsDir, source, presetName) {
     }
     return commands;
 }
-async function loadAssetsFromDirectory(rulesDir, source, presetName) {
+async function loadAssetsFromDirectory(directoryPath, source, presetName) {
     const assets = [];
-    if (!fs_extra_1.default.existsSync(rulesDir)) {
+    if (!fs_extra_1.default.existsSync(directoryPath)) {
         return assets;
     }
     // Find all files except .mdc files and hidden files
-    const pattern = node_path_1.default.join(rulesDir, "**/*").replace(/\\/g, "/");
+    const pattern = node_path_1.default.join(directoryPath, "**/*").replace(/\\/g, "/");
     const filePaths = await (0, fast_glob_1.default)(pattern, {
         onlyFiles: true,
         absolute: true,
@@ -190,8 +188,8 @@ async function loadAssetsFromDirectory(rulesDir, source, presetName) {
     });
     for (const filePath of filePaths) {
         const content = await fs_extra_1.default.readFile(filePath);
-        // Preserve directory structure by using relative path from rulesDir
-        const relativePath = node_path_1.default.relative(rulesDir, filePath);
+        // Preserve directory structure by using relative path from source directory
+        const relativePath = node_path_1.default.relative(directoryPath, filePath);
         // Keep extension for assets
         const assetName = relativePath.replace(/\\/g, "/");
         assets.push({
@@ -204,6 +202,19 @@ async function loadAssetsFromDirectory(rulesDir, source, presetName) {
     }
     return assets;
 }
+/**
+ * Extract namespace from preset path for directory structure
+ * Handles both npm packages and local paths consistently
+ */
+function extractNamespaceFromPresetPath(presetPath) {
+    // Special case: npm package names always use forward slashes, regardless of platform
+    if (presetPath.startsWith("@")) {
+        // For scoped packages like @scope/package/subdir, create nested directories
+        return presetPath.split("/");
+    }
+    const parts = presetPath.split(node_path_1.default.sep);
+    return parts.filter((part) => part.length > 0 && part !== "." && part !== "..");
+}
 function resolvePresetPath(presetPath, cwd) {
     // Support specifying aicm.json directory and load the config from it
     if (!presetPath.endsWith(".json")) {
@@ -241,99 +252,103 @@ async function loadPreset(presetPath, cwd) {
         throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
     }
     const presetDir = node_path_1.default.dirname(resolvedPresetPath);
-    const presetRulesDir = presetConfig.rulesDir
-        ? node_path_1.default.resolve(presetDir, presetConfig.rulesDir)
-        : undefined;
-    const presetCommandsDir = presetConfig.commandsDir
-        ? node_path_1.default.resolve(presetDir, presetConfig.commandsDir)
-        : undefined;
-    if (!presetRulesDir && !presetCommandsDir) {
-        throw new Error(`Preset "${presetPath}" must have a rulesDir or commandsDir specified`);
+    const presetRootDir = node_path_1.default.resolve(presetDir, presetConfig.rootDir || "./");
+    // Check for at least one valid subdirectory
+    const hasRules = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "rules"));
+    const hasCommands = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "commands"));
+    const hasHooks = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "hooks.json"));
+    const hasAssets = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "assets"));
+    if (!hasRules && !hasCommands && !hasHooks && !hasAssets) {
+        throw new Error(`Preset "${presetPath}" must have at least one of: rules/, commands/, hooks.json, or assets/`);
     }
     return {
         config: presetConfig,
-        rulesDir: presetRulesDir,
-        commandsDir: presetCommandsDir,
+        rootDir: presetRootDir,
     };
 }
 async function loadAllRules(config, cwd) {
     const allRules = [];
     const allCommands = [];
     const allAssets = [];
+    const allHookFiles = [];
+    const allHooksConfigs = [];
     let mergedMcpServers = { ...config.mcpServers };
-    // Load local rules only if rulesDir is provided
-    if (config.rulesDir) {
-        const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
-        const localRules = await loadRulesFromDirectory(localRulesPath, "local");
-        const localAssets = await loadAssetsFromDirectory(localRulesPath, "local");
-        allRules.push(...localRules);
-        allAssets.push(...localAssets);
-    }
-    if (config.commandsDir) {
-        const localCommandsPath = node_path_1.default.resolve(cwd, config.commandsDir);
-        const localCommands = await loadCommandsFromDirectory(localCommandsPath, "local");
-        allCommands.push(...localCommands);
+    // Load local files from rootDir only if specified
+    if (config.rootDir) {
+        const rootPath = node_path_1.default.resolve(cwd, config.rootDir);
+        // Load rules from rules/ subdirectory
+        const rulesPath = node_path_1.default.join(rootPath, "rules");
+        if (fs_extra_1.default.existsSync(rulesPath)) {
+            const localRules = await loadRulesFromDirectory(rulesPath, "local");
+            allRules.push(...localRules);
+        }
+        // Load commands from commands/ subdirectory
+        const commandsPath = node_path_1.default.join(rootPath, "commands");
+        if (fs_extra_1.default.existsSync(commandsPath)) {
+            const localCommands = await loadCommandsFromDirectory(commandsPath, "local");
+            allCommands.push(...localCommands);
+        }
+        // Load hooks from hooks.json (sibling to hooks/ directory)
+        const hooksFilePath = node_path_1.default.join(rootPath, "hooks.json");
+        if (fs_extra_1.default.existsSync(hooksFilePath)) {
+            const { config: localHooksConfig, files: localHookFiles } = await (0, hooks_1.loadHooksFromDirectory)(rootPath, "local");
+            allHooksConfigs.push(localHooksConfig);
+            allHookFiles.push(...localHookFiles);
+        }
+        // Load assets from assets/ subdirectory
+        const assetsPath = node_path_1.default.join(rootPath, "assets");
+        if (fs_extra_1.default.existsSync(assetsPath)) {
+            const localAssets = await loadAssetsFromDirectory(assetsPath, "local");
+            allAssets.push(...localAssets);
+        }
     }
+    // Load presets
     if (config.presets) {
         for (const presetPath of config.presets) {
             const preset = await loadPreset(presetPath, cwd);
-            if (preset.rulesDir) {
-                const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
-                const presetAssets = await loadAssetsFromDirectory(preset.rulesDir, "preset", presetPath);
+            const presetRootDir = preset.rootDir;
+            // Load preset rules from rules/ subdirectory
+            const presetRulesPath = node_path_1.default.join(presetRootDir, "rules");
+            if (fs_extra_1.default.existsSync(presetRulesPath)) {
+                const presetRules = await loadRulesFromDirectory(presetRulesPath, "preset", presetPath);
                 allRules.push(...presetRules);
-                allAssets.push(...presetAssets);
             }
-            if (preset.commandsDir) {
-                const presetCommands = await loadCommandsFromDirectory(preset.commandsDir, "preset", presetPath);
+            // Load preset commands from commands/ subdirectory
+            const presetCommandsPath = node_path_1.default.join(presetRootDir, "commands");
+            if (fs_extra_1.default.existsSync(presetCommandsPath)) {
+                const presetCommands = await loadCommandsFromDirectory(presetCommandsPath, "preset", presetPath);
                 allCommands.push(...presetCommands);
             }
+            // Load preset hooks from hooks.json (sibling to hooks/ directory)
+            const presetHooksFile = node_path_1.default.join(presetRootDir, "hooks.json");
+            if (fs_extra_1.default.existsSync(presetHooksFile)) {
+                const { config: presetHooksConfig, files: presetHookFiles } = await (0, hooks_1.loadHooksFromDirectory)(presetRootDir, "preset", presetPath);
+                allHooksConfigs.push(presetHooksConfig);
+                allHookFiles.push(...presetHookFiles);
+            }
+            // Load preset assets from assets/ subdirectory
+            const presetAssetsPath = node_path_1.default.join(presetRootDir, "assets");
+            if (fs_extra_1.default.existsSync(presetAssetsPath)) {
+                const presetAssets = await loadAssetsFromDirectory(presetAssetsPath, "preset", presetPath);
+                allAssets.push(...presetAssets);
+            }
             // Merge MCP servers from preset
             if (preset.config.mcpServers) {
                 mergedMcpServers = mergePresetMcpServers(mergedMcpServers, preset.config.mcpServers);
             }
         }
     }
+    // Merge all hooks configurations
+    const mergedHooks = (0, hooks_1.mergeHooksConfigs)(allHooksConfigs);
     return {
         rules: allRules,
         commands: allCommands,
         assets: allAssets,
         mcpServers: mergedMcpServers,
+        hooks: mergedHooks,
+        hookFiles: allHookFiles,
     };
 }
-function applyOverrides(files, overrides, cwd) {
-    // Validate that all override names exist in the resolved files
-    for (const name of Object.keys(overrides)) {
-        if (!files.some((file) => file.name === name)) {
-            throw new Error(`Override entry "${name}" does not exist in resolved files`);
-        }
-    }
-    const fileMap = new Map();
-    for (const file of files) {
-        fileMap.set(file.name, file);
-    }
-    for (const [name, override] of Object.entries(overrides)) {
-        if (override === false) {
-            fileMap.delete(name);
-        }
-        else if (typeof override === "string") {
-            const overridePath = node_path_1.default.resolve(cwd, override);
-            if (!fs_extra_1.default.existsSync(overridePath)) {
-                throw new Error(`Override file not found: ${override} in ${cwd}`);
-            }
-            const content = fs_extra_1.default.readFileSync(overridePath, "utf8");
-            const existing = fileMap.get(name);
-            fileMap.set(name, {
-                ...(existing !== null && existing !== void 0 ? existing : {}),
-                name,
-                content,
-                sourcePath: overridePath,
-                source: "local",
-                presetName: undefined,
-            });
-        }
-    }
-    return Array.from(fileMap.values());
-}
 /**
  * Merge preset MCP servers with local config MCP servers
  * Local config takes precedence over preset config
@@ -347,7 +362,7 @@ function mergePresetMcpServers(configMcpServers, presetMcpServers) {
             delete newMcpServers[serverName];
             continue;
         }
-        // Only add if not already defined in config (override handled by config)
+        // Only add if not already defined in config (local config takes precedence)
         if (!Object.prototype.hasOwnProperty.call(newMcpServers, serverName)) {
             newMcpServers[serverName] = serverConfig;
         }
@@ -366,6 +381,18 @@ async function loadConfigFile(searchFrom) {
         throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
+/**
+ * Check if workspaces mode is enabled without loading all rules/presets
+ * This is useful for commands that only need to know the workspace setting
+ */
+async function checkWorkspacesEnabled(cwd) {
+    const workingDir = cwd || process.cwd();
+    const configResult = await loadConfigFile(workingDir);
+    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
+        return detectWorkspacesFromPackageJson(workingDir);
+    }
+    return resolveWorkspaces(configResult.config, configResult.filepath, workingDir);
+}
 async function loadConfig(cwd) {
     const workingDir = cwd || process.cwd();
     const configResult = await loadConfigFile(workingDir);
@@ -376,34 +403,15 @@ async function loadConfig(cwd) {
     const isWorkspaces = resolveWorkspaces(config, configResult.filepath, workingDir);
     validateConfig(config, configResult.filepath, workingDir, isWorkspaces);
     const configWithDefaults = applyDefaults(config, isWorkspaces);
-    const { rules, commands, assets, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
-    let rulesWithOverrides = rules;
-    let commandsWithOverrides = commands;
-    // Note: Assets are not currently supported in overrides as they are binary/varied files
-    if (configWithDefaults.overrides) {
-        const overrides = configWithDefaults.overrides;
-        const ruleNames = new Set(rules.map((rule) => rule.name));
-        const commandNames = new Set(commands.map((command) => command.name));
-        for (const overrideName of Object.keys(overrides)) {
-            if (!ruleNames.has(overrideName) && !commandNames.has(overrideName)) {
-                throw new Error(`Override entry "${overrideName}" does not exist in resolved rules or commands`);
-            }
-        }
-        const ruleOverrides = Object.fromEntries(Object.entries(overrides).filter(([name]) => ruleNames.has(name)));
-        const commandOverrides = Object.fromEntries(Object.entries(overrides).filter(([name]) => commandNames.has(name)));
-        if (Object.keys(ruleOverrides).length > 0) {
-            rulesWithOverrides = applyOverrides(rules, ruleOverrides, workingDir);
-        }
-        if (Object.keys(commandOverrides).length > 0) {
-            commandsWithOverrides = applyOverrides(commands, commandOverrides, workingDir);
-        }
-    }
+    const { rules, commands, assets, mcpServers, hooks, hookFiles } = await loadAllRules(configWithDefaults, workingDir);
     return {
         config: configWithDefaults,
-        rules: rulesWithOverrides,
-        commands: commandsWithOverrides,
+        rules,
+        commands,
         assets,
         mcpServers,
+        hooks,
+        hookFiles,
     };
 }
 function saveConfig(config, cwd) {

package/dist/utils/hooks.d.ts

@@ -0,0 +1,50 @@
+export type HookType = "beforeShellExecution" | "beforeMCPExecution" | "afterShellExecution" | "afterMCPExecution" | "beforeReadFile" | "afterFileEdit" | "beforeSubmitPrompt" | "stop";
+export interface HookCommand {
+    command: string;
+}
+export interface HooksJson {
+    version: number;
+    hooks: {
+        [K in HookType]?: HookCommand[];
+    };
+}
+export interface HookFile {
+    name: string;
+    basename: string;
+    content: Buffer;
+    sourcePath: string;
+    source: "local" | "preset";
+    presetName?: string;
+}
+/**
+ * Load hooks configuration from a root directory
+ * The directory should contain hooks.json (sibling to hooks/ directory)
+ * All files in the hooks/ subdirectory are copied during installation
+ */
+export declare function loadHooksFromDirectory(rootDir: string, source: "local" | "preset", presetName?: string): Promise<{
+    config: HooksJson;
+    files: HookFile[];
+}>;
+/**
+ * Merge multiple hooks configurations into one
+ * Later configurations override earlier ones for the same hook type
+ */
+export declare function mergeHooksConfigs(configs: HooksJson[]): HooksJson;
+/**
+ * Rewrite command paths to point to the managed hooks directory (hooks/aicm/)
+ * At this point, paths are already namespaced filenames from loadHooksFromDirectory
+ */
+export declare function rewriteHooksConfigToManagedDir(hooksConfig: HooksJson): HooksJson;
+/**
+ * Count the number of hook entries in a hooks configuration
+ */
+export declare function countHooks(hooksConfig: HooksJson): number;
+/**
+ * Dedupe hook files by namespaced path, warn on content conflicts
+ * Presets are namespaced with directories, so same basename from different presets won't collide
+ */
+export declare function dedupeHookFiles(hookFiles: HookFile[]): HookFile[];
+/**
+ * Write hooks configuration and files to Cursor target
+ */
+export declare function writeHooksToCursor(hooksConfig: HooksJson, hookFiles: HookFile[], cwd: string): void;