aicm 0.4.0 → 0.5.0

package/README.md

@@ -66,9 +66,9 @@ Now the rules will be linked to `.cursor/rules/` when you run `npm install`.
 
 Presets allow you to bundle multiple rules into a single configuration that can be shared across projects.
 
-1. **Create a preset file**
+1. **Create a preset package or directory**
 
-Create a JSON file with your rule definitions:
+Create an npm package with your rule definitions in an `aicm.json` file:
 
 ```json
 {
@@ -81,34 +81,83 @@ Create a JSON file with your rule definitions:
 
 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/`.
 
+### Overriding and Canceling Rules and MCP Servers from Presets
+
+When you use a preset, you can override or cancel 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.
+
+**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
+  }
+}
+```
+
+- 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:
 
+1. Install a package containing a rule
+
 ```bash
-# Install a package containing a rule
 npm install --save-dev pirate-coding-rule
+```
+
+2. Initialize aicm config
 
-# Install the rule via the aicm CLI
-npx -y aicm install pirate-coding pirate-coding-rule/rule.mdc
+```bash
+npx -y aicm init
 ```
 
-This command will:
+3. Add the rule to your config file: `aicm.json`
 
-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/`
+```json
+{
+  "ides": ["cursor"],
+  "rules": {
+    "pirate-coding": "pirate-coding-rule/rule.mdc"
+  }
+}
+```
+
+4. Install all rules from your configuration
+
+```bash
+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.
 
@@ -162,7 +211,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
 
@@ -211,22 +259,18 @@ npx aicm init
 Installs rules from your configuration to the appropriate IDE locations.
 
 ```bash
-npx aicm install [rule-name] [rule-source]
+npx aicm install
 ```
 
 **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)
+- No arguments are supported. All rules are installed from your configuration and any referenced presets.
 
 **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
 ```
 
 ## Contributing

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/index.js",
   "bin": {