aicm 0.15.1 → 0.16.1

package/README.md

@@ -95,6 +95,53 @@ For project-specific rules, you can specify `rulesDir` in your `aicm.json` confi
 }
 ```
 
+### Using Commands
+
+Cursor supports custom commands that can be invoked directly in the chat interface. aicm can manage these command files
+alongside your rules and MCP configurations so they install automatically into Cursor.
+
+#### Local Commands
+
+Add a commands directory to your project configuration:
+
+```json
+{
+  "commandsDir": "./commands",
+  "targets": ["cursor"]
+}
+```
+
+Command files ending in `.md` are installed to `.cursor/commands/aicm/` and appear in Cursor under the `/` command menu.
+
+#### Commands in Presets
+
+Presets can ship reusable command libraries in addition to rules:
+
+```json
+{
+  "rulesDir": "rules",
+  "commandsDir": "commands"
+}
+```
+
+Preset command files install alongside local ones in `.cursor/commands/aicm/` so they appear with concise paths inside Cursor.
+If multiple presets provide a command at the same relative path, aicm will warn during installation and use the version from the
+last preset listed in your configuration. Use `overrides` to explicitly choose a different definition when needed.
+
+#### Command Overrides
+
+Use the existing `overrides` field to customize or disable commands provided by presets:
+
+```json
+{
+  "presets": ["@team/dev-preset"],
+  "overrides": {
+    "legacy-command": false,
+    "custom-test": "./commands/test.md"
+  }
+}
+```
+
 ### Notes
 
 - Generated rules are always placed in a subdirectory for deterministic cleanup and easy gitignore.
@@ -209,6 +256,7 @@ Create an `aicm.json` file in your project root, or an `aicm` key in your projec
 ```json
 {
   "rulesDir": "./rules",
+  "commandsDir": "./commands",
   "targets": ["cursor"],
   "presets": [],
   "overrides": {},
@@ -218,6 +266,7 @@ Create an `aicm.json` file in your project root, or an `aicm` key in your projec
 ```
 
 - **rulesDir**: Directory containing all rule files.
+- **commandsDir**: Directory containing Cursor command files.
 - **targets**: IDEs/Agent targets where rules should be installed. Defaults to `["cursor"]`.
 - **presets**: List of preset packages or paths to include.
 - **overrides**: Map of rule names to `false` (disable) or a replacement file path.

package/dist/api.d.ts

@@ -6,4 +6,4 @@ import { InstallOptions, InstallResult } from "./commands/install";
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;
 export type { InstallOptions, InstallResult } from "./commands/install";
-export type { ResolvedConfig, Config, RuleFile, MCPServers, } from "./utils/config";
+export type { ResolvedConfig, Config, RuleFile, CommandFile, MCPServers, } from "./utils/config";

package/dist/commands/install.d.ts

@@ -37,6 +37,10 @@ export interface InstallResult {
      * Number of rules installed
      */
     installedRuleCount: number;
+    /**
+     * Number of commands installed
+     */
+    installedCommandCount: number;
     /**
      * Number of packages installed
      */

package/dist/commands/install.js

@@ -43,6 +43,19 @@ function writeCursorRules(rules, cursorRulesDir) {
         fs_extra_1.default.writeFileSync(ruleFile, rule.content);
     }
 }
+function writeCursorCommands(commands, cursorCommandsDir) {
+    fs_extra_1.default.removeSync(cursorCommandsDir);
+    for (const command of commands) {
+        const commandNameParts = command.name
+            .replace(/\\/g, "/")
+            .split("/")
+            .filter(Boolean);
+        const commandPath = node_path_1.default.join(cursorCommandsDir, ...commandNameParts);
+        const commandFile = commandPath + ".md";
+        fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(commandFile));
+        fs_extra_1.default.writeFileSync(commandFile, command.content);
+    }
+}
 function extractNamespaceFromPresetPath(presetPath) {
     // Special case: npm package names always use forward slashes, regardless of platform
     if (presetPath.startsWith("@")) {
@@ -50,7 +63,7 @@ function extractNamespaceFromPresetPath(presetPath) {
         return presetPath.split("/");
     }
     const parts = presetPath.split(node_path_1.default.sep);
-    return parts.filter((part) => part.length > 0); // Filter out empty segments
+    return parts.filter((part) => part.length > 0 && part !== "." && part !== "..");
 }
 /**
  * Write rules to a shared directory and update the given rules file
@@ -125,6 +138,79 @@ function writeRulesToTargets(rules, 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);
+        }
+        // Other targets do not support commands yet
+    }
+}
+function warnPresetCommandCollisions(commands) {
+    const collisions = new Map();
+    for (const command of commands) {
+        if (!command.presetName)
+            continue;
+        const entry = collisions.get(command.name);
+        if (entry) {
+            entry.presets.add(command.presetName);
+            entry.lastPreset = command.presetName;
+        }
+        else {
+            collisions.set(command.name, {
+                presets: new Set([command.presetName]),
+                lastPreset: command.presetName,
+            });
+        }
+    }
+    for (const [commandName, { presets, lastPreset }] of collisions) {
+        if (presets.size > 1) {
+            const presetList = Array.from(presets).sort().join(", ");
+            console.warn(chalk_1.default.yellow(`Warning: multiple presets provide the "${commandName}" command (${presetList}). Using definition from ${lastPreset}.`));
+        }
+    }
+}
+function dedupeCommandsForInstall(commands) {
+    const unique = new Map();
+    for (const command of commands) {
+        unique.set(command.name, command);
+    }
+    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
  */
@@ -270,29 +356,35 @@ async function installPackage(options = {}) {
                 success: false,
                 error: new Error("Configuration file not found"),
                 installedRuleCount: 0,
+                installedCommandCount: 0,
                 packagesCount: 0,
             };
         }
-        const { config, rules, mcpServers } = resolvedConfig;
+        const { config, rules, commands, mcpServers } = resolvedConfig;
         if (config.skipInstall === true) {
             return {
                 success: true,
                 installedRuleCount: 0,
+                installedCommandCount: 0,
                 packagesCount: 0,
             };
         }
+        warnPresetCommandCollisions(commands);
+        const commandsToInstall = dedupeCommandsForInstall(commands);
         try {
             if (!options.dryRun) {
-                // Write rules to targets
                 writeRulesToTargets(rules, config.targets);
-                // Write MCP servers
+                writeCommandsToTargets(commandsToInstall, config.targets);
                 if (mcpServers && Object.keys(mcpServers).length > 0) {
                     writeMcpServersToTargets(mcpServers, config.targets, cwd);
                 }
             }
+            const uniqueRuleCount = new Set(rules.map((rule) => rule.name)).size;
+            const uniqueCommandCount = new Set(commandsToInstall.map((command) => command.name)).size;
             return {
                 success: true,
-                installedRuleCount: rules.length,
+                installedRuleCount: uniqueRuleCount,
+                installedCommandCount: uniqueCommandCount,
                 packagesCount: 1,
             };
         }
@@ -301,6 +393,7 @@ async function installPackage(options = {}) {
                 success: false,
                 error: error instanceof Error ? error : new Error(String(error)),
                 installedRuleCount: 0,
+                installedCommandCount: 0,
                 packagesCount: 0,
             };
         }
@@ -312,6 +405,7 @@ async function installPackage(options = {}) {
 async function installWorkspacesPackages(packages, options = {}) {
     const results = [];
     let totalRuleCount = 0;
+    let totalCommandCount = 0;
     // Install packages sequentially for now (can be parallelized later)
     for (const pkg of packages) {
         const packagePath = pkg.absolutePath;
@@ -322,11 +416,13 @@ async function installWorkspacesPackages(packages, options = {}) {
                 config: pkg.config,
             });
             totalRuleCount += result.installedRuleCount;
+            totalCommandCount += result.installedCommandCount;
             results.push({
                 path: pkg.relativePath,
                 success: result.success,
                 error: result.error,
                 installedRuleCount: result.installedRuleCount,
+                installedCommandCount: result.installedCommandCount,
             });
         }
         catch (error) {
@@ -335,6 +431,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 success: false,
                 error: error instanceof Error ? error : new Error(String(error)),
                 installedRuleCount: 0,
+                installedCommandCount: 0,
             });
         }
     }
@@ -343,6 +440,7 @@ async function installWorkspacesPackages(packages, options = {}) {
         success: failedPackages.length === 0,
         packages: results,
         totalRuleCount,
+        totalCommandCount,
     };
 }
 /**
@@ -361,16 +459,18 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             const isRoot = pkg.relativePath === ".";
             if (!isRoot)
                 return true;
-            // For root directories, only keep if it has rules or presets
+            // 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 || hasPresets;
+            return hasRules || hasCommands || hasPresets;
         });
         if (packages.length === 0) {
             return {
                 success: false,
                 error: new Error("No packages with aicm configurations found"),
                 installedRuleCount: 0,
+                installedCommandCount: 0,
                 packagesCount: 0,
             };
         }
@@ -386,6 +486,17 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             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);
+            writeCommandsToTargets(dedupedWorkspaceCommands, 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) {
@@ -398,7 +509,11 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
         if (verbose) {
             result.packages.forEach((pkg) => {
                 if (pkg.success) {
-                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${pkg.installedRuleCount} rules)`));
+                    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}`));
@@ -409,7 +524,10 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
         if (failedPackages.length > 0) {
             console.log(chalk_1.default.yellow(`Installation completed with errors`));
             if (verbose) {
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rules total)`));
+                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
@@ -419,12 +537,14 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 success: false,
                 error: new Error(`Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`),
                 installedRuleCount: result.totalRuleCount,
