aicm 0.12.2 → 0.13.0

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

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installWorkspaces = installWorkspaces;
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../../utils/config");
+const working_directory_1 = require("../../utils/working-directory");
+const install_package_1 = require("./install-package");
+/**
+ * Discover aicm.json files using git ls-files
+ * @param rootDir The root directory to search from
+ * @returns Array of aicm.json file paths
+ */
+function findAicmFiles(rootDir) {
+    const output = (0, node_child_process_1.execSync)("git ls-files --cached --others --exclude-standard aicm.json **/aicm.json", {
+        cwd: rootDir,
+        encoding: "utf8",
+    });
+    return output
+        .trim()
+        .split("\n")
+        .filter(Boolean)
+        .map((file) => node_path_1.default.resolve(rootDir, file));
+}
+/**
+ * Discover all packages with aicm configurations
+ * @param rootDir The root directory to search from
+ * @returns Array of discovered packages
+ */
+async function discoverPackagesWithAicm(rootDir) {
+    const aicmFiles = findAicmFiles(rootDir);
+    const packages = [];
+    for (const aicmFile of aicmFiles) {
+        const packageDir = node_path_1.default.dirname(aicmFile);
+        const relativePath = node_path_1.default.relative(rootDir, packageDir);
+        // Normalize to forward slashes for cross-platform compatibility
+        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+        const config = (0, config_1.getConfig)(packageDir);
+        if (config) {
+            packages.push({
+                relativePath: normalizedRelativePath || ".",
+                absolutePath: packageDir,
+                config,
+            });
+        }
+    }
+    // Sort packages by relativePath for deterministic order
+    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+/**
+ * Install aicm configurations for all packages in a workspace
+ * @param packages The packages to install configurations for
+ * @param options Install options
+ * @returns Result of the workspace installation
+ */
+async function installWorkspacesPackages(packages, options = {}) {
+    const results = [];
+    let totalRuleCount = 0;
+    // Install packages sequentially for now (can be parallelized later)
+    for (const pkg of packages) {
+        const packagePath = pkg.absolutePath;
+        try {
+            const result = await (0, install_package_1.installPackage)({
+                ...options,
+                cwd: packagePath,
+            });
+            totalRuleCount += result.installedRuleCount;
+            results.push({
+                path: pkg.relativePath,
+                success: result.success,
+                error: result.error,
+                errorStack: result.errorStack,
+                installedRuleCount: result.installedRuleCount,
+            });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            results.push({
+                path: pkg.relativePath,
+                success: false,
+                error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                installedRuleCount: 0,
+            });
+        }
+    }
+    const failedPackages = results.filter((r) => !r.success);
+    return {
+        success: failedPackages.length === 0,
+        packages: results,
+        totalRuleCount,
+    };
+}
+/**
+ * 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
+ */
+async function installWorkspaces(cwd, installOnCI, verbose = false) {
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        if (verbose) {
+            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
+        }
+        const allPackages = await discoverPackagesWithAicm(cwd);
+        const packages = allPackages.filter((pkg) => {
+            const isRoot = pkg.relativePath === ".";
+            if (!isRoot)
+                return true;
+            // For root directories, only keep if it has rules or presets
+            const hasRules = pkg.config.rules && Object.keys(pkg.config.rules).length > 0;
+            const hasPresets = pkg.config.presets && pkg.config.presets.length > 0;
+            return hasRules || hasPresets;
+        });
+        if (packages.length === 0) {
+            return {
+                success: false,
+                error: "No packages with aicm configurations found",
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+        if (verbose) {
+            console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations:`));
+            packages.forEach((pkg) => {
+                console.log(chalk_1.default.gray(`  - ${pkg.relativePath}`));
+            });
+            console.log(chalk_1.default.blue(`📦 Installing configurations...`));
+        }
+        const result = await installWorkspacesPackages(packages, {
+            installOnCI,
+        });
+        if (verbose) {
+            result.packages.forEach((pkg) => {
+                if (pkg.success) {
+                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${pkg.installedRuleCount} rules)`));
+                }
+                else {
+                    console.log(chalk_1.default.red(`❌ ${pkg.path}: ${pkg.error}`));
+                }
+            });
+        }
+        const failedPackages = result.packages.filter((r) => !r.success);
+        if (failedPackages.length > 0) {
+            console.log(chalk_1.default.yellow(`Installation completed with errors`));
+            if (verbose) {
+                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rules total)`));
+                console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
+            }
+            const errorDetails = failedPackages
+                .map((p) => `${p.path}: ${p.error}`)
+                .join("; ");
+            return {
+                success: false,
+                error: `Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`,
+                installedRuleCount: result.totalRuleCount,
+                packagesCount: result.packages.length,
+            };
+        }
+        console.log(`Successfully installed ${result.totalRuleCount} rules across ${result.packages.length} packages`);
+        return {
+            success: true,
+            installedRuleCount: result.totalRuleCount,
+            packagesCount: result.packages.length,
+        };
+    });
+}

package/dist/commands/install.d.ts

@@ -1,54 +1,8 @@
-import { NormalizedConfig } 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?: NormalizedConfig;
-    /**
-     * allow installation on CI environments
-     */
-    installOnCI?: boolean;
-    /**
-     * Enable workspaces mode
-     */
-    workspaces?: 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;
-    /**
-     * Number of rules installed
-     */
-    installedRuleCount: number;
-    /**
-     * Number of packages installed
-     */
-    packagesCount: number;
-}
+import { InstallOptions, InstallResult } from "./install/install-package";
 /**
  * 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(installOnCI?: boolean, workspaces?: boolean, verbose?: boolean): Promise<void>;
+export declare function installCommand(installOnCI?: boolean, verbose?: boolean): Promise<void>;

package/dist/commands/install.js

@@ -7,32 +7,10 @@ exports.install = install;
 exports.installCommand = installCommand;
 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 ci_info_1 = require("ci-info");
-const discovery_1 = require("./workspaces/discovery");
-const workspaces_install_1 = require("./workspaces/workspaces-install");
-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);
-        }
-    }
-}
+const working_directory_1 = require("../utils/working-directory");
+const install_package_1 = require("./install/install-package");
+const install_workspaces_1 = require("./install/install-workspaces");
 /**
  * Checks if the current environment is a CI environment
  * This function respects any explicit settings in process.env.CI
@@ -46,64 +24,6 @@ function isInCIEnvironment() {
     // Fall back to ci-info's detection
     return ci_info_1.isCI;
 }
-async function handleWorkspacesInstallation(cwd, installOnCI, verbose = false) {
-    return withWorkingDirectory(cwd, async () => {
-        if (verbose) {
-            console.log(chalk_1.default.blue("🔍 Discovering packages..."));
-        }
-        const packages = await (0, discovery_1.discoverPackagesWithAicm)(cwd);
-        if (packages.length === 0) {
-            return {
-                success: false,
-                error: "No packages with aicm configurations found",
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        if (verbose) {
-            console.log(chalk_1.default.blue(`Found ${packages.length} packages with aicm configurations:`));
-            packages.forEach((pkg) => {
-                console.log(chalk_1.default.gray(`  - ${pkg.relativePath}`));
-            });
-            console.log(chalk_1.default.blue(`📦 Installing configurations...`));
-        }
-        const result = await (0, workspaces_install_1.installWorkspacesPackages)(packages, {
-            installOnCI,
-        });
-        if (verbose) {
-            result.packages.forEach((pkg) => {
-                if (pkg.success) {
-                    console.log(chalk_1.default.green(`✅ ${pkg.path} (${pkg.installedRuleCount} rules)`));
-                }
-                else {
-                    console.log(chalk_1.default.red(`❌ ${pkg.path}: ${pkg.error}`));
-                }
-            });
-        }
-        const failedPackages = result.packages.filter((r) => !r.success);
-        if (failedPackages.length > 0) {
-            console.log(chalk_1.default.yellow(`Installation completed with errors`));
-            if (verbose) {
-                console.log(chalk_1.default.green(`Successfully installed: ${result.packages.length - failedPackages.length}/${result.packages.length} packages (${result.totalRuleCount} rules total)`));
-                console.log(chalk_1.default.red(`Failed packages: ${failedPackages.map((p) => p.path).join(", ")}`));
-            }
-            const errorDetails = failedPackages
-                .map((p) => `${p.path}: ${p.error}`)
-                .join("; ");
-            return {
-                success: false,
-                error: `Package installation failed for ${failedPackages.length} package(s): ${errorDetails}`,
-                installedRuleCount: result.totalRuleCount,
-                packagesCount: result.packages.length,
-            };
-        }
-        return {
-            success: true,
-            installedRuleCount: result.totalRuleCount,
-            packagesCount: result.packages.length,
-        };
-    });
-}
 /**
  * Core implementation of the rule installation logic
  * @param options Install options
@@ -112,132 +32,38 @@ async function handleWorkspacesInstallation(cwd, installOnCI, verbose = false) {
 async function install(options = {}) {
     const cwd = options.cwd || process.cwd();
     const installOnCI = options.installOnCI === true; // Default to false if not specified
-    return withWorkingDirectory(cwd, async () => {
-        if (options.workspaces) {
-            return await handleWorkspacesInstallation(cwd, installOnCI, options.verbose);
-        }
-        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,
-            };
-        }
-        const inCI = isInCIEnvironment();
-        if (inCI && !installOnCI && !config.installOnCI) {
-            console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
-            return {
-                success: true,
-                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) {
-            return {
-                success: false,
-                error: `Error expanding glob patterns: ${error instanceof Error ? error.message : String(error)}`,
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        let hasErrors = false;
-        const errorMessages = [];
-        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);
-            }
-        }
-        if (hasErrors) {
-            return {
-                success: false,
-                error: errorMessages.join("; "),
-                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);
-        }
+    const inCI = isInCIEnvironment();
+    if (inCI && !installOnCI) {
+        console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
         return {
             success: true,
-            installedRuleCount,
-            packagesCount: 1,
+            installedRuleCount: 0,
+            packagesCount: 0,
         };
+    }
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        const config = options.config || (0, config_1.getConfig)();
+        if (config === null || config === void 0 ? void 0 : config.workspaces) {
+            return await (0, install_workspaces_1.installWorkspaces)(cwd, installOnCI, options.verbose);
+        }
+        return (0, install_package_1.installPackage)(options);
     });
 }
-async function installCommand(installOnCI, workspaces, verbose) {
-    try {
-        const result = await install({ installOnCI, workspaces, verbose });
-        if (!result.success) {
-            console.error(chalk_1.default.red(result.error));
-            process.exit(1);
+async function installCommand(installOnCI, verbose) {
+    const result = await install({ installOnCI, verbose });
+    if (!result.success) {
+        const error = new Error(result.error);
+        if (result.errorStack) {
+            error.stack = result.errorStack;
+        }
+        throw error;
+    }
+    else {
+        if (result.packagesCount > 1) {
+            console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
         }
         else {
-            if (result.packagesCount > 1) {
-                console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
-            }
-            else if (workspaces) {
-                console.log(`Successfully installed ${result.installedRuleCount} rules across ${result.packagesCount} packages`);
-            }
-            else {
-                console.log("Rules installation completed");
-            }
+            console.log("Rules installation completed");
         }
     }
-    catch (error) {
-        console.error(chalk_1.default.red(error instanceof Error ? error.message : String(error)));
-        process.exit(1);
-    }
 }

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

@@ -24,6 +24,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 path: pkg.relativePath,
                 success: result.success,
                 error: result.error,
+                errorStack: result.errorStack,
                 installedRuleCount: result.installedRuleCount,
             });
         }
@@ -33,6 +34,7 @@ async function installWorkspacesPackages(packages, options = {}) {
                 path: pkg.relativePath,
                 success: false,
                 error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
                 installedRuleCount: 0,
             });
         }

package/dist/types/index.d.ts

@@ -21,7 +21,7 @@ export interface Config {
     rules?: Rules | string;
     presets?: string[];
     mcpServers?: MCPServers;
-    installOnCI?: boolean;
+    workspaces?: boolean;
 }
 export interface NormalizedConfig extends Omit<Config, "rules"> {
     ides: string[];
@@ -57,6 +57,7 @@ export interface WorkspacesInstallResult {
         path: string;
         success: boolean;
         error?: string;
+        errorStack?: string;
         installedRuleCount: number;
     }>;
     totalRuleCount: number;

package/dist/utils/config.js

@@ -133,7 +133,7 @@ function processPresetsInternal(config, metadata, cwd) {
         }
         // Skip if we've already processed this preset (prevents circular references)
         if (processedPresets.has(pathInfo.fullPath)) {
-            console.warn(`Skipping already processed preset: ${presetPath}`);
+            // Skip duplicates to prevent circular references
             continue;
         }
         // Mark this preset as processed

package/dist/utils/working-directory.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Helper function to execute a function within a specific working directory
+ * and ensure the original directory is always restored
+ */
+export declare function withWorkingDirectory<T>(targetDir: string, fn: () => Promise<T>): Promise<T>;

package/dist/utils/working-directory.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withWorkingDirectory = withWorkingDirectory;
+/**
+ * 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);
+        }
+    }
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "aicm",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",
   "bin": {
-    "aicm": "./dist/index.js"
+    "aicm": "./dist/bin/aicm.js"
   },
   "files": [
     "dist",
@@ -57,8 +57,8 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc --watch",
-    "start": "node dist/index.js",
-    "dev": "ts-node src/index.ts",
+    "start": "node dist/bin/aicm.js",
+    "dev": "ts-node src/bin/aicm.ts",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:all": "npm run build && npm run test",

package/dist/commands/monorepo/discovery.d.ts

@@ -1,7 +0,0 @@
-import { PackageInfo } from "../../types";
-/**
- * Discover all packages with aicm configurations in a monorepo
- * @param rootDir The root directory to search from
- * @returns Array of discovered packages
- */
-export declare function discoverPackagesWithAicm(rootDir: string): Promise<PackageInfo[]>;

package/dist/commands/monorepo/discovery.js

@@ -1,50 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.discoverPackagesWithAicm = discoverPackagesWithAicm;
-const node_path_1 = __importDefault(require("node:path"));
-const node_child_process_1 = require("node:child_process");
-const config_1 = require("../../utils/config");
-/**
- * Discover aicm.json files using git ls-files
- * @param rootDir The root directory to search from
- * @returns Array of aicm.json file paths
- */
-function findAicmFiles(rootDir) {
-    const output = (0, node_child_process_1.execSync)("git ls-files --cached --others --exclude-standard aicm.json **/aicm.json", {
-        cwd: rootDir,
-        encoding: "utf8",
-    });
-    return output
-        .trim()
-        .split("\n")
-        .filter(Boolean)
-        .map((file) => node_path_1.default.resolve(rootDir, file));
-}
-/**
- * Discover all packages with aicm configurations in a monorepo
- * @param rootDir The root directory to search from
- * @returns Array of discovered packages
- */
-async function discoverPackagesWithAicm(rootDir) {
-    const aicmFiles = findAicmFiles(rootDir);
-    const packages = [];
-    for (const aicmFile of aicmFiles) {
-        const packageDir = node_path_1.default.dirname(aicmFile);
-        const relativePath = node_path_1.default.relative(rootDir, packageDir);
-        // Normalize to forward slashes for cross-platform compatibility
-        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
-        const config = (0, config_1.getConfig)(packageDir);
-        if (config) {
-            packages.push({
-                relativePath: normalizedRelativePath || ".",
-                absolutePath: packageDir,
-                config,
-            });
-        }
-    }
-    // Sort packages by relativePath for deterministic order
-    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-}

package/dist/commands/monorepo/installer.d.ts

@@ -1,9 +0,0 @@
-import { PackageInfo, MonorepoInstallResult } from "./types";
-import { InstallOptions } from "../install";
-/**
- * Install aicm configurations for all packages in a monorepo
- * @param packages The packages to install configurations for
- * @param options Install options
- * @returns Result of the monorepo installation
- */
-export declare function installMonorepoPackages(packages: PackageInfo[], options?: InstallOptions): Promise<MonorepoInstallResult>;