aicm 0.18.0 → 0.19.0

package/dist/commands/install-workspaces.js

@@ -5,133 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installWorkspaces = installWorkspaces;
 const chalk_1 = __importDefault(require("chalk"));
-const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
+const hooks_1 = require("../utils/hooks");
 const working_directory_1 = require("../utils/working-directory");
-const rules_file_writer_1 = require("../utils/rules-file-writer");
 const workspace_discovery_1 = require("../utils/workspace-discovery");
 const install_1 = require("./install");
-/**
- * Extract .mdc file references from a command for warning purposes
- * Returns absolute paths to .mdc files that are referenced
- */
-function extractMdcReferences(content, commandSourcePath) {
-    const commandDir = node_path_1.default.dirname(commandSourcePath);
-    const mdcFiles = [];
-    const seenPaths = new Set();
-    // Same regex pattern as rewriteCommandRelativeLinks
-    const matches = content.matchAll(/\.\.[/\\][\w\-/\\.]+/g);
-    for (const match of matches) {
-        const relativePath = match[0];
-        const resolved = node_path_1.default.normalize(node_path_1.default.resolve(commandDir, relativePath));
-        // Only process .mdc files that exist
-        if (resolved.endsWith(".mdc") &&
-            !seenPaths.has(resolved) &&
-            fs_extra_1.default.existsSync(resolved) &&
-            fs_extra_1.default.statSync(resolved).isFile()) {
-            seenPaths.add(resolved);
-            mdcFiles.push(resolved);
-        }
-    }
-    return mdcFiles;
-}
-/**
- * Check if a .mdc file is a manual rule (not automatic/auto-attached/agent-requested)
- */
-function isManualRule(content) {
-    const metadata = (0, rules_file_writer_1.parseRuleFrontmatter)(content);
-    // Check for always rules
-    if (metadata.type === "always" ||
-        metadata.alwaysApply === true ||
-        metadata.alwaysApply === "true") {
-        return false;
-    }
-    // Check for auto-attached rules
-    if (metadata.type === "auto-attached" || metadata.globs) {
-        return false;
-    }
-    // Check for agent-requested rules
-    if (metadata.type === "agent-requested" || metadata.description) {
-        return false;
-    }
-    // Default to manual rule
-    return true;
-}
-/**
- * Process .mdc files referenced by commands in workspace mode
- * Warns about non-manual rules and copies them to root for command access
- */
-function processMdcFilesForWorkspace(mdcFilePaths, commands, packages, rootDir) {
-    const mdcAssets = [];
-    // Build a map of command source paths to their preset names
-    const commandPresetMap = new Map();
-    for (const command of commands) {
-        const commandDir = node_path_1.default.dirname(command.sourcePath);
-        commandPresetMap.set(commandDir, command.presetName);
-    }
-    for (const mdcPath of mdcFilePaths) {
-        const content = fs_extra_1.default.readFileSync(mdcPath, "utf8");
-        if (!isManualRule(content)) {
-            const relativePath = node_path_1.default.basename(mdcPath);
-            console.warn(chalk_1.default.yellow(`Warning: Command references non-manual rule file "${relativePath}". ` +
-                `This may cause the rule to be included twice in the context. ` +
-                `Consider using manual rules (without alwaysApply, globs, or description metadata) ` +
-                `when referencing from commands.`));
-        }
-        // Find which command references this .mdc file and get its preset name
-        let mdcAssetName = "";
-        let presetName;
-        let found = false;
-        // First check packages for local files
-        for (const pkg of packages) {
-            const rulesDir = pkg.config.config.rulesDir;
-            if (rulesDir) {
-                const pkgRulesPath = node_path_1.default.join(pkg.absolutePath, rulesDir);
-                if (mdcPath.startsWith(pkgRulesPath)) {
-                    mdcAssetName = node_path_1.default.relative(pkgRulesPath, mdcPath);
-                    found = true;
-                    break;
-                }
-            }
-        }
-        // If not found in local packages, it might be from a preset
-        if (!found) {
-            // Find the command that references this .mdc file
-            for (const command of commands) {
-                if (command.presetName) {
-                    const commandDir = node_path_1.default.dirname(command.sourcePath);
-                    const rulesDir = node_path_1.default.join(node_path_1.default.dirname(commandDir), "rules");
-                    if (mdcPath.startsWith(rulesDir)) {
-                        mdcAssetName = node_path_1.default.relative(rulesDir, mdcPath);
-                        presetName = command.presetName;
-                        found = true;
-                        break;
-                    }
-                }
-            }
-        }
-        if (found) {
-            // Build the final asset name with preset namespace if applicable
-            const finalAssetName = presetName
-                ? node_path_1.default.posix.join(...(0, install_1.extractNamespaceFromPresetPath)(presetName), mdcAssetName.replace(/\\/g, "/"))
-                : mdcAssetName.replace(/\\/g, "/");
-            // Create an AssetFile entry for the .mdc file
-            mdcAssets.push({
-                name: finalAssetName,
-                content: Buffer.from(content),
-                sourcePath: mdcPath,
-                source: presetName ? "preset" : "local",
-                presetName,
-            });
-            // Copy to root .cursor/rules/aicm/
-            const cursorRulesDir = node_path_1.default.join(rootDir, ".cursor", "rules", "aicm");
-            const targetPath = node_path_1.default.join(cursorRulesDir, finalAssetName);
-            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(targetPath));
-            fs_extra_1.default.writeFileSync(targetPath, content);
-        }
-    }
-    return mdcAssets;
-}
 function mergeWorkspaceCommands(packages) {
     var _a;
     const commands = [];
@@ -194,6 +72,26 @@ function mergeWorkspaceMcpServers(packages) {
     }
     return { merged, conflicts };
 }
