aicm 0.13.0 → 0.14.0

package/dist/commands/install_new.js

@@ -0,0 +1,457 @@
+"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;
+exports.install = install;
+exports.installCommand = installCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const child_process_1 = require("child_process");
+const ci_info_1 = require("ci-info");
+const config_v2_1 = require("../utils/config_v2");
+const working_directory_1 = require("../utils/working-directory");
+function isInCIEnvironment() {
+    if (process.env.CI === "true")
+        return true;
+    if (process.env.CI === "false")
+        return false;
+    return ci_info_1.isCI;
+}
+function getIdePaths() {
+    const projectDir = process.cwd();
+    return {
+        cursor: node_path_1.default.join(projectDir, ".cursor", "rules", "aicm"),
+        windsurf: node_path_1.default.join(projectDir, ".aicm"),
+        codex: node_path_1.default.join(projectDir, ".aicm"),
+    };
+}
+function extractNamespaceFromPresetPath(presetPath) {
+    if (presetPath.startsWith("@")) {
+        return presetPath.split("/");
+    }
+    const parts = presetPath.split(/[/\\]/);
+    return parts.filter((part) => part.length > 0);
+}
+function writeCursorRules(rules, cursorRulesDir) {
+    fs_extra_1.default.emptyDirSync(cursorRulesDir);
+    for (const rule of rules) {
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        let rulePath;
+        if (rule.presetName) {
+            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            rulePath = node_path_1.default.join(cursorRulesDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            rulePath = node_path_1.default.join(cursorRulesDir, ...ruleNameParts);
+        }
+        const ruleFile = rulePath + ".mdc";
+        fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(ruleFile));
+        fs_extra_1.default.writeFileSync(ruleFile, rule.content);
+    }
+}
+function generateRulesFileContent(ruleFiles) {
+    const alwaysApplyRules = [];
+    const optInRules = [];
+    for (const rule of ruleFiles) {
+        const frontmatterMatch = rule.content.match(/^---\n([\s\S]*?)\n---/);
+        let alwaysApply = false;
+        if (frontmatterMatch) {
+            try {
+                const frontmatter = frontmatterMatch[1];
+                const alwaysApplyMatch = frontmatter.match(/alwaysApply:\s*(true|false)/);
+                if (alwaysApplyMatch) {
+                    alwaysApply = alwaysApplyMatch[1] === "true";
+                }
+            }
+            catch (_a) {
+                // If parsing fails, default to false
+            }
+        }
+        if (alwaysApply) {
+            alwaysApplyRules.push(`- ${rule.path}`);
+        }
+        else {
+            optInRules.push(`- ${rule.path}`);
+        }
+    }
+    let content = "<!-- AICM:BEGIN -->\n";
+    content +=
+        "<!-- WARNING: Everything between these markers will be overwritten during installation -->\n\n";
+    if (alwaysApplyRules.length > 0) {
+        content +=
+            "The following rules always apply to all files in the project:\n";
+        content += alwaysApplyRules.join("\n") + "\n\n";
+    }
+    if (optInRules.length > 0) {
+        content +=
+            "The following rules are available for the AI to include when needed:\n";
+        content += optInRules.join("\n") + "\n\n";
+    }
+    content += "<!-- AICM:END -->";
+    return content;
+}
+function writeRulesFile(rulesContent, rulesFilePath) {
+    const RULES_BEGIN = "<!-- AICM:BEGIN -->";
+    const RULES_END = "<!-- AICM:END -->";
+    let fileContent;
+    if (fs_extra_1.default.existsSync(rulesFilePath)) {
+        const existingContent = fs_extra_1.default.readFileSync(rulesFilePath, "utf8");
+        if (existingContent.includes(RULES_BEGIN) &&
+            existingContent.includes(RULES_END)) {
+            const beforeMarker = existingContent.split(RULES_BEGIN)[0];
+            const afterMarker = existingContent.split(RULES_END)[1];
+            fileContent = beforeMarker + rulesContent + afterMarker;
+        }
+        else {
+            let separator = "";
+            if (!existingContent.endsWith("\n")) {
+                separator += "\n";
+            }
+            if (!existingContent.endsWith("\n\n")) {
+                separator += "\n";
+            }
+            fileContent = existingContent + separator + rulesContent;
+        }
+    }
+    else {
+        fileContent = rulesContent;
+    }
+    fs_extra_1.default.writeFileSync(rulesFilePath, fileContent);
+}
+function writeRulesForFile(rules, ruleDir, rulesFile) {
+    fs_extra_1.default.emptyDirSync(ruleDir);
+    const ruleFiles = rules.map((rule) => {
+        const ruleNameParts = rule.name.split(/[/\\]/).filter(Boolean);
+        let rulePath;
+        if (rule.presetName) {
+            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            rulePath = node_path_1.default.join(ruleDir, ...namespace, ...ruleNameParts);
+        }
+        else {
+            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);
+        let windsurfPath;
+        if (rule.presetName) {
+            const namespace = extractNamespaceFromPresetPath(rule.presetName);
+            windsurfPath =
+                node_path_1.default.join(relativeRuleDir, ...namespace, ...ruleNameParts) + ".md";
+        }
+        else {
+            windsurfPath = node_path_1.default.join(relativeRuleDir, ...ruleNameParts) + ".md";
+        }
+        const windsurfPathPosix = windsurfPath.replace(/\\/g, "/");
+        return {
+            name: rule.name,
+            path: windsurfPathPosix,
+            content: rule.content,
+        };
+    });
+    const rulesContent = generateRulesFileContent(ruleFiles);
+    writeRulesFile(rulesContent, node_path_1.default.join(process.cwd(), rulesFile));
+}
+function writeRulesToTargets(rules, targets) {
+    const idePaths = getIdePaths();
+    for (const target of targets) {
+        switch (target) {
+            case "cursor":
+                if (rules.length > 0) {
+                    writeCursorRules(rules, idePaths.cursor);
+                }
+                break;
+            case "windsurf":
+                if (rules.length > 0) {
+                    writeRulesForFile(rules, idePaths.windsurf, ".windsurfrules");
+                }
+                break;
+            case "codex":
+                if (rules.length > 0) {
+                    writeRulesForFile(rules, idePaths.codex, "AGENTS.md");
+                }
+                break;
+        }
+    }
+}
+function writeMcpServersToFile(mcpServers, mcpPath) {
+    var _a;
+    fs_extra_1.default.ensureDirSync(node_path_1.default.dirname(mcpPath));
+    const existingConfig = fs_extra_1.default.existsSync(mcpPath)
+        ? fs_extra_1.default.readJsonSync(mcpPath)
+        : {};
+    const existingMcpServers = (_a = existingConfig === null || existingConfig === void 0 ? void 0 : existingConfig.mcpServers) !== null && _a !== void 0 ? _a : {};
+    const userMcpServers = {};
+    for (const [key, value] of Object.entries(existingMcpServers)) {
+        if (typeof value === "object" && value !== null && value.aicm !== true) {
+            userMcpServers[key] = value;
+        }
+    }
+    const aicmMcpServers = {};
+    for (const [key, value] of Object.entries(mcpServers)) {
+        if (value !== false) {
+            aicmMcpServers[key] = {
+                ...value,
+                aicm: true,
+            };
+        }
+    }
+    const mergedMcpServers = {
+        ...userMcpServers,
+        ...aicmMcpServers,
+    };
+    const mergedConfig = {
+        ...existingConfig,
+        mcpServers: mergedMcpServers,
+    };
+    fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
+}
+function writeMcpServersToTargets(mcpServers, targets, cwd) {
+    if (!mcpServers || Object.keys(mcpServers).length === 0)
+        return;
+    for (const target of targets) {
+        if (target === "cursor") {
+            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
+            writeMcpServersToFile(mcpServers, mcpPath);
+        }
+    }
+}
+function findAicmFiles(rootDir) {
+    try {
+        const output = (0, 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));
+    }
+    catch (_a) {
+        return [];
+    }
+}
+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);
+        const normalizedRelativePath = relativePath.replace(/\\/g, "/");
+        const config = await (0, config_v2_1.loadConfig)(packageDir);
+        if (config) {
+            packages.push({
+                relativePath: normalizedRelativePath || ".",
+                absolutePath: packageDir,
+                config,
+            });
+        }
+    }
+    return packages.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+async function installPackage(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        let resolvedConfig;
+        if (options.config) {
+            resolvedConfig = options.config;
+        }
+        else {
+            resolvedConfig = await (0, config_v2_1.loadConfig)(cwd);
+        }
+        if (!resolvedConfig) {
+            return {
+                success: false,
+                error: "Configuration file not found",
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+        const { config, rules, mcpServers } = resolvedConfig;
+        if (!rules || rules.length === 0) {
+            if (!config.presets || config.presets.length === 0) {
+                return {
+                    success: false,
+                    error: "No rules defined in configuration",
+                    installedRuleCount: 0,
+                    packagesCount: 0,
+                };
+            }
+        }
+        try {
+            writeRulesToTargets(rules, config.targets);
+            if (mcpServers && Object.keys(mcpServers).length > 0) {
+                writeMcpServersToTargets(mcpServers, config.targets, cwd);
+            }
+            return {
+                success: true,
+                installedRuleCount: rules.length,
+                packagesCount: 1,
+            };
+        }
+        catch (error) {
+            const errorMessage = `Error during installation: ${error instanceof Error ? error.message : String(error)}`;
+            return {
+                success: false,
+                error: errorMessage,
+                errorStack: error instanceof Error ? error.stack : undefined,
+                installedRuleCount: 0,
+                packagesCount: 0,
+            };
+        }
+    });
+}
+async function installWorkspacesPackages(packages, options = {}) {
+    const results = [];
+    let totalRuleCount = 0;
+    for (const pkg of packages) {
+        try {
+            const result = await installPackage({
+                ...options,
+                cwd: pkg.absolutePath,
+                config: pkg.config,
+            });
+            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,
+    };
+}
+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;
+            const hasRules = pkg.config.rules && pkg.config.rules.length > 0;
+            const hasPresets = pkg.config.config.presets && pkg.config.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,
+            verbose,
+        });
+        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,
+        };
+    });
+}
+async function install(options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const installOnCI = options.installOnCI === true;
+    const inCI = isInCIEnvironment();
+    if (inCI && !installOnCI) {
+        console.log(chalk_1.default.yellow("Detected CI environment, skipping install."));
+        return {
+            success: true,
+            installedRuleCount: 0,
+            packagesCount: 0,
+        };
+    }
+    return (0, working_directory_1.withWorkingDirectory)(cwd, async () => {
+        let resolvedConfig;
+        if (options.config) {
+            resolvedConfig = options.config;
+        }
+        else {
+            resolvedConfig = await (0, config_v2_1.loadConfig)(cwd);
+        }
+        if (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : resolvedConfig.config.workspaces) {
+            return await installWorkspaces(cwd, installOnCI, options.verbose);
+        }
+        return installPackage(options);
+    });
+}
+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 {
+            console.log("Rules installation completed");
+        }
+    }
+}

package/dist/commands/install_v2.d.ts

@@ -0,0 +1,52 @@
+import { ResolvedConfig } from "../utils/config_v2";
+export interface InstallOptions {
+    /**
+     * Base directory to use instead of process.cwd()
+     */
+    cwd?: string;
+    /**
+     * Custom config object to use instead of loading from file
+     */
+    config?: ResolvedConfig;
+    /**
+     * 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 object if the operation failed
+     */
+    error?: Error;
+    /**
+     * Number of rules installed
+     */
+    installedRuleCount: number;
+    /**
+     * Number of packages installed
+     */
+    packagesCount: number;
+}
+/**
+ * Install rules for a single package (used within workspaces and standalone installs)
+ */
+export declare function installPackage(options?: InstallOptions): Promise<InstallResult>;
+/**
+ * Core implementation of the rule installation logic
+ */
+export declare function install(options?: InstallOptions): Promise<InstallResult>;
+/**
+ * CLI command wrapper for install
+ */
+export declare function installCommand(installOnCI?: boolean, verbose?: boolean): Promise<void>;