+                installedCommandCount: result.totalCommandCount,
                 packagesCount: result.packages.length,
             };
         }
         return {
             success: true,
             installedRuleCount: result.totalRuleCount,
+            installedCommandCount: result.totalCommandCount,
             packagesCount: result.packages.length,
         };
     });
@@ -441,6 +561,7 @@ async function install(options = {}) {
         return {
             success: true,
             installedRuleCount: 0,
+            installedCommandCount: 0,
             packagesCount: 0,
         };
     }
@@ -470,23 +591,36 @@ async function installCommand(installOnCI, verbose, dryRun) {
         throw (_a = result.error) !== null && _a !== void 0 ? _a : new Error("Installation failed with unknown error");
     }
     else {
-        const rulesInstalledMessage = `${result.installedRuleCount} rule${result.installedRuleCount === 1 ? "" : "s"}`;
+        const ruleCount = result.installedRuleCount;
+        const commandCount = result.installedCommandCount;
+        const ruleMessage = ruleCount > 0 ? `${ruleCount} rule${ruleCount === 1 ? "" : "s"}` : null;
+        const commandMessage = commandCount > 0
+            ? `${commandCount} command${commandCount === 1 ? "" : "s"}`
+            : null;
+        const countsParts = [];
+        if (ruleMessage) {
+            countsParts.push(ruleMessage);
+        }
+        if (commandMessage) {
+            countsParts.push(commandMessage);
+        }
+        const countsMessage = countsParts.length > 0 ? countsParts.join(" and ") : "0 rules";
         if (dryRun) {
             if (result.packagesCount > 1) {
-                console.log(`Dry run: validated ${rulesInstalledMessage} across ${result.packagesCount} packages`);
+                console.log(`Dry run: validated ${countsMessage} across ${result.packagesCount} packages`);
             }
             else {
-                console.log(`Dry run: validated ${rulesInstalledMessage}`);
+                console.log(`Dry run: validated ${countsMessage}`);
             }
         }
-        else if (result.installedRuleCount === 0) {
-            console.log("No rules installed");
+        else if (ruleCount === 0 && commandCount === 0) {
+            console.log("No rules or commands installed");
         }
         else if (result.packagesCount > 1) {
-            console.log(`Successfully installed ${rulesInstalledMessage} across ${result.packagesCount} packages`);
+            console.log(`Successfully installed ${countsMessage} across ${result.packagesCount} packages`);
         }
         else {
-            console.log(`Successfully installed ${rulesInstalledMessage}`);
+            console.log(`Successfully installed ${countsMessage}`);
         }
     }
 }

