aicm 0.17.3 → 0.19.0

package/dist/commands/install.js

@@ -3,6 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAssetsToTargets = writeAssetsToTargets;
+exports.writeCommandsToTargets = writeCommandsToTargets;
+exports.warnPresetCommandCollisions = warnPresetCommandCollisions;
+exports.dedupeCommandsForInstall = dedupeCommandsForInstall;
+exports.writeMcpServersToFile = writeMcpServersToFile;
 exports.installPackage = installPackage;
 exports.install = install;
 exports.installCommand = installCommand;
@@ -10,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 workspace_discovery_1 = require("../utils/workspace-discovery");
+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"),
     };
 }
@@ -28,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);
         }
@@ -38,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
@@ -51,34 +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) => [node_path_1.default.normalize(a.sourcePath), a.name]));
-    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
  */
@@ -89,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);
         }
@@ -97,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);
@@ -105,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";
         }
@@ -129,7 +125,7 @@ function writeAssetsToTargets(assets, targets) {
         let targetDir;
         switch (target) {
             case "cursor":
-                targetDir = targetPaths.cursor;
+                targetDir = targetPaths.assetsAicm;
                 break;
             case "windsurf":
             case "codex":
@@ -142,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 {
@@ -185,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
     }
@@ -227,37 +223,6 @@ function dedupeCommandsForInstall(commands) {
     }
     return Array.from(unique.values());
 }
-function mergeWorkspaceCommands(packages) {
-    var _a;
-    const commands = [];
-    const seenPresetCommands = new Set();
-    for (const pkg of packages) {
-        const hasCursorTarget = pkg.config.config.targets.includes("cursor");
-        if (!hasCursorTarget) {
-            continue;
-        }
-        for (const command of (_a = pkg.config.commands) !== null && _a !== void 0 ? _a : []) {
-            if (command.presetName) {
-                const presetKey = `${command.presetName}::${command.name}`;
-                if (seenPresetCommands.has(presetKey)) {
-                    continue;
-                }
-                seenPresetCommands.add(presetKey);
-            }
-            commands.push(command);
-        }
-    }
-    return commands;
-}
-function collectWorkspaceCommandTargets(packages) {
-    const targets = new Set();
-    for (const pkg of packages) {
-        if (pkg.config.config.targets.includes("cursor")) {
-            targets.add("cursor");
-        }
-    }
-    return Array.from(targets);
-}
 /**
  * Write MCP servers configuration to IDE targets
  */
@@ -272,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
  */
@@ -311,37 +291,6 @@ function writeMcpServersToFile(mcpServers, mcpPath) {
     };
     fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
 }
-function mergeWorkspaceMcpServers(packages) {
-    const merged = {};
-    const info = {};
-    for (const pkg of packages) {
-        for (const [key, value] of Object.entries(pkg.config.mcpServers)) {
-            if (value === false)
-                continue;
-            const json = JSON.stringify(value);
-            if (!info[key]) {
-                info[key] = {
-                    configs: new Set([json]),
-                    packages: [pkg.relativePath],
-                    chosen: pkg.relativePath,
-                };
-            }
-            else {
-                info[key].packages.push(pkg.relativePath);
-                info[key].configs.add(json);
-                info[key].chosen = pkg.relativePath;
-            }
-            merged[key] = value;
-        }
-    }
-    const conflicts = [];
-    for (const [key, data] of Object.entries(info)) {
-        if (data.configs.size > 1) {
-            conflicts.push({ key, packages: data.packages, chosen: data.chosen });
-        }
-    }
-    return { merged, conflicts };
-}
 /**
  * Install rules for a single package (used within workspaces and standalone installs)
  */
@@ -362,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,
             };
         }
@@ -380,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,
             };
         }
@@ -402,171 +358,12 @@ async function installPackage(options = {}) {
                 installedRuleCount: 0,
                 installedCommandCount: 0,
                 installedAssetCount: 0,
+                installedHookCount: 0,
                 packagesCount: 0,
             };
         }
     });
 }
