aicm 0.4.1 → 0.6.0

package/README.md

@@ -6,23 +6,13 @@ A CLI tool for syncing and managing Agentic IDE rules across projects
 
 ## Why
 
-Development teams struggle with:
+With the rise of Agentic IDEs like cursor and windsurf, we have an opportunity to enforce best practices through rules. However, these rules are typically isolated within individual developers or projects.
 
-- **Inconsistent Practices**: Developers apply varying standards across projects
-- **Knowledge Silos**: Best practices remain trapped in individual projects
-- **Change Management**: No efficient way to update and distribute new standards
-
-As developers increasingly adopt AI-powered IDEs like Cursor and Windsurf, we have an opportunity to enforce best practices through rules. However, these rules are typically isolated within individual developers or projects.
-
-**aicm** is a CLI tool that helps with distribution of agentic IDE configurations, rules and mcps:
-
-- 🏛️ **Single Source of Truth**: Define, maintain and version-control all AI IDE rules in one central repository
-- 📦 **Seamless Distribution**: Automatically synchronize the latest rules to developers' local projects using npm packages
-- 🌐 **Cross-IDE Support**: Supports multiple AI-powered IDEs (Cursor, Windsurf)
+**aicm** is a CLI tool for distributing Agentic IDE configurations, rules, and MCPs across projects. It leverages package managers to copy configurations from node_modules to the correct locations in your file system.
 
 ## Getting Started
 
-To get automatic rule updates from NPM Packages, you can create, publish, and use dedicated npm packages to distribute AI rules across multiple projects.
+Since aicm is not a package manager, begin by creating an npm package that contains your rules and MCP configurations.
 
 Consider the following npm package structure:
 
@@ -31,8 +21,7 @@ Consider the following npm package structure:
 ├── package.json
 └── rules/
     ├── typescript.mdc
-    ├── react.mdc
-    └── general.mdc
+    └── react.mdc
 ```
 
 1. **Point to the path within the npm package**
@@ -44,8 +33,7 @@ In your project's `aicm.json`, reference the package and the specific rule:
   "ides": ["cursor"],
   "rules": {
     "typescript": "@myteam/ai-tools/rules/typescript.mdc",
-    "react": "@myteam/ai-tools/rules/react.mdc",
-    "general": "@myteam/ai-tools/rules/general.mdc"
+    "react": "@myteam/ai-tools/rules/react.mdc"
   }
 }
 ```
@@ -60,55 +48,111 @@ In your project's `aicm.json`, reference the package and the specific rule:
 }
 ```
 
-Now the rules will be linked to `.cursor/rules/` when you run `npm install`.
+Now the rules will be linked to `.cursor/rules/aicm/` when you run `npm install`.
 
 ### Using Presets
 
-Presets allow you to bundle multiple rules into a single configuration that can be shared across projects.
+Presets allow you to bundle multiple rules & mcps into a single configuration that can be shared across projects.
+
+1. **Create a preset package or directory**
 
-1. **Create a preset file**
+Create an npm package with your rule definitions in an `aicm.json` file:
 
-Create a JSON file with your rule definitions:
+> `@myteam/ai-tools/aicm.json`
 
 ```json
 {
   "rules": {
     "typescript": "./rules/typescript.mdc",
     "react": "./rules/react.mdc"
+  },
+  "mcpServers": {
+    "my-mcp": {
+      "url": "https://example.com/sse"
+    }
   }
 }
 ```
 
 2. **Reference the preset in your project**
 
-In your project's `aicm.json`, reference the preset:
+In your project's `aicm.json`, reference the preset by its npm package or directory name:
 
 ```json
 {
   "ides": ["cursor"],
-  "presets": ["@myteam/ai-tools/my-aicm.json"]
+  "presets": ["@myteam/ai-tools"]
 }
 ```
 
-When you run `npx aicm install`, all rules from the preset will be installed to `.cursor/rules/`.
+When you run `npx aicm install`, all rules from the preset will be installed to `.cursor/rules/aicm/` and all mcps from the preset will be installed to `.cursor/mcp.json`.
+
+### Notes
+
+- Generated rules are always placed in a subdirectory for deterministic cleanup and easy gitignore.
+- Users may add `.cursor/rules/aicm/` and `.aicm/` (for Windsurf) to their `.gitignore` if they do not want to track generated rules.
+
+### Overriding and Disabling Rules and MCP Servers from Presets
+
+When you use a preset, you can override or disable any rule or mcpServer from the preset in your own `aicm.json` configuration:
+
+- **Override**: To override a rule or mcpServer, specify the same key in your config with a new value. The value in your config will take precedence over the preset.
+- **Disable**: To disable a rule or mcpServer from a preset, set its value to `false` in your config.
+
+**Example:**
+
+```json
+{
+  "ides": ["cursor"],
+  "presets": ["@company/ai-rules/aicm.json"],
+  "rules": {
+    "rule-from-preset-a": "./rules/override-rule.mdc",
+    "rule-from-preset-b": false
+  },
+  "mcpServers": {
+    "mcp-from-preset-a": {
+      "command": "./scripts/override-mcp.sh",
+      "env": { "MCP_TOKEN": "override" }
+    },
+    "mcp-from-preset-b": false
+  }
+}
+```
 
 ### Demo
 
-Here is a package to demonstrate how aicm works:
+We'll install an npm package containing a simple rule to demonstrate how aicm works.
+
+1. Install an npm package containing a rule
 
 ```bash