+/**
+ * Merge hooks from multiple workspace packages
+ */
+function mergeWorkspaceHooks(packages) {
+    const allHooksConfigs = [];
+    const allHookFiles = [];
+    for (const pkg of packages) {
+        // Collect hooks configs
+        if (pkg.config.hooks) {
+            allHooksConfigs.push(pkg.config.hooks);
+        }
+        // Collect hook files
+        allHookFiles.push(...pkg.config.hookFiles);
+    }
+    // Merge hooks configs
+    const merged = (0, hooks_1.mergeHooksConfigs)(allHooksConfigs);
+    // Dedupe hook files by basename with MD5 checking
+    const dedupedHookFiles = (0, hooks_1.dedupeHookFiles)(allHookFiles);
+    return { merged, hookFiles: dedupedHookFiles };
+}
 /**
  * Install aicm configurations for all packages in a workspace
  */
@@ -202,6 +100,7 @@ async function installWorkspacesPackages(packages, options = {}) {
     let totalRuleCount = 0;
     let totalCommandCount = 0;
     let totalAssetCount = 0;
+    let totalHookCount = 0;
     // Install packages sequentially for now (can be parallelized later)
     for (const pkg of packages) {
         const packagePath = pkg.absolutePath;
@@ -214,6 +113,7 @@ async function installWorkspacesPackages(packages, options = {}) {
             totalRuleCount += result.installedRuleCount;
             totalCommandCount += result.installedCommandCount;
             totalAssetCount += result.installedAssetCount;
+            totalHookCount += result.installedHookCount;
             results.push({
                 path: pkg.relativePath,
                 success: result.success,
@@ -221,6 +121,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 installedRuleCount: result.installedRuleCount,
                 installedCommandCount: result.installedCommandCount,
                 installedAssetCount: result.installedAssetCount,
+                installedHookCount: result.installedHookCount,
             });
         }
         catch (error) {
@@ -231,6 +132,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
             });
         }
     }
