aicm 0.5.0 → 0.6.1

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,21 +48,28 @@ 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**
 
 Create an npm package with your rule definitions in an `aicm.json` file:
 
+> `@myteam/ai-tools/aicm.json`
+
 ```json
 {
   "rules": {
     "typescript": "./rules/typescript.mdc",
     "react": "./rules/react.mdc"
+  },
+  "mcpServers": {
+    "my-mcp": {
+      "url": "https://example.com/sse"
+    }
   }
 }
 ```
@@ -90,14 +85,19 @@ In your project's `aicm.json`, reference the preset by its npm package or direct
 }
 ```
 
-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`.
 
-### Overriding and Canceling Rules and MCP Servers from Presets
+### Notes
 
-When you use a preset, you can override or cancel any rule or mcpServer from the preset in your own `aicm.json` configuration:
+- 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.
-- **Cancel**: To cancel (remove) a rule or mcpServer from a preset, set its value to `false` in your config.
+- **Disable**: To disable a rule or mcpServer from a preset, set its value to `false` in your config.
 
 **Example:**
 
@@ -119,19 +119,14 @@ When you use a preset, you can override or cancel any rule or mcpServer from the
 }
 ```
 
-- In this example, `npm-rule` is overridden with a local rule, and `preset-rule` is canceled.
-- The `preset-mcp` server is overridden, and `another-mcp` is canceled.
-
-This allows you to fully customize or selectively disable rules and servers from any preset you use.
-
 ### Demo
 
-Here is a package to demonstrate how aicm works:
+We'll install [an npm package](https://github.com/ranyitz/pirate-coding) containing a simple preset to demonstrate how aicm works.
 
-1. Install a package containing a rule
+1. Install an npm package containing a preset
 
 ```bash
-npm install --save-dev pirate-coding-rule
+npm install --save-dev pirate-coding
 ```
 
 2. Initialize aicm config
@@ -145,13 +140,11 @@ npx -y aicm init
 ```json
 {
   "ides": ["cursor"],
-  "rules": {
-    "pirate-coding": "pirate-coding-rule/rule.mdc"
-  }
+  "presets": ["pirate-coding"]
 }
 ```
 
-4. Install all rules from your configuration
+4. Install all rules & mcps from your configuration
 
 ```bash
 npx -y aicm install
@@ -159,7 +152,7 @@ npx -y aicm install
 
 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.
+After installation, open Cursor and ask it to do something. Your AI assistant will respond with pirate-themed coding advice. You can also ask it about the aicm library which uses https://gitmcp.io/ to give you advise based on the latest documentation.
 
 ## Security Note
 
@@ -179,11 +172,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"
     }
   }
 }
@@ -195,7 +188,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:
@@ -234,8 +227,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
 
@@ -256,23 +249,65 @@ npx aicm init
 
 ### `install`
 
-Installs rules from your configuration to the appropriate IDE locations.
+Installs all rules and MCPs configured in your `aicm.json`.
 
 ```bash
 npx aicm install
 ```
 
-**Options:**
+## Node.js API
 
-- No arguments are supported. All rules are installed from your configuration and any referenced presets.
+In addition to the CLI, aicm can be used programmatically in Node.js applications:
 