-# Install a package containing a rule
 npm install --save-dev pirate-coding-rule
+```
 
-# Install the rule via the aicm CLI
-npx -y aicm install pirate-coding pirate-coding-rule/rule.mdc
+2. Initialize aicm config
+
+```bash
+npx -y aicm init
+```
+
+3. Add the rule to your config file: `aicm.json`
+
+```json
+{
+  "ides": ["cursor"],
+  "rules": {
+    "pirate-coding": "pirate-coding-rule/rule.mdc"
+  }
+}
 ```
 
-This command will:
+4. Install all rules from your configuration
+
+```bash
+npx -y aicm install
+```
 
-1. Create a `aicm.json` file if it doesn't exist
-2. Add the rule to the configuration
-3. Install the rule to `.cursor/rules/`
+This command installs all configured rules and MCPs to their IDE-specific locations.
 
 After installation, open Cursor and ask it to do something. Your AI assistant will respond with pirate-themed coding advice.
 
@@ -130,11 +174,11 @@ Example `aicm.json`:
   "ides": ["cursor"],
   "presets": ["@my-team/ai-tools/my-aicm.json"],
   "rules": {
-    "team-standards": "@my-team/ai-tools/rules/team-standards.mdc"
+    "team-rules/team-standards": "@my-team/ai-tools/rules/team-standards.mdc"
   },
   "mcpServers": {
     "remote-mcp": {
-      "url": "https://example.com/mcp-config.json"
+      "url": "https://example.com/sse"
     }
   }
 }
@@ -146,7 +190,7 @@ Example `aicm.json`:
 
 - **rules**: Object containing rule configurations
 
-  - **rule-name**: A unique identifier for the rule
+  - **rule-name**: A unique identifier for the rule. Can include a directory path to install the rule to a specific directory.
   - **source-location**: Location of the rule file (path within an npm package or local path)
 
 - **mcpServers**: Object containing MCP server configurations. Each key is a unique server name, and the value is an object with either:
@@ -162,7 +206,6 @@ Example `aicm.json`:
 
 - **Cursor**: MCP server configs are written to `.cursor/mcp.json` (see Cursor docs for latest path).
 - **Windsurf**: Windsurf does not support project mcpServers. MCP server configuration is not installed for Windsurf projects.
-- All installations are per-project.
 
 ### Rule Source Types
 
@@ -186,8 +229,8 @@ Rules stored locally in your project or filesystem. Any path containing slashes
 
 ## Supported IDEs
 
-- **Cursor**: Rules are installed as individual `.mdc` files in the Cursor rules directory (`.cursor/rules/`), mcp servers are installed to `.cursor/mcp.json`
-- **Windsurf**: Rules are installed in the `.rules` directory which should be added to your `.gitignore` file. Our approach for Windsurf is to create links from the `.windsurfrules` file to the respective rules in the `.rules` directory. There is no support for local mcp servers at the moment.
+- **Cursor**: Rules are installed as individual `.mdc` files in the Cursor rules directory (`.cursor/rules/aicm/`), mcp servers are installed to `.cursor/mcp.json`
+- **Windsurf**: Rules are installed in the `.aicm` directory which should be added to your `.gitignore` file. Our approach for Windsurf is to create links from the `.windsurfrules` file to the respective rules in the `.aicm` directory. There is no support for local mcp servers at the moment.
 
 ## Commands
 
@@ -211,22 +254,7 @@ npx aicm init
 Installs rules from your configuration to the appropriate IDE locations.
 
 ```bash