-/**
- * Install aicm configurations for all packages in a workspace
- */
-async function installWorkspacesPackages(packages, options = {}) {
-    const results = [];
-    let totalRuleCount = 0;
-    let totalCommandCount = 0;
-    let totalAssetCount = 0;
-    // Install packages sequentially for now (can be parallelized later)
-    for (const pkg of packages) {
-        const packagePath = pkg.absolutePath;
-        try {
-            const result = await installPackage({
-                ...options,
-                cwd: packagePath,
-                config: pkg.config,
-            });
-            totalRuleCount += result.installedRuleCount;
-            totalCommandCount += result.installedCommandCount;
-            totalAssetCount += result.installedAssetCount;
-            results.push({
-                path: pkg.relativePath,
-                success: result.success,
-                error: result.error,
-                installedRuleCount: result.installedRuleCount,
-                installedCommandCount: result.installedCommandCount,
-                installedAssetCount: result.installedAssetCount,
-            });
-        }
-        catch (error) {
-            results.push({
-                path: pkg.relativePath,
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                installedRuleCount: 0,
-                installedCommandCount: 0,
-                installedAssetCount: 0,
-            });
-        }
-    }
-    const failedPackages = results.filter((r) => !r.success);
-    return {
-        success: failedPackages.length === 0,
-        packages: results,
-        totalRuleCount,
-        totalCommandCount,
-        totalAssetCount,
-    };
-}
-/**
- * Install rules across multiple packages in a workspace
- */
-async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = false) {
-    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
-        if (verbose) {
-            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
-        }
-        const allPackages = await (0, workspace_discovery_1.discoverPackagesWithAicm)(cwd);
-        const packages = allPackages.filter((pkg) => {
-            if (pkg.config.config.skipInstall === true) {
-                return false;
-            }
-            const isRoot = pkg.relativePath === ".";
-            if (!isRoot)
-                return true;
-            // For root directories, only keep if it has rules, commands, or presets
-            const hasRules = pkg.config.rules && pkg.config.rules.length > 0;
-            const hasCommands = pkg.config.commands && pkg.config.commands.length > 0;
-            const hasPresets = pkg.config.config.presets && pkg.config.config.presets.length > 0;
-            return hasRules || hasCommands || hasPresets;
-        });
-        if (packages.length === 0) {
-            return {
-                success: false,
-                error: new Error("No packages with aicm configurations found"),
-                installedRuleCount: 0,
-                installedCommandCount: 0,
-                installedAssetCount: 0,
-                packagesCount: 0,
-            };
-        }
-        if (verbose) {
-            console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations:`));
-            packages.forEach((pkg) => {
-                console.log(chalk_1.default.gray(`  - ${pkg.relativePath}`));
-            });
-            console.log(chalk_1.default.blue(`📦 Installing configurations...`));
-        }
-        const result = await installWorkspacesPackages(packages, {
-            installOnCI,
-            verbose,
-            dryRun,
-        });
-        const workspaceCommands = mergeWorkspaceCommands(packages);
-        const workspaceCommandTargets = collectWorkspaceCommandTargets(packages);
-        if (workspaceCommands.length > 0) {
-            warnPresetCommandCollisions(workspaceCommands);
-        }
-        if (!dryRun &&
-            workspaceCommands.length > 0 &&
-            workspaceCommandTargets.length > 0) {
-            const dedupedWorkspaceCommands = dedupeCommandsForInstall(workspaceCommands);
-            // Collect all assets from packages for command path rewriting
-            const allAssets = packages.flatMap((pkg) => { var _a; return (_a = pkg.config.assets) !== null && _a !== void 0 ? _a : []; });
-            writeCommandsToTargets(dedupedWorkspaceCommands, allAssets, workspaceCommandTargets);
-        }
-        const { merged: rootMcp, conflicts } = mergeWorkspaceMcpServers(packages);
-        const hasCursorTarget = packages.some((p) => p.config.config.targets.includes("cursor"));
-        if (!dryRun && hasCursorTarget && Object.keys(rootMcp).length > 0) {
-            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
-            writeMcpServersToFile(rootMcp, mcpPath);
-        }
-        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}`);
-        }
-        if (verbose) {
-            result.packages.forEach((pkg) => {
-                if (pkg.success) {
-                    const summaryParts = [`${pkg.installedRuleCount} rules`];
-                    if (pkg.installedCommandCount > 0) {
-                        summaryParts.push(`${pkg.installedCommandCount} command${pkg.installedCommandCount === 1 ? "" : "s"}`);
-                    }
-                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${summaryParts.join(", ")})`));
-                }
-                else {
-                    console.log(chalk_1.default.red(`❌ ${pkg.path}: ${pkg.error}`));
-                }
-            });
-        }
-        const failedPackages = result.packages.filter((r) => !r.success);
-        if (failedPackages.length > 0) {
-            console.log(chalk_1.default.yellow(`Installation completed with errors`));
-            if (verbose) {
-                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})`));
-                console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
-            }
-            const errorDetails = failedPackages
-                .map((p) => `${p.path}: ${p.error}`)
-                .join("; ");
-            return {
-                success: false,
-                error: new Error(`Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`),
-                installedRuleCount: result.totalRuleCount,
-                installedCommandCount: result.totalCommandCount,
-                installedAssetCount: result.totalAssetCount,
-                packagesCount: result.packages.length,
-            };
-        }
-        return {
-            success: true,
-            installedRuleCount: result.totalRuleCount,
-            installedCommandCount: result.totalCommandCount,
-            installedAssetCount: result.totalAssetCount,
-            packagesCount: result.packages.length,
-        };
-    });
-}
 /**
  * Core implementation of the rule installation logic
  */
@@ -581,6 +378,7 @@ async function install(options = {}) {
             installedRuleCount: 0,
             installedCommandCount: 0,
             installedAssetCount: 0,
+            installedHookCount: 0,
             packagesCount: 0,
         };
     }
@@ -595,7 +393,7 @@ async function install(options = {}) {
         const shouldUseWorkspaces = (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.config.workspaces) ||
             (!resolvedConfig && (0, config_1.detectWorkspacesFromPackageJson)(cwd));
         if (shouldUseWorkspaces) {
-            return await installWorkspaces(cwd, installOnCI, options.verbose, options.dryRun);
+            return await (0, install_workspaces_1.installWorkspaces)(cwd, installOnCI, options.verbose, options.dryRun);
         }
         return installPackage(options);
     });
@@ -612,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);
@@ -623,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`);
@@ -632,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;