package/dist/commands/list.js

@@ -13,14 +13,28 @@ async function listCommand() {
         console.log(`Run ${chalk_1.default.blue("npx aicm init")} to create one.`);
         return;
     }
-    if (!config.rules || config.rules.length === 0) {
-        console.log(chalk_1.default.yellow("No rules defined in configuration."));
-        console.log(`Edit your ${chalk_1.default.blue("aicm.json")} file to add rules.`);
+    const hasRules = config.rules && config.rules.length > 0;
+    const hasCommands = config.commands && config.commands.length > 0;
+    if (!hasRules && !hasCommands) {
+        console.log(chalk_1.default.yellow("No rules or commands defined in configuration."));
+        console.log(`Edit your ${chalk_1.default.blue("aicm.json")} file to add rules or commands.`);
         return;
     }
-    console.log(chalk_1.default.blue("Configured Rules:"));
-    console.log(chalk_1.default.dim("─".repeat(50)));
-    for (const rule of config.rules) {
-        console.log(`${chalk_1.default.bold(rule.name)} - ${rule.sourcePath} ${rule.presetName ? `[${rule.presetName}]` : ""}`);
+    if (hasRules) {
+        console.log(chalk_1.default.blue("Configured Rules:"));
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        for (const rule of config.rules) {
+            console.log(`${chalk_1.default.bold(rule.name)} - ${rule.sourcePath} ${rule.presetName ? `[${rule.presetName}]` : ""}`);
+        }
+    }
+    if (hasCommands) {
+        if (hasRules) {
+            console.log();
+        }
+        console.log(chalk_1.default.blue("Configured Commands:"));
+        console.log(chalk_1.default.dim("─".repeat(50)));
+        for (const command of config.commands) {
+            console.log(`${chalk_1.default.bold(command.name)} - ${command.sourcePath} ${command.presetName ? `[${command.presetName}]` : ""}`);
+        }
     }
 }

package/dist/utils/config.d.ts

@@ -1,6 +1,7 @@
 import { CosmiconfigResult } from "cosmiconfig";
 export interface RawConfig {
     rulesDir?: string;
+    commandsDir?: string;
     targets?: string[];
     presets?: string[];
     overrides?: Record<string, string | false>;
@@ -10,6 +11,7 @@ export interface RawConfig {
 }
 export interface Config {
     rulesDir?: string;
+    commandsDir?: string;
     targets: string[];
     presets?: string[];
     overrides?: Record<string, string | false>;
@@ -31,22 +33,25 @@ export type MCPServer = {
 export interface MCPServers {
     [serverName: string]: MCPServer;
 }
-export interface RuleFile {
+export interface ManagedFile {
     name: string;
     content: string;
     sourcePath: string;
     source: "local" | "preset";
     presetName?: string;
 }
+export type RuleFile = ManagedFile;
+export type CommandFile = ManagedFile;
 export interface RuleCollection {
     [target: string]: RuleFile[];
 }
 export interface ResolvedConfig {
     config: Config;
     rules: RuleFile[];
+    commands: CommandFile[];
     mcpServers: MCPServers;
 }
-export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "targets", "presets", "overrides", "mcpServers", "workspaces", "skipInstall"];
+export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "commandsDir", "targets", "presets", "overrides", "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;
@@ -54,16 +59,19 @@ export declare function resolveWorkspaces(config: unknown, configFilePath: strin
 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 resolvePresetPath(presetPath: string, cwd: string): string | null;
 export declare function loadPreset(presetPath: string, cwd: string): Promise<{
     config: Config;
-    rulesDir: string;
+    rulesDir?: string;
+    commandsDir?: string;
 }>;
 export declare function loadAllRules(config: Config, cwd: string): Promise<{
     rules: RuleFile[];
+    commands: CommandFile[];
     mcpServers: MCPServers;
 }>;
-export declare function applyOverrides(rules: RuleFile[], overrides: Record<string, string | false>, cwd: string): RuleFile[];
+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;

package/dist/utils/config.js

@@ -9,6 +9,7 @@ exports.resolveWorkspaces = resolveWorkspaces;
 exports.applyDefaults = applyDefaults;
 exports.validateConfig = validateConfig;
 exports.loadRulesFromDirectory = loadRulesFromDirectory;
+exports.loadCommandsFromDirectory = loadCommandsFromDirectory;
 exports.resolvePresetPath = resolvePresetPath;
 exports.loadPreset = loadPreset;
 exports.loadAllRules = loadAllRules;
@@ -22,6 +23,7 @@ const cosmiconfig_1 = require("cosmiconfig");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 exports.ALLOWED_CONFIG_KEYS = [
     "rulesDir",
+    "commandsDir",
     "targets",
     "presets",
     "overrides",
@@ -61,6 +63,7 @@ function resolveWorkspaces(config, configFilePath, cwd) {
 function applyDefaults(config, workspaces) {
     return {
         rulesDir: config.rulesDir,
+        commandsDir: config.commandsDir,
         targets: config.targets || ["cursor"],
         presets: config.presets || [],
         overrides: config.overrides || {},
@@ -79,13 +82,14 @@ function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
     }
     // 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";
     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) {
-        throw new Error(`Either rulesDir or presets must be specified in config at ${configFilePath}`);
+    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) {
@@ -97,6 +101,15 @@ function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
             throw new Error(`Rules path is not a directory: ${rulesPath}`);
         }
     }
+    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}`);
+        }
+    }
     if ("targets" in config) {
         if (!Array.isArray(config.targets)) {
             throw new Error(`targets must be an array in config at ${configFilePath}`);
@@ -137,6 +150,31 @@ async function loadRulesFromDirectory(rulesDir, source, presetName) {
     }
     return rules;
 }
+async function loadCommandsFromDirectory(commandsDir, source, presetName) {
+    const commands = [];
+    if (!fs_extra_1.default.existsSync(commandsDir)) {
+        return commands;
+    }
+    const pattern = node_path_1.default.join(commandsDir, "**/*.md").replace(/\\/g, "/");
+    const filePaths = await (0, fast_glob_1.default)(pattern, {
+        onlyFiles: true,
+        absolute: true,
+    });
+    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 commandName = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
+        commands.push({
+            name: commandName,
+            content,
+            sourcePath: filePath,
+            source,
+            presetName,
+        });
+    }
+    return commands;
+}
 function resolvePresetPath(presetPath, cwd) {
     // Support specifying aicm.json directory and load the config from it
     if (!presetPath.endsWith(".json")) {
@@ -173,20 +211,25 @@ async function loadPreset(presetPath, cwd) {
     catch (error) {
         throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    // Validate that preset has rulesDir
-    if (!presetConfig.rulesDir) {
-        throw new Error(`Preset "${presetPath}" must have a rulesDir specified`);
-    }
-    // Resolve preset's rules directory relative to the preset file
     const presetDir = node_path_1.default.dirname(resolvedPresetPath);
-    const presetRulesDir = node_path_1.default.resolve(presetDir, presetConfig.rulesDir);
+    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`);
+    }
     return {
         config: presetConfig,
         rulesDir: presetRulesDir,
+        commandsDir: presetCommandsDir,
     };
 }
 async function loadAllRules(config, cwd) {
     const allRules = [];
+    const allCommands = [];
     let mergedMcpServers = { ...config.mcpServers };
     // Load local rules only if rulesDir is provided
     if (config.rulesDir) {
@@ -194,11 +237,22 @@ async function loadAllRules(config, cwd) {
         const localRules = await loadRulesFromDirectory(localRulesPath, "local");
         allRules.push(...localRules);
     }
+    if (config.commandsDir) {
+        const localCommandsPath = node_path_1.default.resolve(cwd, config.commandsDir);
+        const localCommands = await loadCommandsFromDirectory(localCommandsPath, "local");
+        allCommands.push(...localCommands);
+    }
     if (config.presets) {
         for (const presetPath of config.presets) {
             const preset = await loadPreset(presetPath, cwd);
-            const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
-            allRules.push(...presetRules);
+            if (preset.rulesDir) {
+                const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
+                allRules.push(...presetRules);
+            }
+            if (preset.commandsDir) {
+                const presetCommands = await loadCommandsFromDirectory(preset.commandsDir, "preset", presetPath);
+                allCommands.push(...presetCommands);
+            }
             // Merge MCP servers from preset
             if (preset.config.mcpServers) {
                 mergedMcpServers = mergePresetMcpServers(mergedMcpServers, preset.config.mcpServers);
@@ -207,41 +261,43 @@ async function loadAllRules(config, cwd) {
     }
     return {
         rules: allRules,
+        commands: allCommands,
         mcpServers: mergedMcpServers,
     };
 }
-function applyOverrides(rules, overrides, cwd) {
-    // Validate that all override rule names exist in the resolved rules
-    for (const ruleName of Object.keys(overrides)) {
-        // TODO: support better error messages with edit distance, helping the user in case of a typo
-        // TODO: or shows a list of potential rules to override
-        if (!rules.some((rule) => rule.name === ruleName)) {
-            throw new Error(`Override rule "${ruleName}" does not exist in resolved rules`);
+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 ruleMap = new Map();
-    for (const rule of rules) {
-        ruleMap.set(rule.name, rule);
+    const fileMap = new Map();
+    for (const file of files) {
+        fileMap.set(file.name, file);
     }
-    for (const [ruleName, override] of Object.entries(overrides)) {
+    for (const [name, override] of Object.entries(overrides)) {
         if (override === false) {
-            ruleMap.delete(ruleName);
+            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 rule file not found: ${override} in ${cwd}`);
+                throw new Error(`Override file not found: ${override} in ${cwd}`);
             }
             const content = fs_extra_1.default.readFileSync(overridePath, "utf8");
-            ruleMap.set(ruleName, {
-                name: ruleName,
+            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(ruleMap.values());
+    return Array.from(fileMap.values());
 }
 /**
  * Merge preset MCP servers with local config MCP servers
@@ -285,14 +341,31 @@ async function loadConfig(cwd) {
     const isWorkspaces = resolveWorkspaces(config, configResult.filepath, workingDir);
     validateConfig(config, configResult.filepath, workingDir, isWorkspaces);
     const configWithDefaults = applyDefaults(config, isWorkspaces);
-    const { rules, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
+    const { rules, commands, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
     let rulesWithOverrides = rules;
+    let commandsWithOverrides = commands;
     if (configWithDefaults.overrides) {
-        rulesWithOverrides = applyOverrides(rules, configWithDefaults.overrides, workingDir);
+        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);
+        }
     }
     return {
         config: configWithDefaults,
         rules: rulesWithOverrides,
+        commands: commandsWithOverrides,
         mcpServers,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.15.1",
+  "version": "0.16.1",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",