@@ -241,6 +143,7 @@ async function installWorkspacesPackages(packages, options = {}) {
         totalRuleCount,
         totalCommandCount,
         totalAssetCount,
+        totalHookCount,
     };
 }
 /**
@@ -272,6 +175,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
                 packagesCount: 0,
             };
         }
@@ -296,20 +200,11 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             workspaceCommands.length > 0 &&
             workspaceCommandTargets.length > 0) {
             const dedupedWorkspaceCommands = (0, install_1.dedupeCommandsForInstall)(workspaceCommands);
-            // Collect all assets from packages for command path rewriting
+            // Collect all assets from packages
             const allAssets = packages.flatMap((pkg) => { var _a; return (_a = pkg.config.assets) !== null && _a !== void 0 ? _a : []; });
-            // Copy assets to root so root commands can reference them
+            // Copy assets to root
             (0, install_1.writeAssetsToTargets)(allAssets, workspaceCommandTargets);
-            // Extract and process .mdc file references from commands
-            const mdcFilesSet = new Set();
-            for (const command of dedupedWorkspaceCommands) {
-                const mdcRefs = extractMdcReferences(command.content, command.sourcePath);
-                mdcRefs.forEach((ref) => mdcFilesSet.add(ref));
-            }
-            const mdcAssets = processMdcFilesForWorkspace(mdcFilesSet, dedupedWorkspaceCommands, packages, cwd);
-            // Merge .mdc assets with regular assets for link rewriting
-            const allAssetsWithMdc = [...allAssets, ...mdcAssets];
-            (0, install_1.writeCommandsToTargets)(dedupedWorkspaceCommands, allAssetsWithMdc, workspaceCommandTargets);
+            (0, install_1.writeCommandsToTargets)(dedupedWorkspaceCommands, workspaceCommandTargets);
         }
         const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
         const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
@@ -320,6 +215,12 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
         for (const conflict of conflicts) {
             console.warn(`Warning: MCP configuration conflict detected\n  Key: "${conflict.key}"\n  Packages: ${conflict.packages.join(", ")}\n  Using configuration from: ${conflict.chosen}`);
         }
+        // Merge and write hooks for workspace
+        const { merged: rootHooks, hookFiles: rootHookFiles } = mergeWorkspaceHooks(packages);
+        const hasHooks = rootHooks.hooks && Object.keys(rootHooks.hooks).length > 0;
+        if (!dryRun && hasCursorTarget && (hasHooks || rootHookFiles.length > 0)) {
+            (0, hooks_1.writeHooksToCursor)(rootHooks, rootHookFiles, cwd);
+        }
         if (verbose) {
             result.packages.forEach((pkg) => {
                 if (pkg.success) {
@@ -327,6 +228,9 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                     if (pkg.installedCommandCount > 0) {
                         summaryParts.push(`${pkg.installedCommandCount} command${pkg.installedCommandCount === 1 ? "" : "s"}`);
                     }
+                    if (pkg.installedHookCount > 0) {
+                        summaryParts.push(`${pkg.installedHookCount} hook${pkg.installedHookCount === 1 ? "" : "s"}`);
+                    }
                     console.log(chalk_1.default.green(`✅ ${pkg.path} (${summaryParts.join(", ")})`));
                 }
                 else {
@@ -341,7 +245,10 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 const commandSummary = result.totalCommandCount > 0
                     ? `, ${result.totalCommandCount} command${result.totalCommandCount === 1 ? "" : "s"} total`
                     : "";
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary})`));
+                const hookSummary = result.totalHookCount > 0
+                    ? `, ${result.totalHookCount} hook${result.totalHookCount === 1 ? "" : "s"} total`
+                    : "";
+                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rule${result.totalRuleCount === 1 ? "" : "s"} total${commandSummary}${hookSummary})`));
                 console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
             }
             const errorDetails = failedPackages
@@ -353,6 +260,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 installedRuleCount: result.totalRuleCount,
                 installedCommandCount: result.totalCommandCount,
                 installedAssetCount: result.totalAssetCount,
+                installedHookCount: result.totalHookCount,
                 packagesCount: result.packages.length,
             };
         }
@@ -361,6 +269,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             installedRuleCount: result.totalRuleCount,
             installedCommandCount: result.totalCommandCount,
             installedAssetCount: result.totalAssetCount,
+            installedHookCount: result.totalHookCount,
             packagesCount: result.packages.length,
         };
     });

package/dist/commands/install.d.ts

@@ -45,14 +45,17 @@ export interface InstallResult {
      * Number of assets installed
      */
     installedAssetCount: number;
+    /**
+     * Number of hooks installed
+     */
+    installedHookCount: number;
     /**
      * Number of packages installed
      */
     packagesCount: number;
 }
-export declare function extractNamespaceFromPresetPath(presetPath: string): string[];
 export declare function writeAssetsToTargets(assets: AssetFile[], targets: SupportedTarget[]): void;
