aicm 0.6.0 → 0.6.2

package/README.md

@@ -121,32 +121,24 @@ When you use a preset, you can override or disable any rule or mcpServer from th
 
 ### Demo
 
-We'll install an npm package containing a simple rule 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 an npm 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
+2. Create an `aicm.json` file in your project
 
 ```bash
-npx -y aicm init
-```
-
-3. Add the rule to your config file: `aicm.json`
-
-```json
-{
+echo '{
   "ides": ["cursor"],
-  "rules": {
-    "pirate-coding": "pirate-coding-rule/rule.mdc"
-  }
-}
+  "presets": ["pirate-coding"]
+}' > aicm.json
 ```
 
-4. Install all rules from your configuration
+3. Install all rules & mcps from your configuration
 
 ```bash
 npx -y aicm install
@@ -154,7 +146,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
 
@@ -251,12 +243,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
 ```
 
+## Node.js API
+
+In addition to the CLI, aicm can be used programmatically in Node.js applications:
+
+```javascript
+const { install, Config } = require("aicm");
+
+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.

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,39 @@ 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!"));
     }
     catch (error) {
         console.error(chalk_1.default.red(`Error during rule installation: ${error instanceof Error ? error.message : String(error)}`));

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "aicm",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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"
   },