aicm 0.14.4 → 0.14.5

package/dist/utils/config_v2.js

@@ -1,250 +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.SUPPORTED_TARGETS = void 0;
-exports.applyDefaults = applyDefaults;
-exports.validateConfig = validateConfig;
-exports.loadRulesFromDirectory = loadRulesFromDirectory;
-exports.resolvePresetPath = resolvePresetPath;
-exports.loadPreset = loadPreset;
-exports.loadAllRules = loadAllRules;
-exports.applyOverrides = applyOverrides;
-exports.loadConfigFile = loadConfigFile;
-exports.loadConfig = loadConfig;
-exports.saveConfig = saveConfig;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-const cosmiconfig_1 = require("cosmiconfig");
-const fast_glob_1 = __importDefault(require("fast-glob"));
-exports.SUPPORTED_TARGETS = ["cursor", "windsurf", "codex"];
-function applyDefaults(config) {
-    return {
-        rulesDir: config.rulesDir,
-        targets: config.targets || ["cursor"],
-        presets: config.presets || [],
-        overrides: config.overrides || {},
-        mcpServers: config.mcpServers || {},
-        workspaces: config.workspaces || false,
-    };
-}
-function validateConfig(config, configFilePath, cwd) {
-    if (typeof config !== "object" || config === null) {
-        throw new Error(`Config is not an object at ${configFilePath}`);
-    }
-    if (!("rulesDir" in config)) {
-        throw new Error(`rulesDir is not specified in config at ${configFilePath}`);
-    }
-    if (typeof config.rulesDir !== "string") {
-        throw new Error(`rulesDir is not a string in config at ${configFilePath}`);
-    }
-    const rulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
-    if (!fs_extra_1.default.existsSync(rulesPath)) {
-        throw new Error(`Rules directory does not exist: ${rulesPath}`);
-    }
-    if (!fs_extra_1.default.statSync(rulesPath).isDirectory()) {
-        throw new Error(`Rules path is not a directory: ${rulesPath}`);
-    }
-    if ("targets" in config) {
-        if (!Array.isArray(config.targets)) {
-            throw new Error(`targets must be an array in config at ${configFilePath}`);
-        }
-        if (config.targets.length === 0) {
-            throw new Error(`targets must not be empty in config at ${configFilePath}`);
-        }
-        for (const target of config.targets) {
-            if (!exports.SUPPORTED_TARGETS.includes(target)) {
-                throw new Error(`Unsupported target: ${target}. Supported targets: ${exports.SUPPORTED_TARGETS.join(", ")}`);
-            }
-        }
-    }
-    // Validate override rule names will be checked after rule resolution
-}
-async function loadRulesFromDirectory(rulesDir, source, presetName) {
-    const rules = [];
-    if (!fs_extra_1.default.existsSync(rulesDir)) {
-        return rules;
-    }
-    const pattern = node_path_1.default.join(rulesDir, "**/*.mdc").replace(/\\/g, "/");
-    const filePaths = await (0, fast_glob_1.default)(pattern, {
-        onlyFiles: true,
-        absolute: true,
-    });
-    for (const filePath of filePaths) {
-        const content = await fs_extra_1.default.readFile(filePath, "utf8");
-        // Preserve directory structure by using relative path from rulesDir
-        const relativePath = node_path_1.default.relative(rulesDir, filePath);
-        const ruleName = relativePath.replace(/\.mdc$/, "").replace(/\\/g, "/");
-        rules.push({
-            name: ruleName,
-            content,
-            sourcePath: filePath,
-            source,
-            presetName,
-        });
-    }
-    return rules;
-}
-function resolvePresetPath(presetPath, cwd) {
-    // Support specifying aicm.json directory and load the config from it
-    if (!presetPath.endsWith(".json")) {
-        presetPath = node_path_1.default.join(presetPath, "aicm.json");
-    }
-    // Support local or absolute paths
-    const absolutePath = node_path_1.default.isAbsolute(presetPath)
-        ? presetPath
-        : node_path_1.default.resolve(cwd, presetPath);
-    if (fs_extra_1.default.existsSync(absolutePath)) {
-        return absolutePath;
-    }
-    try {
-        // Support npm packages
-        const resolvedPath = require.resolve(presetPath, {
-            paths: [cwd, __dirname],
-        });
-        return fs_extra_1.default.existsSync(resolvedPath) ? resolvedPath : null;
-    }
-    catch (_a) {
-        return null;
-    }
-}
-async function loadPreset(presetPath, cwd) {
-    const resolvedPresetPath = resolvePresetPath(presetPath, cwd);
-    if (!resolvedPresetPath) {
-        throw new Error(`Preset not found: "${presetPath}". Make sure the package is installed or the path is correct.`);
-    }
-    let presetConfig;
-    try {
-        const content = await fs_extra_1.default.readFile(resolvedPresetPath, "utf8");
-        presetConfig = JSON.parse(content);
-    }
-    catch (error) {
-        throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-    // Resolve preset's rules directory relative to the preset file
-    const presetDir = node_path_1.default.dirname(resolvedPresetPath);
-    const presetRulesDir = node_path_1.default.resolve(presetDir, presetConfig.rulesDir);
-    return {
-        config: presetConfig,
-        rulesDir: presetRulesDir,
-    };
-}
-async function loadAllRules(config, cwd) {
-    const allRules = [];
-    let mergedMcpServers = { ...config.mcpServers };
-    // Load local rules
-    const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
-    const localRules = await loadRulesFromDirectory(localRulesPath, "local");
-    allRules.push(...localRules);
-    if (config.presets) {
-        for (const presetPath of config.presets) {
-            const preset = await loadPreset(presetPath, cwd);
-            const presetRules = await loadRulesFromDirectory(preset.rulesDir, "preset", presetPath);
-            allRules.push(...presetRules);
-            // Merge MCP servers from preset
-            if (preset.config.mcpServers) {
-                mergedMcpServers = mergePresetMcpServers(mergedMcpServers, preset.config.mcpServers);
-            }
-        }
-    }
-    return {
-        rules: allRules,
-        mcpServers: mergedMcpServers,
-    };
-}
-function applyOverrides(rules, overrides, cwd) {
-    // Validate that all override rule names exist in the resolved rules
-    for (const ruleName of Object.keys(overrides)) {
-        // TODO: support better error messages with edit distance, helping the user in case of a typo
-        // TODO: or shows a list of potential rules to override
-        if (!rules.some((rule) => rule.name === ruleName)) {
-            throw new Error(`Override rule "${ruleName}" does not exist in resolved rules`);
-        }
-    }
-    const ruleMap = new Map();
-    for (const rule of rules) {
-        ruleMap.set(rule.name, rule);
-    }
-    for (const [ruleName, override] of Object.entries(overrides)) {
-        if (override === false) {
-            ruleMap.delete(ruleName);
-        }
-        else if (typeof override === "string") {
-            const overridePath = node_path_1.default.resolve(cwd, override);
-            if (!fs_extra_1.default.existsSync(overridePath)) {
-                throw new Error(`Override rule file not found: ${override} in ${cwd}`);
-            }
-            const content = fs_extra_1.default.readFileSync(overridePath, "utf8");
-            ruleMap.set(ruleName, {
-                name: ruleName,
-                content,
-                sourcePath: overridePath,
-                source: "local",
-            });
-        }
-    }
-    return Array.from(ruleMap.values());
-}
-/**
- * Merge preset MCP servers with local config MCP servers
- * Local config takes precedence over preset config
- */
-function mergePresetMcpServers(configMcpServers, presetMcpServers) {
-    const newMcpServers = { ...configMcpServers };
-    for (const [serverName, serverConfig] of Object.entries(presetMcpServers)) {
-        // Cancel if set to false in config
-        if (Object.prototype.hasOwnProperty.call(newMcpServers, serverName) &&
-            newMcpServers[serverName] === false) {
-            delete newMcpServers[serverName];
-            continue;
-        }
-        // Only add if not already defined in config (override handled by config)
-        if (!Object.prototype.hasOwnProperty.call(newMcpServers, serverName)) {
-            newMcpServers[serverName] = serverConfig;
-        }
-    }
-    return newMcpServers;
-}
-async function loadConfigFile(searchFrom) {
-    const explorer = (0, cosmiconfig_1.cosmiconfig)("aicm", {
-        searchPlaces: ["aicm.json", "package.json"],
-    });
-    try {
-        const result = await explorer.search(searchFrom);
-        return result;
-    }
-    catch (error) {
-        throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-}
-async function loadConfig(cwd) {
-    const workingDir = cwd || process.cwd();
-    const configResult = await loadConfigFile(workingDir);
-    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
-        return null;
-    }
-    validateConfig(configResult.config, configResult.filepath, workingDir);
-    const config = applyDefaults(configResult.config);
-    const { rules, mcpServers } = await loadAllRules(config, workingDir);
-    let rulesWithOverrides = rules;
-    if (config.overrides) {
-        rulesWithOverrides = applyOverrides(rules, config.overrides, workingDir);
-    }
-    return {
-        config,
-        rules: rulesWithOverrides,
-        mcpServers,
-    };
-}
-function saveConfig(config, cwd) {
-    const workingDir = cwd || process.cwd();
-    const configPath = node_path_1.default.join(workingDir, "aicm.json");
-    try {
-        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
-        return true;
-    }
-    catch (_a) {
-        return false;
-    }
-}

package/dist/utils/glob-handler.d.ts

@@ -1,35 +0,0 @@
-/**
- * Check if a rule source string contains glob patterns
- */
-export declare function isGlobPattern(source: string): boolean;
-/**
- * Expand a glob pattern to matching .mdc files
- * @param pattern The glob pattern to expand
- * @param basePath The base path to resolve relative patterns from
- * @returns Array of file paths that match the pattern
- */
-export declare function expandGlobPattern(pattern: string, basePath?: string): Promise<string[]>;
-/**
- * Generate a rule key from a file path and base key
- * @param filePath The discovered file path
- * @param baseKey The base key from the object notation
- * @param patternBase The base directory of the glob pattern
- * @returns Generated rule key with namespace
- */
-export declare function generateGlobRuleKey(filePath: string, baseKey: string, patternBase: string): string;
-/**
- * Get the base directory from a glob pattern
- * @param pattern The glob pattern
- * @returns The base directory path without glob characters
- */
-export declare function getGlobBase(pattern: string): string;
-/**
- * Expand glob patterns in rules object and return normalized rules
- * @param rules The rules object that may contain glob patterns
- * @param basePath The base path to resolve relative patterns from
- * @returns Object with expanded rules and metadata about sources
- */
-export declare function expandRulesGlobPatterns(rules: Record<string, string | false>, basePath?: string): Promise<{
-    expandedRules: Record<string, string>;
-    globSources: Record<string, string>;
-}>;

package/dist/utils/glob-handler.js

@@ -1,125 +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.isGlobPattern = isGlobPattern;
-exports.expandGlobPattern = expandGlobPattern;
-exports.generateGlobRuleKey = generateGlobRuleKey;
-exports.getGlobBase = getGlobBase;
-exports.expandRulesGlobPatterns = expandRulesGlobPatterns;
-const node_path_1 = __importDefault(require("node:path"));
-const fast_glob_1 = __importDefault(require("fast-glob"));
-/**
- * Check if a rule source string contains glob patterns
- */
-function isGlobPattern(source) {
-    return /[*?{}[\]]/.test(source);
-}
-/**
- * Expand a glob pattern to matching .mdc files
- * @param pattern The glob pattern to expand
- * @param basePath The base path to resolve relative patterns from
- * @returns Array of file paths that match the pattern
- */
-async function expandGlobPattern(pattern, basePath) {
-    // Normalize the pattern to use forward slashes for consistent behavior
-    const normalizedPattern = pattern.replace(/\\/g, "/");
-    try {
-        const matches = await (0, fast_glob_1.default)(normalizedPattern, {
-            ignore: ["**/.*"], // Ignore hidden files
-            absolute: false,
-            onlyFiles: true,
-            // Set the working directory if basePath is provided
-            cwd: basePath,
-        });
-        // Filter to only .mdc files, normalize paths, and sort for deterministic behavior
-        return matches
-            .filter((file) => file.endsWith(".mdc"))
-            .map((file) => file.replace(/\\/g, "/")) // Normalize Windows backslashes to forward slashes
-            .sort((a, b) => a.localeCompare(b));
-    }
-    catch (error) {
-        throw new Error(`Error expanding glob pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Generate a rule key from a file path and base key
- * @param filePath The discovered file path
- * @param baseKey The base key from the object notation
- * @param patternBase The base directory of the glob pattern
- * @returns Generated rule key with namespace
- */
-function generateGlobRuleKey(filePath, baseKey, patternBase) {
-    // Normalize paths to use forward slashes for consistent behavior
-    const normalizedFilePath = filePath.replace(/\\/g, "/");
-    const normalizedPatternBase = patternBase.replace(/\\/g, "/");
-    // Get the relative path from the pattern base to the file
-    const relativePath = node_path_1.default.posix.relative(normalizedPatternBase, normalizedFilePath);
-    // Remove .mdc extension
-    const withoutExtension = relativePath.replace(/\.mdc$/, "");
-    // Return the combined key
-    return `${baseKey}/${withoutExtension}`;
-}
-/**
- * Get the base directory from a glob pattern
- * @param pattern The glob pattern
- * @returns The base directory path without glob characters
- */
-function getGlobBase(pattern) {
-    // Normalize path separators to forward slashes for consistent behavior
-    const normalizedPattern = pattern.replace(/\\/g, "/");
-    // Find the first occurrence of glob characters
-    const globIndex = normalizedPattern.search(/[*?{}[\]]/);
-    if (globIndex === -1) {
-        // No glob characters, return the directory
-        return node_path_1.default.dirname(normalizedPattern);
-    }
-    // Get the path up to the first glob character
-    const basePath = normalizedPattern.substring(0, globIndex);
-    // Find the last path separator before the glob
-    const lastSeparator = basePath.lastIndexOf("/");
-    if (lastSeparator === -1) {
-        return ".";
-    }
-    return basePath.substring(0, lastSeparator);
-}
-/**
- * Expand glob patterns in rules object and return normalized rules
- * @param rules The rules object that may contain glob patterns
- * @param basePath The base path to resolve relative patterns from
- * @returns Object with expanded rules and metadata about sources
- */
-async function expandRulesGlobPatterns(rules, basePath) {
-    const expandedRules = {};
-    const globSources = {};
-    for (const [key, source] of Object.entries(rules)) {
-        if (source === false) {
-            continue; // Skip canceled rules
-        }
-        if (isGlobPattern(source)) {
-            // Expand glob pattern
-            try {
-                const matchedFiles = await expandGlobPattern(source, basePath);
-                if (matchedFiles.length === 0) {
-                    console.warn(`Warning: Glob pattern "${source}" matched no files`);
-                    continue;
-                }
-                const patternBase = getGlobBase(source);
-                for (const filePath of matchedFiles) {
-                    const generatedKey = generateGlobRuleKey(filePath, key, patternBase);
-                    expandedRules[generatedKey] = filePath;
-                    globSources[generatedKey] = source;
-                }
-            }
-            catch (error) {
-                throw new Error(`Error processing glob pattern for key "${key}": ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        else {
-            // Regular file path
-            expandedRules[key] = source;
-        }
-    }
-    return { expandedRules, globSources };
-}

package/dist/utils/mcp-writer.d.ts

@@ -1,14 +0,0 @@
-import { NormalizedConfig } from "../types";
-/**
- * Write MCP servers configuration to IDE targets
- * @param mcpServers The MCP servers configuration
- * @param ides The IDEs to write to
- * @param cwd The current working directory
- */
-export declare function writeMcpServersToTargets(mcpServers: NormalizedConfig["mcpServers"], ides: string[], cwd: string): void;
-/**
- * Write MCP servers configuration to a specific file
- * @param mcpServers The MCP servers configuration
- * @param mcpPath The path to the mcp.json file
- */
-export declare function writeMcpServersToFile(mcpServers: NormalizedConfig["mcpServers"], mcpPath: string): void;

package/dist/utils/mcp-writer.js

@@ -1,69 +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.writeMcpServersToTargets = writeMcpServersToTargets;
-exports.writeMcpServersToFile = writeMcpServersToFile;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Write MCP servers configuration to IDE targets
- * @param mcpServers The MCP servers configuration
- * @param ides The IDEs to write to
- * @param cwd The current working directory
- */
-function writeMcpServersToTargets(mcpServers, ides, cwd) {
-    if (!mcpServers)
-        return;
-    for (const ide of ides) {
-        if (ide === "cursor") {
-            const mcpPath = node_path_1.default.join(cwd, ".cursor", "mcp.json");
-            writeMcpServersToFile(mcpServers, mcpPath);
-        }
-        // Windsurf does not support project mcpServers, so skip
-    }
-}
-/**
- * Write MCP servers configuration to a specific file
- * @param mcpServers The MCP servers configuration
- * @param mcpPath The path to the mcp.json file
- */
-function writeMcpServersToFile(mcpServers, mcpPath) {
-    var _a;
-    if (!mcpServers)
-        return;
-    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 });
-}