-**Examples:**
+```javascript
+const { install, Config } = require("aicm");
 
-```bash
-# Install all configured rules
-npx -y aicm install
+install().then((result) => {
+  if (result.success) {
+    console.log(`Successfully installed ${result.installedRuleCount} rules`);
+  } else {
+    console.error(`Error: ${result.error}`);
+  }
+});
+
+// Install with custom options
+const customConfig = {
+  ides: ["cursor"],
+  rules: {
+    typescript: "./rules/typescript.mdc",
+    react: "@org/rules/react.mdc",
+  },
+};
+
+install({
+  config: customConfig,
+  cwd: "/path/to/project",
+  silent: true,
+}).then((result) => {
+  // Handle result
+});
 ```
 
+### API Reference
+
+#### `install(options?: InstallOptions): Promise<InstallResult>`
+
+Installs rules and MCP servers based on configuration.
+
+**Options:**
+
+- `cwd`: Base directory to use instead of `process.cwd()`
+- `config`: Custom config object to use instead of loading from file
+- `silent`: Whether to suppress console output
+
+**Returns:**
+
+A Promise that resolves to an object with:
+
+- `success`: Whether the operation was successful
+- `error`: Error message if the operation failed
+- `installedRuleCount`: Number of rules installed
+
 ## Contributing
 
 Contributions are welcome! Please feel free to submit a Pull Request.
@@ -281,8 +316,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/api.d.ts

@@ -0,0 +1,8 @@
+import { InstallOptions, InstallResult } from "./commands/install";
+/**
+ * Install AICM rules based on configuration
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+export declare function install(options?: InstallOptions): Promise<InstallResult>;
+export { Config, Rule, Rules, RuleMetadata, RuleContent, RuleCollection, } from "./types";

package/dist/api.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
+const install_1 = require("./commands/install");
+/**
+ * Install AICM rules based on configuration
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+async function install(options = {}) {
+    return (0, install_1.install)(options);
+}

package/dist/commands/init.js

@@ -20,11 +20,10 @@ function initCommand() {
     }
     try {
         fs_extra_1.default.writeJsonSync(configPath, defaultConfig, { spaces: 2 });
-        console.log(chalk_1.default.green("Configuration file created successfully!"));
         console.log(`Configuration file location: ${chalk_1.default.blue(configPath)}`);
         console.log(`\nNext steps:`);
-        console.log(`  1. Edit ${chalk_1.default.blue("aicm.json")} to configure your rules`);
-        console.log(`  2. Run ${chalk_1.default.blue("npx aicm install")} to install rules`);
+        console.log(`  1. Edit ${chalk_1.default.blue("aicm.json")} to configure your rules & presets`);
+        console.log(`  2. Run ${chalk_1.default.blue("npx aicm install")} to install rules & mcps`);
     }
     catch (error) {
         console.error(chalk_1.default.red("Error creating configuration file:"), error);

package/dist/commands/install.d.ts

@@ -1 +1,42 @@
+import { Config } from "../types";
+/**
+ * Options for the installCore function
+ */
+export interface InstallOptions {
+    /**
+     * Base directory to use instead of process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Custom config object to use instead of loading from file
+     */
+    config?: Config;
+    /**
+     * Whether to log progress to console
+     */
+    silent?: boolean;
+}
+/**
+ * Result of the install operation
+ */
+export interface InstallResult {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Error message if the operation failed
+     */
+    error?: string;
+    /**
+     * Number of rules installed
+     */
+    installedRuleCount: number;
+}
+/**
+ * Core implementation of the rule installation logic
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+export declare function install(options?: InstallOptions): Promise<InstallResult>;
 export declare function installCommand(): Promise<void>;

package/dist/commands/install.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.install = install;
 exports.installCommand = installCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../utils/config");
@@ -11,13 +12,19 @@ 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"));
-function writeMcpServersToTargets(mcpServers, ides) {
+/**
+ * Write MCP servers configuration to IDE targets
+ * @param mcpServers The MCP servers configuration
+ * @param ides The IDEs to write to
+ * @param cwd The current working directory
+ */
+function writeMcpServersToTargets(mcpServers, ides, cwd) {
     if (!mcpServers)
         return;
     for (const ide of ides) {
         let mcpPath = null;
         if (ide === "cursor") {
-            mcpPath = node_path_1.default.join(process.cwd(), ".cursor", "mcp.json");
+            mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
             fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(mcpPath));
         }
         // Windsurf does not support project mcpServers, so skip
@@ -26,37 +33,59 @@ function writeMcpServersToTargets(mcpServers, ides) {
         }
     }
 }
-async function installCommand() {
+/**
+ * Core implementation of the rule installation logic
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+async function install(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const silent = options.silent || false;
+    const log = silent ? () => { } : console.log;
+    const error = silent ? () => { } : console.error;
     try {
+        // Save original process.cwd() and change to the specified cwd
+        const originalCwd = process.cwd();
+        if (cwd !== originalCwd) {
+            process.chdir(cwd);
+        }
         // Initialize rule collection
         const ruleCollection = (0, rule_collector_1.initRuleCollection)();
-        // Load configuration
-        const config = (0, config_1.getConfig)();
-        // If config doesn't exist, print error and exit
+        // Use provided config or load from file
+        const config = options.config || (0, config_1.getConfig)();
+        // If config doesn't exist, return error
         if (!config) {
-            console.error(chalk_1.default.red("Configuration file not found! Please run 'npx aicm init' to create one."));
-            process.exit(1);
+            error("Configuration file not found!");
+            // Restore original cwd
+            if (cwd !== originalCwd) {
+                process.chdir(originalCwd);
+            }
+            return {
+                success: false,
+                error: "Configuration file not found!",
+                installedRuleCount: 0,
+            };
         }
         // 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.`);