-export declare function writeCommandsToTargets(commands: CommandFile[], assets: AssetFile[], targets: SupportedTarget[]): void;
+export declare function writeCommandsToTargets(commands: CommandFile[], targets: SupportedTarget[]): void;
 export declare function warnPresetCommandCollisions(commands: CommandFile[]): void;
 export declare function dedupeCommandsForInstall(commands: CommandFile[]): CommandFile[];
 /**

package/dist/commands/install.js

@@ -3,7 +3,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractNamespaceFromPresetPath = extractNamespaceFromPresetPath;
 exports.writeAssetsToTargets = writeAssetsToTargets;
 exports.writeCommandsToTargets = writeCommandsToTargets;
 exports.warnPresetCommandCollisions = warnPresetCommandCollisions;
@@ -16,14 +15,25 @@ const chalk_1 = __importDefault(require("chalk"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const config_1 = require("../utils/config");
+const hooks_1 = require("../utils/hooks");
 const working_directory_1 = require("../utils/working-directory");
 const is_ci_1 = require("../utils/is-ci");
 const rules_file_writer_1 = require("../utils/rules-file-writer");
 const install_workspaces_1 = require("./install-workspaces");
+/**
+ * Rewrite asset references from source paths to installation paths
+ * Only rewrites the ../assets/ pattern - everything else is preserved
+ */
+function rewriteAssetReferences(content) {
+    // Replace ../assets/ with ../../assets/aicm/
+    // Handles both forward slashes and backslashes for cross-platform compatibility
+    return content.replace(/\.\.[\\/]assets[\\/]/g, "../../assets/aicm/");
+}
 function getTargetPaths() {
     const projectDir = process.cwd();
     return {
         cursor: node_path_1.default.join(projectDir, ".cursor", "rules", "aicm"),
+        assetsAicm: node_path_1.default.join(projectDir, ".cursor", "assets", "aicm"),
         aicm: node_path_1.default.join(projectDir, ".aicm"),
     };
 }
@@ -34,7 +44,7 @@ function writeCursorRules(rules, cursorRulesDir) {
         const ruleNameParts = rule.name.split(node_path_1.default.sep).filter(Boolean);
         if (rule.presetName) {
             // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            const namespace = (0, config_1.extractNamespaceFromPresetPath)(rule.presetName);
             // Path will be: cursorRulesDir/namespace/rule-name.mdc
             rulePath = node_path_1.default.join(cursorRulesDir, ...namespace, ...ruleNameParts);
         }
@@ -44,10 +54,12 @@ function writeCursorRules(rules, cursorRulesDir) {
         }
         const ruleFile = rulePath + ".mdc";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(ruleFile));
-        fs_extra_1.default.writeFileSync(ruleFile, rule.content);
+        // Rewrite asset references before writing
+        const content = rewriteAssetReferences(rule.content);
+        fs_extra_1.default.writeFileSync(ruleFile, content);
     }
 }
-function writeCursorCommands(commands, cursorCommandsDir, assets) {
+function writeCursorCommands(commands, cursorCommandsDir) {
     fs_extra_1.default.removeSync(cursorCommandsDir);
     for (const command of commands) {
         const commandNameParts = command.name
@@ -57,46 +69,11 @@ function writeCursorCommands(commands, cursorCommandsDir, assets) {
         const commandPath = node_path_1.default.join(cursorCommandsDir, ...commandNameParts);
         const commandFile = commandPath + ".md";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(commandFile));
-        // If the command file references assets in the rules directory, we need to rewrite the links.
-        // Commands are installed in .cursor/commands/aicm/
-        // Rules/assets are installed in .cursor/rules/aicm/
-        // So a link like "../rules/asset.json" in source (from commands/ to rules/)
-        // needs to become "../../rules/aicm/asset.json" in target (from .cursor/commands/aicm/ to .cursor/rules/aicm/)
-        const content = rewriteCommandRelativeLinks(command.content, command.sourcePath, assets);
+        // Rewrite asset references before writing
+        const content = rewriteAssetReferences(command.content);
         fs_extra_1.default.writeFileSync(commandFile, content);
     }
 }
-function rewriteCommandRelativeLinks(content, commandSourcePath, assets) {
-    const commandDir = node_path_1.default.dirname(commandSourcePath);
-    const assetMap = new Map(assets.map((a) => {
-        let targetPath;
-        if (a.presetName) {
-            const namespace = extractNamespaceFromPresetPath(a.presetName);
-            // Use posix paths for URLs/links (always forward slashes)
-            targetPath = node_path_1.default.posix.join(...namespace, a.name);
-        }
-        else {
-            // Normalize to posix for consistent forward slashes in links
-            targetPath = a.name.split(node_path_1.default.sep).join(node_path_1.default.posix.sep);
-        }
-        return [node_path_1.default.normalize(a.sourcePath), targetPath];
-    }));
-    return content.replace(/\.\.[/\\][\w\-/\\.]+/g, (match) => {
-        const resolved = node_path_1.default.normalize(node_path_1.default.resolve(commandDir, match));
-        return assetMap.has(resolved)
-            ? `../../rules/aicm/${assetMap.get(resolved)}`
-            : match;
-    });
-}
-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 !== "..");
-}
 /**
  * Write rules to a shared directory and update the given rules file
  */