package/dist/utils/mdc-parser.d.ts

@@ -1,9 +0,0 @@
-/**
- * Parse an MDC file and extract its content
- * MDC files are Markdown files with metadata
- * https://docs.cursor.com/context/rules
- */
-export declare function parseMdcFile(filePath: string): {
-    metadata: Record<string, boolean | string | string[]>;
-    content: string;
-};

package/dist/utils/mdc-parser.js

@@ -1,59 +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.parseMdcFile = parseMdcFile;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-/**
- * Parse an MDC file and extract its content
- * MDC files are Markdown files with metadata
- * https://docs.cursor.com/context/rules
- */
-function parseMdcFile(filePath) {
-    const fileContent = fs_extra_1.default.readFileSync(filePath, "utf8");
-    if (!fileContent.startsWith("---")) {
-        return {
-            metadata: {},
-            content: fileContent,
-        };
-    }
-    const endOfMetadata = fileContent.indexOf("---", 3);
-    if (endOfMetadata === -1) {
-        return {
-            metadata: {},
-            content: fileContent,
-        };
-    }
-    const metadataStr = fileContent.substring(3, endOfMetadata).trim();
-    const content = fileContent.substring(endOfMetadata + 3).trim();
-    const metadata = {};
-    metadataStr.split("\n").forEach((line) => {
-        const colonIndex = line.indexOf(":");
-        if (colonIndex !== -1) {
-            const key = line.substring(0, colonIndex).trim();
-            const valueStr = line.substring(colonIndex + 1).trim();
-            // Handle different value types
-            let value = "";
-            if (valueStr === "true") {
-                value = true;
-            }
-            else if (valueStr === "false") {
-                value = false;
-            }
-            else if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
-                // Remove quotes from string values
-                value = valueStr.substring(1, valueStr.length - 1);
-            }
-            else {
-                // Default to using the string value as is
-                value = valueStr;
-            }
-            metadata[key] = value;
-        }
-    });
-    return {
-        metadata,
-        content,
-    };
-}

package/dist/utils/rule-collector.d.ts

@@ -1,33 +0,0 @@
-import { RuleCollection, RuleContent } from "../types";
-/**
- * Find the root directory of a package by name
- * @param packageName The name of the package
- * @returns The absolute path to the package's root directory
- */
-export declare function findPackageRoot(packageName: string): string;
-/**
- * Initialize an empty rule collection
- */
-export declare function initRuleCollection(): RuleCollection;
-/**
- * Add a rule to the collection
- * @param collection The rule collection to add to
- * @param rule The rule content to add
- * @param ides The IDEs to add the rule for
- */
-export declare function addRuleToCollection(collection: RuleCollection, rule: RuleContent, ides: string[]): void;
-/**
- * Collect a rule from a local file source
- * @param ruleName The name of the rule
- * @param source The source path (relative or absolute)
- * @param ruleBasePath Optional base path for resolving relative paths
- * @returns The rule content
- */
-export declare function collectLocalRule(ruleName: string, source: string | false, ruleBasePath?: string): RuleContent;
-/**
- * Collect a rule from an npm package
- * @param ruleName The name of the rule
- * @param source The npm package source (can include path)
- * @returns The rule content
- */
-export declare function collectNpmRule(ruleName: string, source: string | false): RuleContent;