-                return;
-            }
-        }
-        if (config.presets && config.presets.length > 0) {
-            const hasValidPresets = true;
-            // If no valid presets and no direct rules, exit
-            if (!hasValidPresets &&
-                (!config.rules || Object.keys(config.rules).length === 0)) {
-                console.log(chalk_1.default.yellow("\nNo valid rules found in configuration or presets."));
-                return;
+                error("No rules defined in configuration.");
+                // Restore original cwd
+                if (cwd !== originalCwd) {
+                    process.chdir(originalCwd);
+                }
+                return {
+                    success: false,
+                    error: "No rules defined in configuration.",
+                    installedRuleCount: 0,
+                };
             }
         }
         // Process each rule
         let hasErrors = false;
+        const errorMessages = [];
+        let installedRuleCount = 0;
         for (const [name, source] of Object.entries(config.rules)) {
             if (source === false)
                 continue; // skip canceled rules
@@ -75,20 +104,32 @@ async function installCommand() {
                         ruleContent = (0, rule_collector_1.collectLocalRule)(name, source, ruleBasePath);
                         break;
                     default:
-                        console.log(chalk_1.default.yellow(`Unknown rule type: ${ruleType}`));
+                        error(`Unknown rule type: ${ruleType}`);
+                        errorMessages.push(`Unknown rule type: ${ruleType}`);
                         continue;
                 }
                 // Add rule to collection
                 (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
+                installedRuleCount++;
             }
-            catch (error) {
+            catch (e) {
                 hasErrors = true;
-                console.error(chalk_1.default.red(`Error processing rule ${name}: ${error instanceof Error ? error.message : String(error)}`));
+                const errorMessage = `Error processing rule ${name}: ${e instanceof Error ? e.message : String(e)}`;
+                error(errorMessage);
+                errorMessages.push(errorMessage);
             }
         }
         // If there were errors, exit with error
         if (hasErrors) {
-            throw new Error("One or more rules failed to process");
+            // Restore original cwd
+            if (cwd !== originalCwd) {
+                process.chdir(originalCwd);
+            }
+            return {
+                success: false,
+                error: errorMessages.join("; "),
+                installedRuleCount,
+            };
         }
         // Write all collected rules to their targets
         (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
@@ -96,9 +137,40 @@ async function installCommand() {
         if (config.mcpServers) {
             // Filter out canceled servers
             const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
-            writeMcpServersToTargets(filteredMcpServers, config.ides);
+            writeMcpServersToTargets(filteredMcpServers, config.ides, cwd);
+        }
+        log("Rules installation completed!");
+        // Restore original cwd
+        if (cwd !== originalCwd) {
+            process.chdir(originalCwd);
+        }
+        return {
+            success: true,
+            installedRuleCount,
+        };
+    }
+    catch (e) {
+        const errorMessage = `Error during rule installation: ${e instanceof Error ? e.message : String(e)}`;
+        error(errorMessage);
+        // If cwd was changed, restore it
+        if (cwd !== process.cwd()) {
+            process.chdir(cwd);
+        }
+        return {
+            success: false,
+            error: errorMessage,
+            installedRuleCount: 0,
+        };
+    }
+}
+async function installCommand() {
+    try {
+        const result = await install({ silent: false });
+        if (!result.success) {
+            console.error(chalk_1.default.red(result.error));
+            process.exit(1);
         }
-        console.log(chalk_1.default.green("\nRules installation completed!"));
+        console.log(chalk_1.default.green("Rules installation completed!"));
     }
     catch (error) {
         console.error(chalk_1.default.red(`Error during rule installation: ${error instanceof Error ? error.message : String(error)}`));

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,8 +1,9 @@
 {
   "name": "aicm",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
-  "main": "dist/index.js",
+  "main": "dist/api.js",
+  "types": "dist/api.d.ts",
   "bin": {
     "aicm": "./dist/index.js"
   },
@@ -24,7 +25,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": [