@@ -107,7 +84,7 @@ function writeRulesForFile(rules, assets, ruleDir, rulesFile) {
         const ruleNameParts = rule.name.split(node_path_1.default.sep).filter(Boolean);
         if (rule.presetName) {
             // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            const namespace = (0, config_1.extractNamespaceFromPresetPath)(rule.presetName);
             // Path will be: ruleDir/namespace/rule-name.md
             rulePath = node_path_1.default.join(ruleDir, ...namespace, ...ruleNameParts);
         }
@@ -115,7 +92,8 @@ function writeRulesForFile(rules, assets, ruleDir, rulesFile) {
             // For local rules, maintain the original flat structure
             rulePath = node_path_1.default.join(ruleDir, ...ruleNameParts);
         }
-        const content = rule.content;
+        // Rewrite asset references before writing
+        const content = rewriteAssetReferences(rule.content);
         const physicalRulePath = rulePath + ".md";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(physicalRulePath));
         fs_extra_1.default.writeFileSync(physicalRulePath, content);
@@ -123,7 +101,7 @@ function writeRulesForFile(rules, assets, ruleDir, rulesFile) {
         // For the rules file, maintain the same structure
         let windsurfPath;
         if (rule.presetName) {
-            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            const namespace = (0, config_1.extractNamespaceFromPresetPath)(rule.presetName);
             windsurfPath =
                 node_path_1.default.join(relativeRuleDir, ...namespace, ...ruleNameParts) + ".md";
         }
@@ -147,7 +125,7 @@ function writeAssetsToTargets(assets, targets) {
         let targetDir;
         switch (target) {
             case "cursor":
-                targetDir = targetPaths.cursor;
+                targetDir = targetPaths.assetsAicm;
                 break;
             case "windsurf":
             case "codex":
@@ -160,7 +138,7 @@ function writeAssetsToTargets(assets, targets) {
         for (const asset of assets) {
             let assetPath;
             if (asset.presetName) {
-                const namespace = extractNamespaceFromPresetPath(asset.presetName);
+                const namespace = (0, config_1.extractNamespaceFromPresetPath)(asset.presetName);
                 assetPath = node_path_1.default.join(targetDir, ...namespace, asset.name);
             }
             else {
@@ -203,13 +181,13 @@ function writeRulesToTargets(rules, assets, targets) {
     // Write assets after rules so they don't get wiped by emptyDirSync
     writeAssetsToTargets(assets, targets);
 }
-function writeCommandsToTargets(commands, assets, targets) {
+function writeCommandsToTargets(commands, targets) {
     const projectDir = process.cwd();
     const cursorRoot = node_path_1.default.join(projectDir, ".cursor");
     for (const target of targets) {
         if (target === "cursor") {
             const commandsDir = node_path_1.default.join(cursorRoot, "commands", "aicm");
-            writeCursorCommands(commands, commandsDir, assets);
+            writeCursorCommands(commands, commandsDir);
         }
         // Other targets do not support commands yet
     }
@@ -259,6 +237,21 @@ function writeMcpServersToTargets(mcpServers, targets, cwd) {
         // Windsurf and Codex do not support project mcpServers, so skip
     }
 }
+/**
+ * Write hooks to IDE targets
+ */
+function writeHooksToTargets(hooksConfig, hookFiles, targets, cwd) {
+    const hasHooks = hooksConfig.hooks && Object.keys(hooksConfig.hooks).length > 0;
+    if (!hasHooks && hookFiles.length === 0) {
+        return;
+    }
+    for (const target of targets) {
+        if (target === "cursor") {
+            (0, hooks_1.writeHooksToCursor)(hooksConfig, hookFiles, cwd);
+        }
+        // Other targets do not support hooks yet
+    }
+}
 /**
  * Write MCP servers configuration to a specific file
  */
@@ -318,16 +311,18 @@ async function installPackage(options = {}) {
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
                 packagesCount: 0,
             };
         }
-        const { config, rules, commands, assets, mcpServers } = resolvedConfig;
+        const { config, rules, commands, assets, mcpServers, hooks, hookFiles } = resolvedConfig;
         if (config.skipInstall === true) {
             return {
                 success: true,
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
                 packagesCount: 0,
             };
         }
@@ -336,18 +331,23 @@ async function installPackage(options = {}) {
         try {
             if (!options.dryRun) {
                 writeRulesToTargets(rules, assets, config.targets);
-                writeCommandsToTargets(commandsToInstall, assets, config.targets);
+                writeCommandsToTargets(commandsToInstall, config.targets);
                 if (mcpServers && Object.keys(mcpServers).length > 0) {
                     writeMcpServersToTargets(mcpServers, config.targets, cwd);
                 }
+                if (hooks && ((0, hooks_1.countHooks)(hooks) > 0 || hookFiles.length > 0)) {
+                    writeHooksToTargets(hooks, hookFiles, config.targets, cwd);
+                }
             }
             const uniqueRuleCount = new Set(rules.map((rule) => rule.name)).size;
             const uniqueCommandCount = new Set(commandsToInstall.map((command) => command.name)).size;
+            const uniqueHookCount = (0, hooks_1.countHooks)(hooks);
             return {
                 success: true,
                 installedRuleCount: uniqueRuleCount,
                 installedCommandCount: uniqueCommandCount,
                 installedAssetCount: assets.length,
+                installedHookCount: uniqueHookCount,
                 packagesCount: 1,
             };
         }
@@ -358,6 +358,7 @@ async function installPackage(options = {}) {
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
                 packagesCount: 0,
             };
         }
@@ -377,6 +378,7 @@ async function install(options = {}) {
             installedRuleCount: 0,
             installedCommandCount: 0,
             installedAssetCount: 0,
+            installedHookCount: 0,
             packagesCount: 0,
         };
     }
@@ -408,10 +410,12 @@ async function installCommand(installOnCI, verbose, dryRun) {
     else {
         const ruleCount = result.installedRuleCount;
         const commandCount = result.installedCommandCount;
+        const hookCount = result.installedHookCount;
         const ruleMessage = ruleCount > 0 ? `${ruleCount} rule${ruleCount === 1 ? "" : "s"}` : null;
         const commandMessage = commandCount > 0
             ? `${commandCount} command${commandCount === 1 ? "" : "s"}`
             : null;
+        const hookMessage = hookCount > 0 ? `${hookCount} hook${hookCount === 1 ? "" : "s"}` : null;
         const countsParts = [];
         if (ruleMessage) {
             countsParts.push(ruleMessage);
@@ -419,7 +423,12 @@ async function installCommand(installOnCI, verbose, dryRun) {
         if (commandMessage) {
             countsParts.push(commandMessage);
         }
-        const countsMessage = countsParts.length > 0 ? countsParts.join(" and ") : "0 rules";
+        if (hookMessage) {
+            countsParts.push(hookMessage);
+        }
+        const countsMessage = countsParts.length > 0
+            ? countsParts.join(", ").replace(/, ([^,]*)$/, " and $1")
+            : "0 rules";
         if (dryRun) {
             if (result.packagesCount > 1) {
                 console.log(`Dry run: validated ${countsMessage} across ${result.packagesCount} packages`);
@@ -428,8 +437,8 @@ async function installCommand(installOnCI, verbose, dryRun) {
                 console.log(`Dry run: validated ${countsMessage}`);
             }
         }
-        else if (ruleCount === 0 && commandCount === 0) {
-            console.log("No rules or commands installed");
+        else if (ruleCount === 0 && commandCount === 0 && hookCount === 0) {
+            console.log("No rules, commands, or hooks installed");
         }
         else if (result.packagesCount > 1) {
             console.log(`Successfully installed ${countsMessage} across ${result.packagesCount} packages`);

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,37 @@ 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>;
 export declare function loadConfig(cwd?: string): Promise<ResolvedConfig | null>;
 export declare function saveConfig(config: Config, cwd?: string): boolean;