aicm 0.16.0 → 0.17.0

package/README.md

@@ -95,6 +95,32 @@ For project-specific rules, you can specify `rulesDir` in your `aicm.json` confi
 }
 ```
 
+**Referencing Auxiliary Files**
+
+You can place any file (e.g., `example.ts`, `schema.json`, `guide.md`) in your `rulesDir` alongside your `.mdc` files. These assets are automatically copied to the target location. You can reference them in your rules using relative paths, and aicm will automatically rewrite the links to point to the correct location for each target IDE.
+
+Example `rules/my-rule.mdc`:
+
+```markdown
+# My Rule
+
+See [Example](./example.ts) for details.
+```
+
+**Commands referencing files**
+
+You can also use this feature to create commands that reference auxiliary files in your `rulesDir`. Since assets in `rulesDir` are copied to the target directory, your commands can link to them.
+
+For example, if you have a schema file at `rules/schema.json` and a command at `commands/generate-schema.md`:
+
+```markdown
+# Generate Schema
+
+Use the schema defined in [Schema Template](../rules/schema.json) to generate the response.
+```
+
+When installed, `aicm` will automatically rewrite the link to point to the correct location of `schema.json` in the target environment (e.g., `../../rules/aicm/schema.json` for Cursor).
+
 ### Using Commands
 
 Cursor supports custom commands that can be invoked directly in the chat interface. aicm can manage these command files

package/dist/commands/install.d.ts

@@ -41,6 +41,10 @@ export interface InstallResult {
      * Number of commands installed
      */
     installedCommandCount: number;
+    /**
+     * Number of assets installed
+     */
+    installedAssetCount: number;
     /**
      * Number of packages installed
      */

package/dist/commands/install.js

@@ -18,9 +18,7 @@ function getTargetPaths() {
     const projectDir = process.cwd();
     return {
         cursor: node_path_1.default.join(projectDir, ".cursor", "rules", "aicm"),
-        windsurf: node_path_1.default.join(projectDir, ".aicm"),
-        codex: node_path_1.default.join(projectDir, ".aicm"),
-        claude: node_path_1.default.join(projectDir, ".aicm"),
+        aicm: node_path_1.default.join(projectDir, ".aicm"),
     };
 }
 function writeCursorRules(rules, cursorRulesDir) {
@@ -53,9 +51,29 @@ function writeCursorCommands(commands, cursorCommandsDir) {
         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);
+        // 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);
+        fs_extra_1.default.writeFileSync(commandFile, content);
     }
 }
+function rewriteCommandRelativeLinks(content) {
+    return content.replace(/\[([^\]]*)\]\(([^)]+)\)/g, (match, text, url) => {
+        if (url.startsWith("http") || url.startsWith("#") || url.startsWith("/")) {
+            return match;
+        }
+        // Check if it's a link to the rules directory
+        if (url.includes("rules/")) {
+            const parts = url.split("/");
+            const filename = parts[parts.length - 1];
+            return `[${text}](../../rules/aicm/${filename})`;
+        }
+        return match;
+    });
+}
 function extractNamespaceFromPresetPath(presetPath) {
     // Special case: npm package names always use forward slashes, regardless of platform
     if (presetPath.startsWith("@")) {
@@ -68,7 +86,7 @@ function extractNamespaceFromPresetPath(presetPath) {
 /**
  * Write rules to a shared directory and update the given rules file
  */
-function writeRulesForFile(rules, ruleDir, rulesFile) {
+function writeRulesForFile(rules, assets, ruleDir, rulesFile) {
     fs_extra_1.default.emptyDirSync(ruleDir);
     const ruleFiles = rules.map((rule) => {
         let rulePath;
@@ -83,9 +101,10 @@ function writeRulesForFile(rules, ruleDir, rulesFile) {
             // For local rules, maintain the original flat structure
             rulePath = node_path_1.default.join(ruleDir, ...ruleNameParts);
         }
+        const content = rule.content;
         const physicalRulePath = rulePath + ".md";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(physicalRulePath));
-        fs_extra_1.default.writeFileSync(physicalRulePath, rule.content);
+        fs_extra_1.default.writeFileSync(physicalRulePath, content);
         const relativeRuleDir = node_path_1.default.basename(ruleDir);
         // For the rules file, maintain the same structure
         let windsurfPath;
@@ -102,16 +121,46 @@ function writeRulesForFile(rules, ruleDir, rulesFile) {
         return {
             name: rule.name,
             path: windsurfPathPosix,
-            metadata: (0, rules_file_writer_1.parseRuleFrontmatter)(rule.content),
+            metadata: (0, rules_file_writer_1.parseRuleFrontmatter)(content),
         };
     });
     const rulesContent = (0, rules_file_writer_1.generateRulesFileContent)(ruleFiles);
     (0, rules_file_writer_1.writeRulesFile)(rulesContent, node_path_1.default.join(process.cwd(), rulesFile));
 }
+function writeAssetsToTargets(assets, targets) {
+    const targetPaths = getTargetPaths();
+    for (const target of targets) {
+        let targetDir;
+        switch (target) {
+            case "cursor":
+                targetDir = targetPaths.cursor;
+                break;
+            case "windsurf":
+            case "codex":
+            case "claude":
+                targetDir = targetPaths.aicm;
+                break;
+            default:
+                continue;
+        }
+        for (const asset of assets) {
+            let assetPath;
+            if (asset.presetName) {
+                const namespace = extractNamespaceFromPresetPath(asset.presetName);
+                assetPath = node_path_1.default.join(targetDir, ...namespace, asset.name);
+            }
+            else {
+                assetPath = node_path_1.default.join(targetDir, asset.name);
+            }
+            fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(assetPath));
+            fs_extra_1.default.writeFileSync(assetPath, asset.content);
+        }
+    }
+}
 /**
  * Write all collected rules to their respective IDE targets
  */
-function writeRulesToTargets(rules, targets) {
+function writeRulesToTargets(rules, assets, targets) {
     const targetPaths = getTargetPaths();
     for (const target of targets) {
         switch (target) {
@@ -122,21 +171,23 @@ function writeRulesToTargets(rules, targets) {
                 break;
             case "windsurf":
                 if (rules.length > 0) {
-                    writeRulesForFile(rules, targetPaths.windsurf, ".windsurfrules");
+                    writeRulesForFile(rules, assets, targetPaths.aicm, ".windsurfrules");
                 }
                 break;
             case "codex":
                 if (rules.length > 0) {
-                    writeRulesForFile(rules, targetPaths.codex, "AGENTS.md");
+                    writeRulesForFile(rules, assets, targetPaths.aicm, "AGENTS.md");
                 }
                 break;
             case "claude":
                 if (rules.length > 0) {
-                    writeRulesForFile(rules, targetPaths.claude, "CLAUDE.md");
+                    writeRulesForFile(rules, assets, targetPaths.aicm, "CLAUDE.md");
                 }
                 break;
         }
     }
+    // Write assets after rules so they don't get wiped by emptyDirSync
+    writeAssetsToTargets(assets, targets);
 }
 function writeCommandsToTargets(commands, targets) {
     const projectDir = process.cwd();
@@ -180,6 +231,37 @@ 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
  */
@@ -326,15 +408,17 @@ async function installPackage(options = {}) {
                 error: new Error("Configuration file not found"),
                 installedRuleCount: 0,
                 installedCommandCount: 0,
+                installedAssetCount: 0,
                 packagesCount: 0,
             };
         }
-        const { config, rules, commands, mcpServers } = resolvedConfig;
+        const { config, rules, commands, assets, mcpServers } = resolvedConfig;
         if (config.skipInstall === true) {
             return {
                 success: true,
                 installedRuleCount: 0,
                 installedCommandCount: 0,
+                installedAssetCount: 0,
                 packagesCount: 0,
             };
         }
@@ -342,7 +426,7 @@ async function installPackage(options = {}) {
         const commandsToInstall = dedupeCommandsForInstall(commands);
         try {
             if (!options.dryRun) {
-                writeRulesToTargets(rules, config.targets);
+                writeRulesToTargets(rules, assets, config.targets);
                 writeCommandsToTargets(commandsToInstall, config.targets);
                 if (mcpServers && Object.keys(mcpServers).length > 0) {
                     writeMcpServersToTargets(mcpServers, config.targets, cwd);
@@ -354,6 +438,7 @@ async function installPackage(options = {}) {
                 success: true,
                 installedRuleCount: uniqueRuleCount,
                 installedCommandCount: uniqueCommandCount,
+                installedAssetCount: assets.length,
                 packagesCount: 1,
             };
         }
@@ -363,6 +448,7 @@ async function installPackage(options = {}) {
                 error: error instanceof Error ? error : new Error(String(error)),
                 installedRuleCount: 0,
                 installedCommandCount: 0,
+                installedAssetCount: 0,
                 packagesCount: 0,
             };
         }
@@ -375,6 +461,7 @@ 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;
@@ -386,12 +473,14 @@ async function installWorkspacesPackages(packages, options = {}) {
             });
             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) {
@@ -401,6 +490,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 error: error instanceof Error ? error : new Error(String(error)),
                 installedRuleCount: 0,
                 installedCommandCount: 0,
+                installedAssetCount: 0,
             });
         }
     }
@@ -410,6 +500,7 @@ async function installWorkspacesPackages(packages, options = {}) {
         packages: results,
         totalRuleCount,
         totalCommandCount,
+        totalAssetCount,
     };
 }
 /**
@@ -440,6 +531,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 error: new Error("No packages with aicm configurations found"),
                 installedRuleCount: 0,
                 installedCommandCount: 0,
+                installedAssetCount: 0,
                 packagesCount: 0,
             };
         }
@@ -455,6 +547,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) {
@@ -496,6 +599,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
                 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,
             };
         }
@@ -503,6 +607,7 @@ async function installWorkspaces(cwd, installOnCI, verbose = false, dryRun = fal
             success: true,
             installedRuleCount: result.totalRuleCount,
             installedCommandCount: result.totalCommandCount,
+            installedAssetCount: result.totalAssetCount,
             packagesCount: result.packages.length,
         };
     });
@@ -520,6 +625,7 @@ async function install(options = {}) {
             success: true,
             installedRuleCount: 0,
             installedCommandCount: 0,
+            installedAssetCount: 0,
             packagesCount: 0,
         };
     }

package/dist/utils/config.d.ts

@@ -40,6 +40,13 @@ export interface ManagedFile {
     source: "local" | "preset";
     presetName?: string;
 }
+export interface AssetFile {
+    name: string;
+    content: Buffer;
+    sourcePath: string;
+    source: "local" | "preset";
+    presetName?: string;
+}
 export type RuleFile = ManagedFile;
 export type CommandFile = ManagedFile;
 export interface RuleCollection {
@@ -49,6 +56,7 @@ export interface ResolvedConfig {
     config: Config;
     rules: RuleFile[];
     commands: CommandFile[];
+    assets: AssetFile[];
     mcpServers: MCPServers;
 }
 export declare const ALLOWED_CONFIG_KEYS: readonly ["rulesDir", "commandsDir", "targets", "presets", "overrides", "mcpServers", "workspaces", "skipInstall"];
@@ -60,6 +68,7 @@ export declare function applyDefaults(config: RawConfig, workspaces: boolean): C
 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 resolvePresetPath(presetPath: string, cwd: string): string | null;
 export declare function loadPreset(presetPath: string, cwd: string): Promise<{
     config: Config;
@@ -69,6 +78,7 @@ export declare function loadPreset(presetPath: string, cwd: string): Promise<{
 export declare function loadAllRules(config: Config, cwd: string): Promise<{
     rules: RuleFile[];
     commands: CommandFile[];
+    assets: AssetFile[];
     mcpServers: MCPServers;
 }>;
 export declare function applyOverrides<T extends ManagedFile>(files: T[], overrides: Record<string, string | false>, cwd: string): T[];

package/dist/utils/config.js

@@ -10,6 +10,7 @@ exports.applyDefaults = applyDefaults;
 exports.validateConfig = validateConfig;
 exports.loadRulesFromDirectory = loadRulesFromDirectory;
 exports.loadCommandsFromDirectory = loadCommandsFromDirectory;
+exports.loadAssetsFromDirectory = loadAssetsFromDirectory;
 exports.resolvePresetPath = resolvePresetPath;
 exports.loadPreset = loadPreset;
 exports.loadAllRules = loadAllRules;
@@ -175,6 +176,34 @@ async function loadCommandsFromDirectory(commandsDir, source, presetName) {
     }
     return commands;
 }
+async function loadAssetsFromDirectory(rulesDir, source, presetName) {
+    const assets = [];
+    if (!fs_extra_1.default.existsSync(rulesDir)) {
+        return assets;
+    }
+    // Find all files except .mdc files and hidden files
+    const pattern = node_path_1.default.join(rulesDir, "**/*").replace(/\\/g, "/");
+    const filePaths = await (0, fast_glob_1.default)(pattern, {
+        onlyFiles: true,
+        absolute: true,
+        ignore: ["**/*.mdc", "**/.*"],
+    });
+    for (const filePath of filePaths) {
+        const content = await fs_extra_1.default.readFile(filePath);
+        // Preserve directory structure by using relative path from rulesDir
+        const relativePath = node_path_1.default.relative(rulesDir, filePath);
+        // Keep extension for assets
+        const assetName = relativePath.replace(/\\/g, "/");
+        assets.push({
+            name: assetName,
+            content,
+            sourcePath: filePath,
+            source,
+            presetName,
+        });
+    }
+    return assets;
+}
 function resolvePresetPath(presetPath, cwd) {
     // Support specifying aicm.json directory and load the config from it
     if (!presetPath.endsWith(".json")) {
@@ -230,12 +259,15 @@ async function loadPreset(presetPath, cwd) {
 async function loadAllRules(config, cwd) {
     const allRules = [];
     const allCommands = [];
+    const allAssets = [];
     let mergedMcpServers = { ...config.mcpServers };
     // Load local rules only if rulesDir is provided
     if (config.rulesDir) {
         const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
         const localRules = await loadRulesFromDirectory(localRulesPath, "local");
+        const localAssets = await loadAssetsFromDirectory(localRulesPath, "local");
         allRules.push(...localRules);
+        allAssets.push(...localAssets);
     }
     if (config.commandsDir) {
         const localCommandsPath = node_path_1.default.resolve(cwd, config.commandsDir);
@@ -247,7 +279,9 @@ async function loadAllRules(config, cwd) {
             const preset = await loadPreset(presetPath, cwd);
             if (preset.rulesDir) {
                 const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
+                const presetAssets = await loadAssetsFromDirectory(preset.rulesDir, "preset", presetPath);
                 allRules.push(...presetRules);
+                allAssets.push(...presetAssets);
             }
             if (preset.commandsDir) {
                 const presetCommands = await loadCommandsFromDirectory(preset.commandsDir, "preset", presetPath);
@@ -262,6 +296,7 @@ async function loadAllRules(config, cwd) {
     return {
         rules: allRules,
         commands: allCommands,
+        assets: allAssets,
         mcpServers: mergedMcpServers,
     };
 }
@@ -341,9 +376,10 @@ async function loadConfig(cwd) {
     const isWorkspaces = resolveWorkspaces(config, configResult.filepath, workingDir);
     validateConfig(config, configResult.filepath, workingDir, isWorkspaces);
     const configWithDefaults = applyDefaults(config, isWorkspaces);
-    const { rules, commands, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
+    const { rules, commands, assets, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
     let rulesWithOverrides = rules;
     let commandsWithOverrides = commands;
+    // Note: Assets are not currently supported in overrides as they are binary/varied files
     if (configWithDefaults.overrides) {
         const overrides = configWithDefaults.overrides;
         const ruleNames = new Set(rules.map((rule) => rule.name));
@@ -366,6 +402,7 @@ async function loadConfig(cwd) {
         config: configWithDefaults,
         rules: rulesWithOverrides,
         commands: commandsWithOverrides,
+        assets,
         mcpServers,
     };
 }

package/package.json

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