aicm 0.14.4 → 0.14.5

package/dist/commands/install_v2.js

@@ -1,505 +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.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 config_v2_1 = require("../utils/config_v2");
-const working_directory_1 = require("../utils/working-directory");
-const is_ci_1 = require("../utils/is-ci");
-function getTargetPaths() {
-    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 writeCursorRules(rules, cursorRulesDir) {
-    fs_extra_1.default.emptyDirSync(cursorRulesDir);
-    for (const rule of rules) {
-        let rulePath;
-        const ruleNameParts = rule.name.split(node_path_1.default.sep).filter(Boolean);
-        if (rule.presetName) {
-            // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetName);
-            // 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));
-        fs_extra_1.default.writeFileSync(ruleFile, rule.content);
-    }
-}
-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("/");
-    }
-    const parts = presetPath.split(node_path_1.default.sep);
-    return parts.filter((part) => part.length > 0); // Filter out empty segments
-}
-function generateRulesFileContent(ruleFiles) {
-    const alwaysApplyRules = [];
-    const optInRules = [];
-    for (const rule of ruleFiles) {
-        // Parse metadata to determine rule type
-        const metadata = rule.content.match(/^---\n([\s\S]*?)\n---/);
-        let alwaysApply = false;
-        if (metadata) {
-            try {
-                const frontmatter = metadata[1];
-                // Simple YAML parsing for alwaysApply field
-                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";
-    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 -->\n";
-    return content;
-}
-/**
- * Write rules file content to a file, preserving existing content outside markers
- */
-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 {
-            // Preserve the existing content and append markers
-            let separator = "";
-            if (!existingContent.endsWith("\n")) {
-                separator += "\n";
-            }
-            if (!existingContent.endsWith("\n\n")) {
-                separator += "\n";
-            }
-            fileContent = existingContent + separator + rulesContent;
-        }
-    }
-    else {
-        // Create new file with markers and content
-        fileContent = rulesContent;
-    }
-    fs_extra_1.default.writeFileSync(rulesFilePath, fileContent);
-}
-/**
- * Write rules to a shared directory and update the given rules file
- */
-function writeRulesForFile(rules, ruleDir, rulesFile) {
-    fs_extra_1.default.emptyDirSync(ruleDir);
-    const ruleFiles = rules.map((rule) => {
-        let rulePath;
-        const ruleNameParts = rule.name.split(node_path_1.default.sep).filter(Boolean);
-        if (rule.presetName) {
-            // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetName);
-            // 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);
-        // For the rules file, maintain the same structure
-        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";
-        }
-        // Normalize to POSIX style for cross-platform compatibility
-        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));
-}
-/**
- * Write all collected rules to their respective IDE targets
- */
-function writeRulesToTargets(rules, targets) {
-    const targetPaths = getTargetPaths();
-    for (const target of targets) {
-        switch (target) {
-            case "cursor":
-                if (rules.length > 0) {
-                    writeCursorRules(rules, targetPaths.cursor);
-                }
-                break;
-            case "windsurf":
-                if (rules.length > 0) {
-                    writeRulesForFile(rules, targetPaths.windsurf, ".windsurfrules");
-                }
-                break;
-            case "codex":
-                if (rules.length > 0) {
-                    writeRulesForFile(rules, targetPaths.codex, "AGENTS.md");
-                }
-                break;
-        }
-    }
-}
-/**
- * Write MCP servers configuration to IDE targets
- */
-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);
-        }
-        // Windsurf and Codex do not support project mcpServers, so skip
-    }
-}
-/**
- * Write MCP servers configuration to a specific file
- */
-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 : {};
-    // Filter out any existing aicm-managed servers (with aicm: true)
-    // This removes stale aicm servers that are no longer in the configuration
-    const userMcpServers = {};
-    for (const [key, value] of Object.entries(existingMcpServers)) {
-        if (typeof value === "object" && value !== null && value.aicm !== true) {
-            userMcpServers[key] = value;
-        }
-    }
-    // Mark new aicm servers as managed and filter out canceled servers
-    const aicmMcpServers = {};
-    for (const [key, value] of Object.entries(mcpServers)) {
-        if (value !== false) {
-            aicmMcpServers[key] = {
-                ...value,
-                aicm: true,
-            };
-        }
-    }
-    // Merge user servers with aicm servers (aicm servers override user servers with same key)
-    const mergedMcpServers = {
-        ...userMcpServers,
-        ...aicmMcpServers,
-    };
-    const mergedConfig = {
-        ...existingConfig,
-        mcpServers: mergedMcpServers,
-    };
-    fs_extra_1.default.writeJsonSync(mcpPath, mergedConfig, { spaces: 2 });
-}
-/**
- * Discover all packages with aicm configurations using git ls-files
- */
-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) {
-        // Fallback to manual search if git is not available
-        return [];
-    }
-}
-/**
- * Discover all packages with aicm configurations
- */
-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 = await (0, config_v2_1.loadConfig)(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 rules for a single package (used within workspaces and standalone installs)
- */
-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: new Error("Configuration file not found"),
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-        const { config, rules, mcpServers } = resolvedConfig;
-        // Check if rules are defined (either directly or through presets)
-        if (!rules || rules.length === 0) {
-            // If there are no presets defined either, show a message
-            if (!config.presets || config.presets.length === 0) {
-                return {
-                    success: false,
-                    error: new Error("No rules defined in configuration"),
-                    installedRuleCount: 0,
-                    packagesCount: 0,
-                };
-            }
-        }
-        try {
-            // Write rules to targets
-            writeRulesToTargets(rules, config.targets);
-            // Write MCP servers
-            if (mcpServers && Object.keys(mcpServers).length > 0) {
-                writeMcpServersToTargets(mcpServers, config.targets, cwd);
-            }
-            return {
-                success: true,
-                installedRuleCount: rules.length,
-                packagesCount: 1,
-            };
-        }
-        catch (error) {
-            return {
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                installedRuleCount: 0,
-                packagesCount: 0,
-            };
-        }
-    });
-}
-/**
- * Install aicm configurations for all packages in a workspace
- */
-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 installPackage({
-                ...options,
-                cwd: packagePath,
-                config: pkg.config,
-            });
-            totalRuleCount += result.installedRuleCount;
-            results.push({
-                path: pkg.relativePath,
-                success: result.success,
-                error: result.error,
-                installedRuleCount: result.installedRuleCount,
-            });
-        }
-        catch (error) {
-            results.push({
-                path: pkg.relativePath,
-                success: false,
-                error: error instanceof Error ? error : new Error(String(error)),
-                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
- */
-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 && 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: new 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: new 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,
-        };
-    });
-}
-/**
- * Core implementation of the rule installation logic
- */
-async function install(options = {}) {
-    const cwd = options.cwd || process.cwd();
-    const installOnCI = options.installOnCI === true; // Default to false if not specified
-    const inCI = (0, is_ci_1.isCIEnvironment)();
-    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);
-    });
-}
-/**
- * CLI command wrapper for install
- */
-async function installCommand(installOnCI, verbose) {
-    var _a;
-    const result = await install({ installOnCI, verbose });
-    if (!result.success) {
-        throw (_a = result.error) !== null && _a !== void 0 ? _a : new Error("Installation failed with unknown 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_/327/2242.d.ts

@@ -1,59 +0,0 @@
-import { ResolvedConfig } from "../utils/config_new";
-/**
- * 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?: 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 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)
- */
-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>;