aicm 0.8.0 → 0.9.1

package/README.md

@@ -37,12 +37,12 @@ In your project's `aicm.json`, reference the package and the specific rule:
 }
 ```
 
-2. **Add a postinstall script** to your `package.json`:
+2. **Add a prepare script** to your `package.json`:
 
 ```json
 {
   "scripts": {
-    "postinstall": "npx -y aicm install"
+    "prepare": "npx -y aicm install"
   }
 }
 ```

package/dist/commands/install.js

@@ -108,6 +108,8 @@ async function install(options = {}) {
             const ruleType = (0, rule_detector_1.detectRuleType)(source);
             // Get the base path of the preset file if this rule came from a preset
             const ruleBasePath = (0, config_1.getRuleSource)(config, name);
+            // Get the original preset path for namespacing
+            const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
             // Collect the rule based on its type
             try {
                 let ruleContent;
@@ -122,6 +124,10 @@ async function install(options = {}) {
                         errorMessages.push(`Unknown rule type: ${ruleType}`);
                         continue;
                 }
+                // Add the preset path to the rule content for namespacing
+                if (originalPresetPath) {
+                    ruleContent.presetPath = originalPresetPath;
+                }
                 (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
                 installedRuleCount++;
             }

package/dist/types/index.d.ts

@@ -35,6 +35,7 @@ export interface RuleContent {
     content: string;
     metadata: RuleMetadata;
     sourcePath: string;
+    presetPath?: string;
 }
 export interface RuleCollection {
     cursor: RuleContent[];

package/dist/utils/config.d.ts

@@ -1,20 +1,30 @@
 import { Config, Rules } from "../types";
-interface ConfigWithMeta extends Config {
-    __ruleSources?: Record<string, string>;
+export interface RuleMetadata {
+    ruleSources: Record<string, string>;
+    originalPresetPaths: Record<string, string>;
 }
-export declare function getFullPresetPath(presetPath: string): string | null;
+export interface ConfigResult {
+    config: Config;
+    metadata: RuleMetadata;
+}
+export interface PresetPathInfo {
+    fullPath: string;
+    originalPath: string;
+}
+export declare function getFullPresetPath(presetPath: string): PresetPathInfo | null;
 /**
- * Load a preset file and return its rules and mcpServers
+ * Load a preset file and return its contents
  */
 export declare function loadPreset(presetPath: string): {
     rules: Rules;
     mcpServers?: import("../types").MCPServers;
+    presets?: string[];
 } | null;
 /**
  * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
  * Returns the config object or null if not found.
  */
-export declare function loadAicmConfigCosmiconfig(): ConfigWithMeta | null;
+export declare function loadAicmConfigCosmiconfig(): Config | null;
 /**
  * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
  */
@@ -23,8 +33,11 @@ export declare function getConfig(): Config | null;
  * Get the source preset path for a rule if it came from a preset
  */
 export declare function getRuleSource(config: Config, ruleName: string): string | undefined;
+/**
+ * Get the original preset path for a rule if it came from a preset
+ */
+export declare function getOriginalPresetPath(config: Config, ruleName: string): string | undefined;
 /**
  * Save the configuration to the aicm.json file
  */
 export declare function saveConfig(config: Config): boolean;
-export {};

package/dist/utils/config.js

@@ -8,43 +8,66 @@ exports.loadPreset = loadPreset;
 exports.loadAicmConfigCosmiconfig = loadAicmConfigCosmiconfig;
 exports.getConfig = getConfig;
 exports.getRuleSource = getRuleSource;
+exports.getOriginalPresetPath = getOriginalPresetPath;
 exports.saveConfig = saveConfig;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
 const cosmiconfig_1 = require("cosmiconfig");
 const CONFIG_FILE = "aicm.json";
 function getFullPresetPath(presetPath) {
+    // If it's a local file with .json extension and exists, return as is
     if (presetPath.endsWith(".json") && fs_extra_1.default.pathExistsSync(presetPath)) {
-        return presetPath;
+        return { fullPath: presetPath, originalPath: presetPath };
     }
     try {
         let absolutePresetPath;
+        // Handle npm package with explicit JSON path
         if (presetPath.endsWith(".json")) {
             absolutePresetPath = require.resolve(presetPath, {
                 paths: [__dirname, process.cwd()],
             });
         }
+        // Handle npm package without explicit JSON path (add aicm.json)
         else {
+            // For npm packages, ensure we properly handle scoped packages (@org/pkg)
             const presetPathWithConfig = node_path_1.default.join(presetPath, "aicm.json");
-            absolutePresetPath = require.resolve(presetPathWithConfig, {
-                paths: [__dirname, process.cwd()],
-            });
+            try {
+                absolutePresetPath = require.resolve(presetPathWithConfig, {
+                    paths: [__dirname, process.cwd()],
+                });
+            }
+            catch (_a) {
+                // If direct resolution fails, try as a package name
+                absolutePresetPath = require.resolve(presetPath, {
+                    paths: [__dirname, process.cwd()],
+                });
+                // If we found the package but not the config file, look for aicm.json
+                if (fs_extra_1.default.existsSync(absolutePresetPath)) {
+                    const packageDir = node_path_1.default.dirname(absolutePresetPath);
+                    const configPath = node_path_1.default.join(packageDir, "aicm.json");
+                    if (fs_extra_1.default.existsSync(configPath)) {
+                        absolutePresetPath = configPath;
+                    }
+                }
+            }
         }
-        return fs_extra_1.default.existsSync(absolutePresetPath) ? absolutePresetPath : null;
+        return fs_extra_1.default.existsSync(absolutePresetPath)
+            ? { fullPath: absolutePresetPath, originalPath: presetPath }
+            : null;
     }
-    catch (_a) {
+    catch (_b) {
         return null;
     }
 }
 /**
- * Load a preset file and return its rules and mcpServers
+ * Load a preset file and return its contents
  */
 function loadPreset(presetPath) {
-    const fullPresetPath = getFullPresetPath(presetPath);
-    if (!fullPresetPath) {
+    const pathInfo = getFullPresetPath(presetPath);
+    if (!pathInfo) {
         throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
     }
-    const presetContent = fs_extra_1.default.readFileSync(fullPresetPath, "utf8");
+    const presetContent = fs_extra_1.default.readFileSync(pathInfo.fullPath, "utf8");
     let preset;
     try {
         preset = JSON.parse(presetContent);
@@ -56,67 +79,122 @@ function loadPreset(presetPath) {
     if (!preset.rules || typeof preset.rules !== "object") {
         throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
     }
-    return { rules: preset.rules, mcpServers: preset.mcpServers };
+    return {
+        rules: preset.rules,
+        mcpServers: preset.mcpServers,
+        presets: preset.presets,
+    };
 }
+// Global metadata storage
+let currentMetadata = null;
+// Track processed presets to avoid circular references
+const processedPresets = new Set();
 /**
- * Process presets and merge their rules and mcpServers into the config
+ * Process presets and return a new config with merged rules and metadata
  */
 function processPresets(config) {
+    // Create a deep copy of the config to avoid mutations
+    const newConfig = JSON.parse(JSON.stringify(config));
+    const metadata = {
+        ruleSources: {},
+        originalPresetPaths: {},
+    };
+    // Clear processed presets tracking set when starting from the top level
+    processedPresets.clear();
+    return processPresetsInternal(newConfig, metadata);
+}
+/**
+ * Internal function to process presets recursively
+ */
+function processPresetsInternal(config, metadata) {
     if (!config.presets || !Array.isArray(config.presets)) {
-        return;
+        return { config, metadata };
     }
     for (const presetPath of config.presets) {
+        const pathInfo = getFullPresetPath(presetPath);
+        if (!pathInfo) {
+            throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
+        }
+        // Skip if we've already processed this preset (prevents circular references)
+        if (processedPresets.has(pathInfo.fullPath)) {
+            console.warn(`Skipping already processed preset: ${presetPath}`);
+            continue;
+        }
+        // Mark this preset as processed
+        processedPresets.add(pathInfo.fullPath);
         const preset = loadPreset(presetPath);
         if (!preset)
             continue;
-        const fullPresetPath = getFullPresetPath(presetPath);
-        if (!fullPresetPath)
-            continue;
-        mergePresetRules(config, preset.rules, fullPresetPath);
+        // Process nested presets first (depth-first)
+        if (preset.presets && preset.presets.length > 0) {
+            // Create a temporary config with just the presets from this preset
+            const presetConfig = {
+                rules: {},
+                presets: preset.presets,
+                ides: [],
+            };
+            // Recursively process the nested presets
+            const { config: nestedConfig } = processPresetsInternal(presetConfig, metadata);
+            Object.assign(preset.rules, nestedConfig.rules);
+        }
+        const { updatedConfig, updatedMetadata } = mergePresetRules(config, preset.rules, pathInfo, metadata);
+        Object.assign(config.rules, updatedConfig.rules);
+        Object.assign(metadata.ruleSources, updatedMetadata.ruleSources);
+        Object.assign(metadata.originalPresetPaths, updatedMetadata.originalPresetPaths);
         if (preset.mcpServers) {
-            mergePresetMcpServers(config, preset.mcpServers);
+            config.mcpServers = mergePresetMcpServers(config.mcpServers || {}, preset.mcpServers);
         }
     }
+    return { config, metadata };
 }
 /**
- * Merge preset rules into the config
+ * Merge preset rules into the config without mutation
  */
-function mergePresetRules(config, presetRules, presetPath) {
+function mergePresetRules(config, presetRules, pathInfo, metadata) {
+    const updatedRules = { ...config.rules };
+    const updatedMetadata = {
+        ruleSources: { ...metadata.ruleSources },
+        originalPresetPaths: { ...metadata.originalPresetPaths },
+    };
     for (const [ruleName, rulePath] of Object.entries(presetRules)) {
         // Cancel if set to false in config
         if (Object.prototype.hasOwnProperty.call(config.rules, ruleName) &&
             config.rules[ruleName] === false) {
-            delete config.rules[ruleName];
-            if (config.__ruleSources)
-                delete config.__ruleSources[ruleName];
+            delete updatedRules[ruleName];
+            delete updatedMetadata.ruleSources[ruleName];
+            delete updatedMetadata.originalPresetPaths[ruleName];
             continue;
         }
         // Only add if not already defined in config (override handled by config)
         if (!Object.prototype.hasOwnProperty.call(config.rules, ruleName)) {
-            config.rules[ruleName] = rulePath;
-            config.__ruleSources = config.__ruleSources || {};
-            config.__ruleSources[ruleName] = presetPath;
+            updatedRules[ruleName] = rulePath;
+            updatedMetadata.ruleSources[ruleName] = pathInfo.fullPath;
+            updatedMetadata.originalPresetPaths[ruleName] = pathInfo.originalPath;
         }
     }
+    return {
+        updatedConfig: { ...config, rules: updatedRules },
+        updatedMetadata,
+    };
 }
 /**
- * Merge preset mcpServers into the config
+ * Merge preset mcpServers without mutation
  */
-function mergePresetMcpServers(config, presetMcpServers) {
-    if (!config.mcpServers)
-        config.mcpServers = {};
+function mergePresetMcpServers(configMcpServers, presetMcpServers) {
+    const newMcpServers = { ...configMcpServers };
     for (const [serverName, serverConfig] of Object.entries(presetMcpServers)) {
         // Cancel if set to false in config
-        if (Object.prototype.hasOwnProperty.call(config.mcpServers, serverName) &&
-            config.mcpServers[serverName] === false) {
-            delete config.mcpServers[serverName];
+        if (Object.prototype.hasOwnProperty.call(newMcpServers, serverName) &&
+            newMcpServers[serverName] === false) {
+            delete newMcpServers[serverName];
             continue;
         }
         // Only add if not already defined in config (override handled by config)
-        if (!Object.prototype.hasOwnProperty.call(config.mcpServers, serverName)) {
-            config.mcpServers[serverName] = serverConfig;
+        if (!Object.prototype.hasOwnProperty.call(newMcpServers, serverName)) {
+            newMcpServers[serverName] = serverConfig;
         }
     }
+    return newMcpServers;
 }
 /**
  * Load the aicm config using cosmiconfigSync, supporting both aicm.json and package.json.
@@ -149,15 +227,24 @@ function getConfig() {
     if (!config) {
         throw new Error(`No config found in ${process.cwd()}, create one using "aicm init"`);
     }
-    processPresets(config);
-    return config;
+    const { config: processedConfig, metadata } = processPresets(config);
+    // Store metadata for later access
+    currentMetadata = metadata;
+    return processedConfig;
 }
 /**
  * Get the source preset path for a rule if it came from a preset
  */
 function getRuleSource(config, ruleName) {
     var _a;
-    return (_a = config.__ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
+    return (_a = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
+}
+/**
+ * Get the original preset path for a rule if it came from a preset
+ */
+function getOriginalPresetPath(config, ruleName) {
+    var _a;
+    return (_a = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.originalPresetPaths) === null || _a === void 0 ? void 0 : _a[ruleName];
 }
 /**
  * Save the configuration to the aicm.json file

package/dist/utils/rule-writer.js

@@ -23,6 +23,21 @@ function writeRulesToTargets(collection) {
         writeWindsurfRulesFromCollection(collection.windsurf, idePaths.windsurf);
     }
 }
+/**
+ * Extract a normalized namespace from a preset path
+ * @param presetPath The original preset path
+ * @returns An array of path segments to use for namespacing
+ */
+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("/");
+    }
+    // Handle both Unix and Windows style path separators
+    const parts = presetPath.split(/[/\\]/);
+    return parts.filter((part) => part.length > 0); // Filter out empty segments
+}
 /**
  * Write rules to Cursor's rules directory
  * @param rules The rules to write
@@ -31,7 +46,20 @@ function writeRulesToTargets(collection) {
 function writeCursorRules(rules, cursorRulesDir) {
     fs_extra_1.default.emptyDirSync(cursorRulesDir);
     for (const rule of rules) {
-        const ruleFile = node_path_1.default.join(cursorRulesDir, ...rule.name.split("/")) + ".mdc";
+        let rulePath;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        if (rule.presetPath) {
+            // For rules from presets, create a namespaced directory structure
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            // Path will be: cursorRulesDir/namespace/rule-name.mdc
+            rulePath = node_path_1.default.join(cursorRulesDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            // For local rules, maintain the original flat structure
+            rulePath = node_path_1.default.join(cursorRulesDir, ...ruleNameParts);
+        }
+        const ruleFile = rulePath + ".mdc";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(ruleFile));
         if (fs_extra_1.default.existsSync(rule.sourcePath)) {
             fs_extra_1.default.copyFileSync(rule.sourcePath, ruleFile);
@@ -49,11 +77,33 @@ function writeCursorRules(rules, cursorRulesDir) {
 function writeWindsurfRulesFromCollection(rules, ruleDir) {
     fs_extra_1.default.emptyDirSync(ruleDir);
     const ruleFiles = rules.map((rule) => {
-        const physicalRulePath = node_path_1.default.join(ruleDir, ...rule.name.split("/")) + ".md";
+        let rulePath;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        if (rule.presetPath) {
+            // For rules from presets, create a namespaced directory structure
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            // Path will be: ruleDir/namespace/rule-name.md
+            rulePath = node_path_1.default.join(ruleDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            // For local rules, maintain the original flat structure
+            rulePath = node_path_1.default.join(ruleDir, ...ruleNameParts);
+        }
+        const physicalRulePath = rulePath + ".md";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(physicalRulePath));
         fs_extra_1.default.writeFileSync(physicalRulePath, rule.content);
         const relativeRuleDir = node_path_1.default.basename(ruleDir); // Gets '.rules'
-        const windsurfPath = node_path_1.default.join(relativeRuleDir, ...rule.name.split("/")) + ".md";
+        // For the Windsurf rules file, we need to maintain the same structure
+        let windsurfPath;
+        if (rule.presetPath) {
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            windsurfPath =
+                node_path_1.default.join(relativeRuleDir, ...namespace, ...ruleNameParts) + ".md";
+        }
+        else {
+            windsurfPath = node_path_1.default.join(relativeRuleDir, ...ruleNameParts) + ".md";
+        }
         // Normalize to POSIX style for cross-platform compatibility in .windsurfrules
         const windsurfPathPosix = windsurfPath.replace(/\\/g, "/");
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.8.0",
+  "version": "0.9.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",