aicm 0.12.2 → 0.13.1

package/README.md

@@ -157,10 +157,12 @@ To prevent [prompt-injection](https://en.wikipedia.org/wiki/Prompt_injection), u
 
 aicm supports workspaces by automatically discovering and installing configurations across multiple packages in your repository.
 
-To enable workspaces mode, use the `--workspaces` flag:
+To enable workspaces mode, set the `workspaces` property to `true` in your root `aicm.json`:
 
-```bash
-npx aicm install --workspaces
+```json
+{
+  "workspaces": true
+}
 ```
 
 This will:
@@ -175,6 +177,7 @@ Each directory containing an `aicm.json` file is treated as a separate package w
 For example, in a workspace structure like:
 
 ```
+├── aicm.json (with "workspaces": true)
 ├── packages/
 │   ├── frontend/
 │   │   └── aicm.json
@@ -185,7 +188,7 @@ For example, in a workspace structure like:
         └── aicm.json
 ```
 
-Running `npx aicm install --workspaces` will install rules for each package in their respective directories:
+Running `npx aicm install` will install rules for each package in their respective directories:
 
 - `packages/frontend/.cursor/rules/aicm/`
 - `packages/backend/.cursor/rules/aicm/`
@@ -270,8 +273,6 @@ The key becomes the base namespace for discovered files:
 
   - Preset files should contain a `rules` and `mcpServers` objects with the same structure as the main configuration.
 
-- **installOnCI**: Boolean flag (default: `false`) that controls whether installation should proceed in CI environments. When set to `true`, rules will be installed even in CI environments.
-
 ### MCP Server Installation
 
 - **Cursor**: MCP server configs are written to `.cursor/mcp.json` (see Cursor docs for latest path).
@@ -320,6 +321,8 @@ Initializes a new configuration file in your current directory.
 npx aicm init
 ```
 
+Edit this file to add your rules, presets, or other settings.
+
 ### `install`
 
 Installs all rules and MCPs configured in your `aicm.json`.
@@ -331,8 +334,7 @@ npx aicm install
 Options:
 
 - `--ci`: run in CI environments (default: `false`)
-- `--workspaces`: enable workspaces mode to discover and install configurations across multiple packages
-- `--verbose`: show detailed output during installation
+- `--verbose`: show detailed output and stack traces for debugging
 
 ## Node.js API
 
@@ -377,8 +379,7 @@ Installs rules and MCP servers based on configuration.
 - `cwd`: Base directory to use instead of `process.cwd()`
 - `config`: Custom config object to use instead of loading from file
 - `installOnCI`: Run installation on CI environments (default: `false`)
-- `workspaces`: Enable workspaces mode (default: `false`)
-- `verbose`: Show verbose output during installation (default: `false`)
+- `verbose`: Show verbose output and stack traces for debugging (default: `false`)
 
 **Returns:**
 

package/dist/api.d.ts

@@ -1,4 +1,4 @@
-import { InstallOptions, InstallResult } from "./commands/install";
+import { InstallOptions, InstallResult } from "./commands/install/install-package";
 /**
  * Install AICM rules based on configuration
  * @param options Installation options

package/dist/bin/aicm.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/aicm.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cli_1 = require("../cli");
+(0, cli_1.runCli)();

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function runCli(): Promise<void>;

package/dist/cli.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const arg_1 = __importDefault(require("arg"));
+const chalk_1 = __importDefault(require("chalk"));
+const init_1 = require("./commands/init");
+const install_1 = require("./commands/install");
+const list_1 = require("./commands/list");
+// Define version from package.json
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const pkg = require("../package.json");
+async function runCli() {
+    const args = (0, arg_1.default)({
+        "--help": Boolean,
+        "--version": Boolean,
+        "--ci": Boolean,
+        "--verbose": Boolean,
+        "-h": "--help",
+        "-v": "--version",
+    }, {
+        permissive: true,
+        argv: process.argv.slice(2),
+    });
+    // Show version
+    if (args["--version"]) {
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    // Show help
+    if (args["--help"]) {
+        showHelp();
+        process.exit(0);
+    }
+    const command = args._.length > 0 ? args._[0] : null;
+    try {
+        switch (command) {
+            case "init":
+                (0, init_1.initCommand)();
+                break;
+            case "install":
+                await (0, install_1.installCommand)(args["--ci"], args["--verbose"]);
+                break;
+            case "list":
+                await (0, list_1.listCommand)();
+                break;
+            default:
+                showHelp();
+                break;
+        }
+    }
+    catch (error) {
+        logError(error, args["--verbose"]);
+        process.exit(1);
+    }
+}
+function showHelp() {
+    console.log(`
+${chalk_1.default.bold("aicm")} - A CLI tool for managing AI IDE configurations
+
+${chalk_1.default.bold("USAGE")}
+  $ aicm [command] [options]
+
+${chalk_1.default.bold("COMMANDS")}
+  init                Initialize a new aicm configuration file
+  install             Install rules from configured sources
+  list                List all configured rules and their status
+
+${chalk_1.default.bold("OPTIONS")}
+  -h, --help          Show this help message
+  -v, --version       Show version number
+  --ci                Run in CI environments (default: \`false\`)
+  --verbose           Show detailed output and stack traces for debugging
+
+${chalk_1.default.bold("EXAMPLES")}
+  $ aicm init
+  $ aicm install
+  $ aicm list
+`);
+}
+function logError(error, verbose = false) {
+    if (verbose && error instanceof Error && error.stack) {
+        console.error(chalk_1.default.red(error.stack));
+    }
+    else {
+        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
+    }
+}

package/dist/commands/init.js

@@ -8,10 +8,7 @@ const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
 const defaultConfig = {
-    ides: ["cursor"],
     rules: {},
-    mcpServers: {},
-    installOnCI: false,
 };
 function initCommand() {
     const configPath = path_1.default.join(process.cwd(), "aicm.json");

package/dist/commands/install/install-package.d.ts

@@ -0,0 +1,53 @@
+import { NormalizedConfig } from "../../types";
+/**
+ * Options for the install functions
+ */
+export interface InstallOptions {
+    /**
+     * Base directory to use instead of process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Custom config object to use instead of loading from file
+     */
+    config?: NormalizedConfig;
+    /**
+     * allow installation on CI environments
+     */
+    installOnCI?: boolean;
+    /**
+     * Show verbose output during installation
+     */
+    verbose?: boolean;
+}
+/**
+ * Result of the install operation
+ */
+export interface InstallResult {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Error message if the operation failed
+     */
+    error?: string;
+    /**
+     * Error stack trace for debugging (when available)
+     */
+    errorStack?: string;
+    /**
+     * Number of rules installed
+     */
+    installedRuleCount: number;
+    /**
+     * Number of packages installed
+     */
+    packagesCount: number;
+}
+/**
+ * Install rules for a single package (used within workspaces and standalone installs)
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+export declare function installPackage(options?: InstallOptions): Promise<InstallResult>;

package/dist/commands/install/install-package.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPackage = installPackage;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../../utils/config");
+const rule_detector_1 = require("../../utils/rule-detector");
+const working_directory_1 = require("../../utils/working-directory");
+const rule_collector_1 = require("../../utils/rule-collector");
+const rule_writer_1 = require("../../utils/rule-writer");
+const mcp_writer_1 = require("../../utils/mcp-writer");
+const glob_handler_1 = require("../../utils/glob-handler");
+/**
+ * Install rules for a single package (used within workspaces and standalone installs)
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+async function installPackage(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        const config = options.config || (await (0, config_1.getConfig)());
+        const ruleCollection = (0, rule_collector_1.initRuleCollection)();
+        if (!config) {
+            return {
+                success: false,
+                error: "Configuration file not found",
+                installedRuleCount: 0,
+                packagesCount: 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) {
+                return {
+                    success: false,
+                    error: "No rules defined in configuration",
+                    installedRuleCount: 0,
+                    packagesCount: 0,
+                };
+            }
+        }
+        let expandedRules;
+        try {
+            const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(config.rules, cwd);
+            expandedRules = expansion.expandedRules;
+            if (options.verbose) {
+                for (const [expandedKey, originalPattern] of Object.entries(expansion.globSources)) {
+                    console.log(chalk_1.default.gray(`  Pattern "${originalPattern}" → ${expandedKey}`));
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = `Error expanding glob patterns: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                success: false,
+                error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+        let hasErrors = false;
+        const errorMessages = [];
+        let firstErrorStack;
+        let installedRuleCount = 0;
+        for (const [name, source] of Object.entries(expandedRules)) {
+            const ruleType = (0, rule_detector_1.detectRuleType)(source);
+            const ruleBasePath = (0, config_1.getRuleSource)(config, name);
+            const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
+            try {
+                let ruleContent;
+                switch (ruleType) {
+                    case "npm":
+                        ruleContent = (0, rule_collector_1.collectNpmRule)(name, source);
+                        break;
+                    case "local":
+                        ruleContent = (0, rule_collector_1.collectLocalRule)(name, source, ruleBasePath);
+                        break;
+                    default:
+                        errorMessages.push(`Unknown rule type: ${ruleType}`);
+                        continue;
+                }
+                if (originalPresetPath) {
+                    ruleContent.presetPath = originalPresetPath;
+                }
+                (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
+                installedRuleCount++;
+            }
+            catch (e) {
+                hasErrors = true;
+                const errorMessage = `Error processing rule ${name}: ${e instanceof Error ? e.message : String(e)}`;
+                errorMessages.push(errorMessage);
+                // Keep the first error stack trace
+                if (!firstErrorStack && e instanceof Error && e.stack) {
+                    firstErrorStack = e.stack;
+                }
+            }
+        }
+        if (hasErrors) {
+            return {
+                success: false,
+                error: errorMessages.join("; "),
+                errorStack: firstErrorStack,
+                installedRuleCount,
+                packagesCount: 0,
+            };
+        }
+        (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
+        if (config.mcpServers) {
+            const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
+            (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
+        }
+        return {
+            success: true,
+            installedRuleCount,
+            packagesCount: 1,
+        };
+    });
+}

package/dist/commands/install/install-single-package.d.ts

@@ -0,0 +1,53 @@
+import { NormalizedConfig } from "../../types";
+/**
+ * Options for the install functions
+ */
+export interface InstallOptions {
+    /**
+     * Base directory to use instead of process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Custom config object to use instead of loading from file
+     */
+    config?: NormalizedConfig;
+    /**
+     * allow installation on CI environments
+     */
+    installOnCI?: boolean;
+    /**
+     * Show verbose output during installation
+     */
+    verbose?: boolean;
+}
+/**
+ * Result of the install operation
+ */
+export interface InstallResult {
+    /**
+     * Whether the operation was successful
+     */
+    success: boolean;
+    /**
+     * Error message if the operation failed
+     */
+    error?: string;
+    /**
+     * Error stack trace for debugging (when available)
+     */
+    errorStack?: string;
+    /**
+     * Number of rules installed
+     */
+    installedRuleCount: number;
+    /**
+     * Number of packages installed
+     */
+    packagesCount: number;
+}
+/**
+ * Core single package installation logic
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+export declare function installSinglePackage(options?: InstallOptions): Promise<InstallResult>;

package/dist/commands/install/install-single-package.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installSinglePackage = installSinglePackage;
+const chalk_1 = __importDefault(require("chalk"));
+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 mcp_writer_1 = require("../../utils/mcp-writer");
+const glob_handler_1 = require("../../utils/glob-handler");
+/**
+ * Helper function to execute a function within a specific working directory
+ * and ensure the original directory is always restored
+ */
+async function withWorkingDirectory(targetDir, fn) {
+    const originalCwd = process.cwd();
+    if (targetDir !== originalCwd) {
+        process.chdir(targetDir);
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        if (targetDir !== originalCwd) {
+            process.chdir(originalCwd);
+        }
+    }
+}
+/**
+ * Core single package installation logic
+ * @param options Install options
+ * @returns Result of the install operation
+ */
+async function installSinglePackage(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    return withWorkingDirectory(cwd, async () => {
+        const config = options.config || (0, config_1.getConfig)();
+        const ruleCollection = (0, rule_collector_1.initRuleCollection)();
+        if (!config) {
+            return {
+                success: false,
+                error: "Configuration file not found",
+                installedRuleCount: 0,
+                packagesCount: 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) {
+                return {
+                    success: false,
+                    error: "No rules defined in configuration",
+                    installedRuleCount: 0,
+                    packagesCount: 0,
+                };
+            }
+        }
+        let expandedRules;
+        try {
+            const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(config.rules, cwd);
+            expandedRules = expansion.expandedRules;
+            if (options.verbose) {
+                for (const [expandedKey, originalPattern] of Object.entries(expansion.globSources)) {
+                    console.log(chalk_1.default.gray(`  Pattern "${originalPattern}" → ${expandedKey}`));
+                }
+            }
+        }
+        catch (error) {
+            const errorMessage = `Error expanding glob patterns: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                success: false,
+                error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+        let hasErrors = false;
+        const errorMessages = [];
+        let firstErrorStack;
+        let installedRuleCount = 0;
+        for (const [name, source] of Object.entries(expandedRules)) {
+            const ruleType = (0, rule_detector_1.detectRuleType)(source);
+            const ruleBasePath = (0, config_1.getRuleSource)(config, name);
+            const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
+            try {
+                let ruleContent;
+                switch (ruleType) {
+                    case "npm":
+                        ruleContent = (0, rule_collector_1.collectNpmRule)(name, source);
+                        break;
+                    case "local":
+                        ruleContent = (0, rule_collector_1.collectLocalRule)(name, source, ruleBasePath);
+                        break;
+                    default:
+                        errorMessages.push(`Unknown rule type: ${ruleType}`);
+                        continue;
+                }
+                if (originalPresetPath) {
+                    ruleContent.presetPath = originalPresetPath;
+                }
+                (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
+                installedRuleCount++;
+            }
+            catch (e) {
+                hasErrors = true;
+                const errorMessage = `Error processing rule ${name}: ${e instanceof Error ? e.message : String(e)}`;
+                errorMessages.push(errorMessage);
+                // Keep the first error stack trace
+                if (!firstErrorStack && e instanceof Error && e.stack) {
+                    firstErrorStack = e.stack;
+                }
+            }
+        }
+        if (hasErrors) {
+            return {
+                success: false,
+                error: errorMessages.join("; "),
+                errorStack: firstErrorStack,
+                installedRuleCount,
+                packagesCount: 0,
+            };
+        }
+        (0, rule_writer_1.writeRulesToTargets)(ruleCollection);
+        if (config.mcpServers) {
+            const filteredMcpServers = Object.fromEntries(Object.entries(config.mcpServers).filter(([, v]) => v !== false));
+            (0, mcp_writer_1.writeMcpServersToTargets)(filteredMcpServers, config.ides, cwd);
+        }
+        return {
+            success: true,
+            installedRuleCount,
+            packagesCount: 1,
+        };
+    });
+}

package/dist/commands/install/install-workspaces.d.ts

@@ -0,0 +1,9 @@
+import { InstallResult } from "./install-package";
+/**
+ * Install rules across multiple packages in a workspace
+ * @param cwd The current working directory
+ * @param installOnCI Whether to install on CI environments
+ * @param verbose Whether to show verbose output
+ * @returns Result of the install operation
+ */
+export declare function installWorkspaces(cwd: string, installOnCI: boolean, verbose?: boolean): Promise<InstallResult>;