-npx aicm install [rule-name] [rule-source]
-```
-
-**Options:**
-
-- `[rule-name]`: Optional - Name of a specific rule to install instead of all rules
-- `[rule-source]`: Optional - Source of the rule (npm package or local path)
-
-**Examples:**
-
-```bash
-# Install all configured rules
-npx -y aicm install
-
-# Install a rule from an npm package and update configuration
-npx -y aicm install react-best-practices @my-team/ai-tools/react-best-practices.mdc
+npx aicm install
 ```
 
 ## Contributing
@@ -237,8 +265,6 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 ### Testing
 
-The project includes both unit tests and end-to-end (E2E) tests:
-
 ```bash
 # Run all tests
 npm test

package/dist/commands/install.js

@@ -5,19 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.installCommand = installCommand;
 const chalk_1 = __importDefault(require("chalk"));
-const arg_1 = __importDefault(require("arg"));
 const config_1 = require("../utils/config");
 const rule_detector_1 = require("../utils/rule-detector");
 const rule_collector_1 = require("../utils/rule-collector");
 const rule_writer_1 = require("../utils/rule-writer");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
-// Default configuration
-const defaultConfig = {
-    ides: ["cursor", "windsurf"],
-    rules: {},
-    presets: [],
-};
 function writeMcpServersToTargets(mcpServers, ides) {
     if (!mcpServers)
         return;
@@ -34,74 +27,22 @@ function writeMcpServersToTargets(mcpServers, ides) {
     }
 }
 async function installCommand() {
-    // Parse command-specific arguments
-    const args = (0, arg_1.default)({
-    // Removed flags as we'll infer the type from the source
-    }, {
-        permissive: true,
-        argv: process.argv.slice(3), // Skip the first two args and the command name
-    });
-    // Get rule name and source if provided
-    const ruleName = args._.length > 0 ? args._[0] : null;
-    const ruleSource = args._.length > 1 ? args._[1] : null;
     try {
         // Initialize rule collection
         const ruleCollection = (0, rule_collector_1.initRuleCollection)();
-        // If a rule name and source are provided, install directly
-        if (ruleName && ruleSource) {
-            // Detect rule type from the source string
-            const ruleType = (0, rule_detector_1.detectRuleType)(ruleSource);
-            // Create config file if it doesn't exist
-            let config = (0, config_1.getConfig)();
-            if (!config) {
-                config = { ...defaultConfig };
-                console.log(chalk_1.default.blue("Configuration file not found. Creating a new one..."));
-            }
-            // Add the rule to the config
-            config.rules[ruleName] = ruleSource;
-            // Save the updated config
-            (0, config_1.saveConfig)(config);
-            console.log(chalk_1.default.green("Configuration updated successfully!"));
-            // Collect the rule based on its type
-            let ruleContent;
-            switch (ruleType) {
-                case "npm":
-                    ruleContent = (0, rule_collector_1.collectNpmRule)(ruleName, ruleSource);
-                    break;
-                case "local":
-                    ruleContent = (0, rule_collector_1.collectLocalRule)(ruleName, ruleSource);
-                    break;
-                default:
-                    console.log(chalk_1.default.yellow(`Unknown rule type: ${ruleType}`));
-                    return;
-            }
-            // Add rule to collection
-            (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
-            // Write rules to targets
-            (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
-            // Write mcpServers config to IDE targets
-            writeMcpServersToTargets(config.mcpServers, config.ides);
-            console.log(chalk_1.default.green("\nRules installation completed!"));
-            return;
-        }
         // Load configuration
-        let config = (0, config_1.getConfig)();
-        // If config doesn't exist, create a new one
+        const config = (0, config_1.getConfig)();
+        // If config doesn't exist, print error and exit
         if (!config) {
-            config = { ...defaultConfig };
-            console.log(chalk_1.default.blue("Configuration file not found. Creating a new one..."));
-            (0, config_1.saveConfig)(config);
-            console.log(chalk_1.default.green("Empty configuration file created successfully!"));
-            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 or use the direct install command: npx aicm install <rule-name> <rule-source>`);
-            return;
+            console.error(chalk_1.default.red("Configuration file not found! Please run 'npx aicm init' to create one."));
+            process.exit(1);
         }
         // Check if rules are defined (either directly or through presets)
         if (!config.rules || Object.keys(config.rules).length === 0) {
             // If there are no presets defined either, show a message
             if (!config.presets || config.presets.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 or use the direct install command: npx aicm install <rule-name> <rule-source>`);
+                console.log(`Edit your ${chalk_1.default.blue("aicm.json")} file to add rules.`);
                 return;
             }
         }
@@ -114,13 +55,11 @@ async function installCommand() {
                 return;
             }
         }
-        // Process each rule (or just the specific one if provided)
+        // Process each rule
         let hasErrors = false;
         for (const [name, source] of Object.entries(config.rules)) {
-            // Skip if a specific rule was requested and this isn't it
-            if (ruleName && name !== ruleName) {
-                continue;
-            }
+            if (source === false)
+                continue; // skip canceled rules
             // Detect rule type from the source string
             const ruleType = (0, rule_detector_1.detectRuleType)(source);
             // Get the base path of the preset file if this rule came from a preset
@@ -145,25 +84,20 @@ async function installCommand() {
             catch (error) {
                 hasErrors = true;
                 console.error(chalk_1.default.red(`Error processing rule ${name}: ${error instanceof Error ? error.message : String(error)}`));
-                // If a specific rule was requested and it failed, exit immediately
-                if (ruleName) {
-                    throw error;
-                }
             }
         }
-        // If there were errors and we're not processing a specific rule, exit with error
-        if (hasErrors && !ruleName) {
+        // If there were errors, exit with error
+        if (hasErrors) {
             throw new Error("One or more rules failed to process");
         }
-        // If a specific rule was requested but not found
-        if (ruleName && !Object.keys(config.rules).includes(ruleName)) {
-            console.log(chalk_1.default.yellow(`Rule "${ruleName}" not found in configuration.`));
-            return;
-        }
         // Write all collected rules to their targets
         (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
         // Write mcpServers config to IDE targets
-        writeMcpServersToTargets(config.mcpServers, config.ides);
+        if (config.mcpServers) {
+            // Filter out canceled servers
+            const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
+            writeMcpServersToTargets(filteredMcpServers, config.ides);
+        }
         console.log(chalk_1.default.green("\nRules installation completed!"));
     }
     catch (error) {

package/dist/commands/list.js

@@ -23,6 +23,8 @@ function listCommand() {
     console.log(chalk_1.default.blue("Configured Rules:"));
     console.log(chalk_1.default.dim("─".repeat(50)));
     for (const [ruleName, source] of Object.entries(config.rules)) {
+        if (source === false)
+            continue; // skip canceled rules
         const ruleType = (0, rule_detector_1.detectRuleType)(source);
         const status = (0, rule_status_1.checkRuleStatus)(ruleName, ruleType, config.ides);
         const statusColor = status

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type Rule = string;
+export type Rule = string | false;
 export interface Rules {
     [ruleName: string]: Rule;
 }
@@ -12,7 +12,7 @@ export type MCPServer = {
     env?: Record<string, string>;
     command?: never;
     args?: never;
-};
+} | false;
 export interface MCPServers {
     [serverName: string]: MCPServer;
 }

package/dist/utils/config.js

@@ -23,14 +23,24 @@ function getFullPresetPath(presetPath) {
         let fullPresetPath = presetPath;
         if (ruleType === "npm") {
             try {
+                // Try to resolve as a file first
                 fullPresetPath = require.resolve(presetPath, {
                     paths: [process.cwd()],
                 });
             }
             catch (_a) {
+                // If not a file, check if it's a directory in node_modules
                 const directPath = node_path_1.default.join(process.cwd(), "node_modules", presetPath);
                 if (fs_extra_1.default.existsSync(directPath)) {
-                    fullPresetPath = directPath;
+                    // If it's a directory, look for aicm.json inside
+                    const aicmJsonPath = node_path_1.default.join(directPath, "aicm.json");
+                    if (fs_extra_1.default.existsSync(aicmJsonPath)) {
+                        fullPresetPath = aicmJsonPath;
+                    }
+                    else {
+                        // If aicm.json doesn't exist, treat the directory as invalid
+                        return null;
+                    }
                 }
                 else {
                     return null;
@@ -93,12 +103,18 @@ function processPresets(config) {
  * Merge preset rules into the config
  */
 function mergePresetRules(config, presetRules, presetPath) {
-    // Add preset rules, but don't override existing rules
     for (const [ruleName, rulePath] of Object.entries(presetRules)) {
-        // Only add if not already defined in config
-        if (!config.rules[ruleName]) {
+        // 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];
+            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;
-            // Store the source preset path in metadata
             config.__ruleSources = config.__ruleSources || {};
             config.__ruleSources[ruleName] = presetPath;
         }
@@ -111,7 +127,14 @@ function mergePresetMcpServers(config, presetMcpServers) {
     if (!config.mcpServers)
         config.mcpServers = {};
     for (const [serverName, serverConfig] of Object.entries(presetMcpServers)) {
-        if (!config.mcpServers[serverName]) {
+        // Cancel if set to false in config
+        if (Object.prototype.hasOwnProperty.call(config.mcpServers, serverName) &&
+            config.mcpServers[serverName] === false) {
+            delete config.mcpServers[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;
         }
     }

package/dist/utils/rule-collector.d.ts

@@ -23,11 +23,11 @@ export declare function addRuleToCollection(collection: RuleCollection, rule: Ru
  * @param ruleBasePath Optional base path for resolving relative paths
  * @returns The rule content
  */
-export declare function collectLocalRule(ruleName: string, source: string, ruleBasePath?: string): RuleContent;
+export declare function collectLocalRule(ruleName: string, source: string | false, ruleBasePath?: string): RuleContent;
 /**
  * Collect a rule from an npm package
  * @param ruleName The name of the rule
  * @param source The npm package source (can include path)
  * @returns The rule content
  */
-export declare function collectNpmRule(ruleName: string, source: string): RuleContent;
+export declare function collectNpmRule(ruleName: string, source: string | false): RuleContent;

package/dist/utils/rule-collector.js

@@ -87,6 +87,8 @@ function addRuleToCollection(collection, rule, ides) {
  * @returns The rule content
  */
 function collectLocalRule(ruleName, source, ruleBasePath) {
+    if (source === false)
+        throw new Error(`Rule '${ruleName}' is canceled and should not be processed.`);
     // Resolve path relative to base path or current directory
     let sourcePath = source;
     if (!node_path_1.default.isAbsolute(source)) {
@@ -118,6 +120,8 @@ function collectLocalRule(ruleName, source, ruleBasePath) {
  * @returns The rule content
  */
 function collectNpmRule(ruleName, source) {
+    if (source === false)
+        throw new Error(`Rule '${ruleName}' is canceled and should not be processed.`);
     // Parse source into package and file path
     let packageName;
     let packagePath;

package/dist/utils/rule-status.js

@@ -13,8 +13,8 @@ const node_path_1 = __importDefault(require("node:path"));
 function getIdePaths() {
     const projectDir = process.cwd(); // Get current working directory (project root)
     return {
-        cursor: node_path_1.default.join(projectDir, ".cursor", "rules"),
-        windsurf: node_path_1.default.join(projectDir, ".rules"),
+        cursor: node_path_1.default.join(projectDir, ".cursor", "rules", "aicm"),
+        windsurf: node_path_1.default.join(projectDir, ".aicm"),
     };
 }
 /**
@@ -22,7 +22,6 @@ function getIdePaths() {
  */
 function checkRuleStatus(ruleName, ruleType, ides) {
     const idePaths = getIdePaths();
-    // Check if rule is installed in all specified IDEs
     return ides.every((ide) => {
         if (!idePaths[ide]) {
             return false;
@@ -31,14 +30,11 @@ function checkRuleStatus(ruleName, ruleType, ides) {
             return fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.mdc`));
         }
         if (ide === "windsurf") {
-            // For Windsurf, check if the rule exists in .rules directory
-            // and if it's referenced in .windsurfrules
             const ruleExists = fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.md`));
-            // Check if .windsurfrules exists and contains a reference to this rule
             const windsurfRulesPath = node_path_1.default.join(process.cwd(), ".windsurfrules");
             if (fs_extra_1.default.existsSync(windsurfRulesPath)) {
                 const windsurfRulesContent = fs_extra_1.default.readFileSync(windsurfRulesPath, "utf8");
-                return (ruleExists && windsurfRulesContent.includes(`.rules/${ruleName}.md`));
+                return (ruleExists && windsurfRulesContent.includes(`.aicm/${ruleName}.md`));
             }
             return false;
         }

package/dist/utils/rule-writer.js

@@ -20,7 +20,7 @@ function writeRulesToTargets(collection) {
     }
     // Write Windsurf rules
     if (collection.windsurf.length > 0) {
-        writeWindsurfRulesFromCollection(collection.windsurf);
+        writeWindsurfRulesFromCollection(collection.windsurf, idePaths.windsurf);
     }
 }
 /**
@@ -29,16 +29,14 @@ function writeRulesToTargets(collection) {
  * @param cursorRulesDir The path to Cursor's rules directory
  */
 function writeCursorRules(rules, cursorRulesDir) {
-    fs_extra_1.default.ensureDirSync(cursorRulesDir);
+    fs_extra_1.default.emptyDirSync(cursorRulesDir);
     for (const rule of rules) {
-        const ruleFile = node_path_1.default.join(cursorRulesDir, `${rule.name}.mdc`);
-        // For Cursor, we either copy the file or create a symlink to the original
+        const ruleFile = node_path_1.default.join(cursorRulesDir, ...rule.name.split("/")) + ".mdc";
+        fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(ruleFile));
         if (fs_extra_1.default.existsSync(rule.sourcePath)) {
-            // Copy the file (safer than symlink)
             fs_extra_1.default.copyFileSync(rule.sourcePath, ruleFile);
         }
         else {
-            // If source path doesn't exist (shouldn't happen), write content directly
             const mdcContent = `---\n${JSON.stringify(rule.metadata, null, 2)}\n---\n\n${rule.content}`;
             fs_extra_1.default.writeFileSync(ruleFile, mdcContent);
         }
@@ -48,21 +46,22 @@ function writeCursorRules(rules, cursorRulesDir) {
  * Write rules to Windsurf's rules directory and update .windsurfrules file
  * @param rules The rules to write
  */
-function writeWindsurfRulesFromCollection(rules) {
-    const idePaths = (0, rule_status_1.getIdePaths)();
-    const ruleDir = idePaths.windsurf;
-    fs_extra_1.default.ensureDirSync(ruleDir);
-    // First write individual rule files
+function writeWindsurfRulesFromCollection(rules, ruleDir) {
+    fs_extra_1.default.emptyDirSync(ruleDir);
     const ruleFiles = rules.map((rule) => {
-        const ruleFile = node_path_1.default.join(ruleDir, `${rule.name}.md`);
-        fs_extra_1.default.writeFileSync(ruleFile, rule.content);
+        const physicalRulePath = node_path_1.default.join(ruleDir, ...rule.name.split("/")) + ".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";
+        // Normalize to POSIX style for cross-platform compatibility in .windsurfrules
+        const windsurfPathPosix = windsurfPath.replace(/\\/g, "/");
         return {
             name: rule.name,
-            path: `.rules/${rule.name}.md`,
+            path: windsurfPathPosix,
             metadata: rule.metadata,
         };
     });
-    // Then generate and write the .windsurfrules file
     const windsurfRulesContent = (0, windsurf_writer_1.generateWindsurfRulesContent)(ruleFiles);
     (0, windsurf_writer_1.writeWindsurfRules)(windsurfRulesContent);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/index.js",
   "bin": {
@@ -24,7 +24,7 @@
     "format": "prettier --write .",
     "format:check": "prettier --check .",
     "lint": "eslint",
-    "prepare": "husky && npx ts-node src/index.ts install",
+    "prepare": "husky install && npx ts-node src/index.ts install",
     "version": "auto-changelog -p && git add CHANGELOG.md"
   },
   "keywords": [