aicm 0.7.0 → 0.9.0

package/README.md

@@ -37,12 +37,12 @@ In your project's `aicm.json`, reference the package and the specific rule:
 }
 ```
 
-2. **Add a postinstall script** to your `package.json`:
+2. **Add a prepare script** to your `package.json`:
 
 ```json
 {
   "scripts": {
-    "postinstall": "npx -y aicm install"
+    "prepare": "npx -y aicm install"
   }
 }
 ```
@@ -192,6 +192,8 @@ Example `aicm.json`:
 
   - 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).
@@ -247,6 +249,10 @@ Installs all rules and MCPs configured in your `aicm.json`.
 npx aicm install
 ```
 
+Options:
+
+- `--ci`: run in CI environments (default: `false`)
+
 ## Node.js API
 
 In addition to the CLI, aicm can be used programmatically in Node.js applications:
@@ -289,6 +295,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`)
 
 **Returns:**
 

package/dist/api.d.ts

@@ -1,7 +1,7 @@
 import { InstallOptions, InstallResult } from "./commands/install";
 /**
  * Install AICM rules based on configuration
- * @param options Install options
+ * @param options Installation options
  * @returns Result of the install operation
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;

package/dist/api.js

@@ -4,7 +4,7 @@ exports.install = install;
 const install_1 = require("./commands/install");
 /**
  * Install AICM rules based on configuration
- * @param options Install options
+ * @param options Installation options
  * @returns Result of the install operation
  */
 async function install(options = {}) {

package/dist/commands/init.js

@@ -11,6 +11,7 @@ const defaultConfig = {
     ides: ["cursor"],
     rules: {},
     mcpServers: {},
+    installOnCI: false,
 };
 function initCommand() {
     const configPath = path_1.default.join(process.cwd(), "aicm.json");

package/dist/commands/install.d.ts

@@ -11,6 +11,10 @@ export interface InstallOptions {
      * Custom config object to use instead of loading from file
      */
     config?: Config;
+    /**
+     * allow installation on CI environments
+     */
+    installOnCI?: boolean;
 }
 /**
  * Result of the install operation
@@ -35,4 +39,4 @@ export interface InstallResult {
  * @returns Result of the install operation
  */
 export declare function install(options?: InstallOptions): Promise<InstallResult>;
-export declare function installCommand(): Promise<void>;
+export declare function installCommand(installOnCI?: boolean): Promise<void>;

package/dist/commands/install.js

@@ -12,6 +12,7 @@ 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"));
+const ci_info_1 = require("ci-info");
 /**
  * Write MCP servers configuration to IDE targets
  * @param mcpServers The MCP servers configuration
@@ -33,6 +34,19 @@ function writeMcpServersToTargets(mcpServers, ides, cwd) {
         }
     }
 }
+/**
+ * Checks if the current environment is a CI environment
+ * This function respects any explicit settings in process.env.CI
+ */
+function isInCIEnvironment() {
+    // Explicit environment variable settings take precedence
+    if (process.env.CI === "true")
+        return true;
+    if (process.env.CI === "false")
+        return false;
+    // Fall back to ci-info's detection
+    return ci_info_1.isCI;
+}
 /**
  * Core implementation of the rule installation logic
  * @param options Install options
@@ -40,6 +54,7 @@ function writeMcpServersToTargets(mcpServers, ides, cwd) {
  */
 async function install(options = {}) {
     const cwd = options.cwd || process.cwd();
+    const installOnCI = options.installOnCI === true; // Default to false if not specified
     try {
         const originalCwd = process.cwd();
         if (cwd !== originalCwd) {
@@ -57,6 +72,17 @@ async function install(options = {}) {
                 installedRuleCount: 0,
             };
         }
+        const inCI = isInCIEnvironment();
+        if (inCI && !installOnCI && !config.installOnCI) {
+            if (cwd !== originalCwd) {
+                process.chdir(originalCwd);
+            }
+            console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
+            return {
+                success: true,
+                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
@@ -82,6 +108,8 @@ async function install(options = {}) {
             const ruleType = (0, rule_detector_1.detectRuleType)(source);
             // Get the base path of the preset file if this rule came from a preset
             const ruleBasePath = (0, config_1.getRuleSource)(config, name);
+            // Get the original preset path for namespacing
+            const originalPresetPath = (0, config_1.getOriginalPresetPath)(config, name);
             // Collect the rule based on its type
             try {
                 let ruleContent;
@@ -96,6 +124,10 @@ async function install(options = {}) {
                         errorMessages.push(`Unknown rule type: ${ruleType}`);
                         continue;
                 }
+                // Add the preset path to the rule content for namespacing
+                if (originalPresetPath) {
+                    ruleContent.presetPath = originalPresetPath;
+                }
                 (0, rule_collector_1.addRuleToCollection)(ruleCollection, ruleContent, config.ides);
                 installedRuleCount++;
             }
@@ -146,9 +178,9 @@ async function install(options = {}) {
         };
     }
 }
-async function installCommand() {
+async function installCommand(installOnCI) {
     try {
-        const result = await install();
+        const result = await install({ installOnCI });
         if (!result.success) {
             console.error(chalk_1.default.red(result.error));
             process.exit(1);

package/dist/index.js

@@ -16,6 +16,7 @@ const pkg = require("../package.json");
 const args = (0, arg_1.default)({
     "--help": Boolean,
     "--version": Boolean,
+    "--ci": Boolean,
     "-h": "--help",
     "-v": "--version",
 }, {
@@ -35,7 +36,7 @@ switch (command) {
         (0, init_1.initCommand)();
         break;
     case "install":
-        (0, install_1.installCommand)();
+        (0, install_1.installCommand)(args["--ci"]);
         break;
     case "list":
         (0, list_1.listCommand)();
@@ -60,6 +61,7 @@ ${chalk_1.default.bold("COMMANDS")}
 ${chalk_1.default.bold("OPTIONS")}
   -h, --help          Show this help message
   -v, --version       Show version number
+  --ci                Run in CI environments (default: \`false\`)
 
 ${chalk_1.default.bold("EXAMPLES")}
   $ aicm init

package/dist/types/index.d.ts

@@ -21,6 +21,7 @@ export interface Config {
     rules: Rules;
     presets?: string[];
     mcpServers?: MCPServers;
+    installOnCI?: boolean;
 }
 export interface RuleMetadata {
     type?: string;
@@ -34,6 +35,7 @@ export interface RuleContent {
     content: string;
     metadata: RuleMetadata;
     sourcePath: string;
+    presetPath?: string;
 }
 export interface RuleCollection {
     cursor: RuleContent[];

package/dist/utils/config.d.ts

@@ -1,8 +1,13 @@
 import { Config, Rules } from "../types";
 interface ConfigWithMeta extends Config {
     __ruleSources?: Record<string, string>;
+    __originalPresetPaths?: Record<string, string>;
 }
-export declare function getFullPresetPath(presetPath: string): string | null;
+export interface PresetPathInfo {
+    fullPath: string;
+    originalPath: string;
+}
+export declare function getFullPresetPath(presetPath: string): PresetPathInfo | null;
 /**
  * Load a preset file and return its rules and mcpServers
  */
@@ -23,6 +28,10 @@ export declare function getConfig(): Config | null;
  * Get the source preset path for a rule if it came from a preset
  */
 export declare function getRuleSource(config: Config, ruleName: string): string | undefined;
+/**
+ * Get the original preset path for a rule if it came from a preset
+ */
+export declare function getOriginalPresetPath(config: Config, ruleName: string): string | undefined;
 /**
  * Save the configuration to the aicm.json file
  */

package/dist/utils/config.js

@@ -8,6 +8,7 @@ exports.loadPreset = loadPreset;
 exports.loadAicmConfigCosmiconfig = loadAicmConfigCosmiconfig;
 exports.getConfig = getConfig;
 exports.getRuleSource = getRuleSource;
+exports.getOriginalPresetPath = getOriginalPresetPath;
 exports.saveConfig = saveConfig;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const node_path_1 = __importDefault(require("node:path"));
@@ -15,7 +16,7 @@ const cosmiconfig_1 = require("cosmiconfig");
 const CONFIG_FILE = "aicm.json";
 function getFullPresetPath(presetPath) {
     if (presetPath.endsWith(".json") && fs_extra_1.default.pathExistsSync(presetPath)) {
-        return presetPath;
+        return { fullPath: presetPath, originalPath: presetPath };
     }
     try {
         let absolutePresetPath;
@@ -30,7 +31,9 @@ function getFullPresetPath(presetPath) {
                 paths: [__dirname, process.cwd()],
             });
         }
-        return fs_extra_1.default.existsSync(absolutePresetPath) ? absolutePresetPath : null;
+        return fs_extra_1.default.existsSync(absolutePresetPath)
+            ? { fullPath: absolutePresetPath, originalPath: presetPath }
+            : null;
     }
     catch (_a) {
         return null;
@@ -40,11 +43,11 @@ function getFullPresetPath(presetPath) {
  * Load a preset file and return its rules and mcpServers
  */
 function loadPreset(presetPath) {
-    const fullPresetPath = getFullPresetPath(presetPath);
-    if (!fullPresetPath) {
+    const pathInfo = getFullPresetPath(presetPath);
+    if (!pathInfo) {
         throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
     }
-    const presetContent = fs_extra_1.default.readFileSync(fullPresetPath, "utf8");
+    const presetContent = fs_extra_1.default.readFileSync(pathInfo.fullPath, "utf8");
     let preset;
     try {
         preset = JSON.parse(presetContent);
@@ -69,10 +72,10 @@ function processPresets(config) {
         const preset = loadPreset(presetPath);
         if (!preset)
             continue;
-        const fullPresetPath = getFullPresetPath(presetPath);
-        if (!fullPresetPath)
+        const pathInfo = getFullPresetPath(presetPath);
+        if (!pathInfo)
             continue;
-        mergePresetRules(config, preset.rules, fullPresetPath);
+        mergePresetRules(config, preset.rules, pathInfo);
         if (preset.mcpServers) {
             mergePresetMcpServers(config, preset.mcpServers);
         }
@@ -81,7 +84,7 @@ function processPresets(config) {
 /**
  * Merge preset rules into the config
  */
-function mergePresetRules(config, presetRules, presetPath) {
+function mergePresetRules(config, presetRules, pathInfo) {
     for (const [ruleName, rulePath] of Object.entries(presetRules)) {
         // Cancel if set to false in config
         if (Object.prototype.hasOwnProperty.call(config.rules, ruleName) &&
@@ -89,13 +92,17 @@ function mergePresetRules(config, presetRules, presetPath) {
             delete config.rules[ruleName];
             if (config.__ruleSources)
                 delete config.__ruleSources[ruleName];
+            if (config.__originalPresetPaths)
+                delete config.__originalPresetPaths[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;
             config.__ruleSources = config.__ruleSources || {};
-            config.__ruleSources[ruleName] = presetPath;
+            config.__ruleSources[ruleName] = pathInfo.fullPath;
+            config.__originalPresetPaths = config.__originalPresetPaths || {};
+            config.__originalPresetPaths[ruleName] = pathInfo.originalPath;
         }
     }
 }
@@ -159,6 +166,13 @@ function getRuleSource(config, ruleName) {
     var _a;
     return (_a = config.__ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
 }
+/**
+ * Get the original preset path for a rule if it came from a preset
+ */
+function getOriginalPresetPath(config, ruleName) {
+    var _a;
+    return (_a = config.__originalPresetPaths) === null || _a === void 0 ? void 0 : _a[ruleName];
+}
 /**
  * Save the configuration to the aicm.json file
  */

package/dist/utils/rule-writer.js

@@ -23,6 +23,21 @@ function writeRulesToTargets(collection) {
         writeWindsurfRulesFromCollection(collection.windsurf, idePaths.windsurf);
     }
 }
+/**
+ * Extract a normalized namespace from a preset path
+ * @param presetPath The original preset path
+ * @returns An array of path segments to use for namespacing
+ */
+function extractNamespaceFromPresetPath(presetPath) {
+    // Special case: npm package names always use forward slashes, regardless of platform
+    if (presetPath.startsWith("@")) {
+        // For scoped packages like @scope/package/subdir, create nested directories
+        return presetPath.split("/");
+    }
+    // Handle both Unix and Windows style path separators
+    const parts = presetPath.split(/[/\\]/);
+    return parts.filter((part) => part.length > 0); // Filter out empty segments
+}
 /**
  * Write rules to Cursor's rules directory
  * @param rules The rules to write
@@ -31,7 +46,20 @@ function writeRulesToTargets(collection) {
 function writeCursorRules(rules, cursorRulesDir) {
     fs_extra_1.default.emptyDirSync(cursorRulesDir);
     for (const rule of rules) {
-        const ruleFile = node_path_1.default.join(cursorRulesDir, ...rule.name.split("/")) + ".mdc";
+        let rulePath;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        if (rule.presetPath) {
+            // For rules from presets, create a namespaced directory structure
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            // Path will be: cursorRulesDir/namespace/rule-name.mdc
+            rulePath = node_path_1.default.join(cursorRulesDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            // For local rules, maintain the original flat structure
+            rulePath = node_path_1.default.join(cursorRulesDir, ...ruleNameParts);
+        }
+        const ruleFile = rulePath + ".mdc";
         fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(ruleFile));
         if (fs_extra_1.default.existsSync(rule.sourcePath)) {
             fs_extra_1.default.copyFileSync(rule.sourcePath, ruleFile);
@@ -49,11 +77,33 @@ function writeCursorRules(rules, cursorRulesDir) {
 function writeWindsurfRulesFromCollection(rules, ruleDir) {
     fs_extra_1.default.emptyDirSync(ruleDir);
     const ruleFiles = rules.map((rule) => {
-        const physicalRulePath = node_path_1.default.join(ruleDir, ...rule.name.split("/")) + ".md";
+        let rulePath;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        if (rule.presetPath) {
+            // For rules from presets, create a namespaced directory structure
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            // Path will be: ruleDir/namespace/rule-name.md
+            rulePath = node_path_1.default.join(ruleDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            // For local rules, maintain the original flat structure
+            rulePath = node_path_1.default.join(ruleDir, ...ruleNameParts);
+        }
+        const physicalRulePath = rulePath + ".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";
+        // For the Windsurf rules file, we need to maintain the same structure
+        let windsurfPath;
+        if (rule.presetPath) {
+            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
+            windsurfPath =
+                node_path_1.default.join(relativeRuleDir, ...namespace, ...ruleNameParts) + ".md";
+        }
+        else {
+            windsurfPath = node_path_1.default.join(relativeRuleDir, ...ruleNameParts) + ".md";
+        }
         // Normalize to POSIX style for cross-platform compatibility in .windsurfrules
         const windsurfPathPosix = windsurfPath.replace(/\\/g, "/");
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.7.0",
+  "version": "0.9.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",
@@ -41,6 +41,7 @@
     "arg": "^5.0.2",
     "args": "^5.0.3",
     "chalk": "^4.1.2",
+    "ci-info": "^4.2.0",
     "cosmiconfig": "^9.0.0",
     "fs-extra": "^11.1.1"
   },