aicm 0.13.1 → 0.14.1

package/dist/utils/config.js

@@ -3,203 +3,224 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeRules = normalizeRules;
-exports.getFullPresetPath = getFullPresetPath;
+exports.SUPPORTED_TARGETS = void 0;
+exports.detectWorkspacesFromPackageJson = detectWorkspacesFromPackageJson;
+exports.applyDefaults = applyDefaults;
+exports.validateConfig = validateConfig;
+exports.loadRulesFromDirectory = loadRulesFromDirectory;
+exports.resolvePresetPath = resolvePresetPath;
 exports.loadPreset = loadPreset;
-exports.loadAicmConfigCosmiconfig = loadAicmConfigCosmiconfig;
-exports.getConfig = getConfig;
-exports.getRuleSource = getRuleSource;
-exports.getOriginalPresetPath = getOriginalPresetPath;
+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 glob_handler_1 = require("./glob-handler");
-const CONFIG_FILE = "aicm.json";
-function normalizeRules(rules) {
-    if (!rules)
-        return {};
-    if (typeof rules === "string") {
-        return { "/": rules };
+const fast_glob_1 = __importDefault(require("fast-glob"));
+exports.SUPPORTED_TARGETS = ["cursor", "windsurf", "codex"];
+function detectWorkspacesFromPackageJson(cwd) {
+    try {
+        const packageJsonPath = node_path_1.default.join(cwd, "package.json");
+        if (!fs_extra_1.default.existsSync(packageJsonPath)) {
+            return false;
+        }
+        const packageJson = JSON.parse(fs_extra_1.default.readFileSync(packageJsonPath, "utf8"));
+        return Boolean(packageJson.workspaces);
+    }
+    catch (_a) {
+        return false;
     }
-    return rules;
 }
-function getFullPresetPath(presetPath, cwd) {
+function applyDefaults(config, cwd) {
     const workingDir = cwd || process.cwd();
-    // If it's a local file with .json extension, check relative to the working directory
-    if (presetPath.endsWith(".json")) {
-        const absolutePath = node_path_1.default.isAbsolute(presetPath)
-            ? presetPath
-            : node_path_1.default.resolve(workingDir, presetPath);
-        if (fs_extra_1.default.pathExistsSync(absolutePath)) {
-            return { fullPath: absolutePath, originalPath: presetPath };
+    // Auto-detect workspaces if not explicitly set
+    const workspaces = config.workspaces !== undefined
+        ? config.workspaces
+        : detectWorkspacesFromPackageJson(workingDir);
+    return {
+        rulesDir: config.rulesDir,
+        targets: config.targets || ["cursor"],
+        presets: config.presets || [],
+        overrides: config.overrides || {},
+        mcpServers: config.mcpServers || {},
+        workspaces,
+    };
+}
+function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
+    if (typeof config !== "object" || config === null) {
+        throw new Error(`Config is not an object at ${configFilePath}`);
+    }
+    // Validate that either rulesDir or presets is provided
+    const hasRulesDir = "rulesDir" in config && typeof config.rulesDir === "string";
+    const hasPresets = "presets" in config &&
+        Array.isArray(config.presets) &&
+        config.presets.length > 0;
+    // In workspace mode, root config doesn't need rulesDir or presets
+    // since packages will have their own configurations
+    if (!isWorkspaceMode && !hasRulesDir && !hasPresets) {
+        throw new Error(`Either rulesDir or presets must be specified in config at ${configFilePath}`);
+    }
+    // Validate rulesDir if provided
+    if (hasRulesDir) {
+        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}`);
         }
     }
-    try {
-        let absolutePresetPath;
-        // Handle npm package with explicit JSON path
-        if (presetPath.endsWith(".json")) {
-            absolutePresetPath = require.resolve(presetPath, {
-                paths: [__dirname, workingDir],
-            });
+    if ("targets" in config) {
+        if (!Array.isArray(config.targets)) {
+            throw new Error(`targets must be an array in config at ${configFilePath}`);
         }
-        // Handle npm package without explicit JSON path (add aicm.json)
-        else {
-            // For npm packages, ensure we properly handle scoped packages (@org/pkg)
-            const presetPathWithConfig = node_path_1.default.join(presetPath, "aicm.json");
-            try {
-                absolutePresetPath = require.resolve(presetPathWithConfig, {
-                    paths: [__dirname, workingDir],
-                });
-            }
-            catch (_a) {
-                // If direct resolution fails, try as a package name
-                absolutePresetPath = require.resolve(presetPath, {
-                    paths: [__dirname, workingDir],
-                });
-                // If we found the package but not the config file, look for aicm.json
-                if (fs_extra_1.default.existsSync(absolutePresetPath)) {
-                    const packageDir = node_path_1.default.dirname(absolutePresetPath);
-                    const configPath = node_path_1.default.join(packageDir, "aicm.json");
-                    if (fs_extra_1.default.existsSync(configPath)) {
-                        absolutePresetPath = configPath;
-                    }
-                }
+        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(", ")}`);
             }
         }
-        return fs_extra_1.default.existsSync(absolutePresetPath)
-            ? { fullPath: absolutePresetPath, originalPath: presetPath }
-            : null;
     }
-    catch (_b) {
+    // 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;
     }
 }
-/**
- * Load a preset file and return its contents
- */
-function loadPreset(presetPath, cwd) {
-    const pathInfo = getFullPresetPath(presetPath, cwd);
-    if (!pathInfo) {
-        throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
+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.`);
     }
-    const presetContent = fs_extra_1.default.readFileSync(pathInfo.fullPath, "utf8");
-    let preset;
+    let presetConfig;
     try {
-        preset = JSON.parse(presetContent);
+        const content = await fs_extra_1.default.readFile(resolvedPresetPath, "utf8");
+        presetConfig = JSON.parse(content);
     }
     catch (error) {
-        const parseError = error;
-        throw new Error(`Error loading preset: Invalid JSON in ${presetPath}: ${parseError.message}`);
+        throw new Error(`Failed to load preset "${presetPath}": ${error instanceof Error ? error.message : "Unknown error"}`);
     }
-    if (!preset.rules) {
-        throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
+    // Validate that preset has rulesDir
+    if (!presetConfig.rulesDir) {
+        throw new Error(`Preset "${presetPath}" must have a rulesDir specified`);
     }
-    const normalizedRules = normalizeRules(preset.rules);
+    // 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 {
-        rules: normalizedRules,
-        mcpServers: preset.mcpServers,
-        presets: preset.presets,
+        config: presetConfig,
+        rulesDir: presetRulesDir,
     };
 }
-// Global metadata storage
-let currentMetadata = null;
-// Track processed presets to avoid circular references
-const processedPresets = new Set();
-/**
- * Process presets and return a new config with merged rules and metadata
- */
-async function processPresets(config, cwd) {
-    // Create a deep copy of the config to avoid mutations
-    const newConfig = JSON.parse(JSON.stringify(config));
-    const metadata = {
-        ruleSources: {},
-        originalPresetPaths: {},
-    };
-    // Clear processed presets tracking set when starting from the top level
-    processedPresets.clear();
-    return await processPresetsInternal(newConfig, metadata, cwd);
-}
-/**
- * Internal function to process presets recursively
- */
-async function processPresetsInternal(config, metadata, cwd) {
-    if (!config.presets || !Array.isArray(config.presets)) {
-        return { config, metadata };
+async function loadAllRules(config, cwd) {
+    const allRules = [];
+    let mergedMcpServers = { ...config.mcpServers };
+    // Load local rules only if rulesDir is provided
+    if (config.rulesDir) {
+        const localRulesPath = node_path_1.default.resolve(cwd, config.rulesDir);
+        const localRules = await loadRulesFromDirectory(localRulesPath, "local");
+        allRules.push(...localRules);
     }
-    for (const presetPath of config.presets) {
-        const pathInfo = getFullPresetPath(presetPath, cwd);
-        if (!pathInfo) {
-            throw new Error(`Error loading preset: "${presetPath}". Make sure the package is installed in your project.`);
-        }
-        // Skip if we've already processed this preset (prevents circular references)
-        if (processedPresets.has(pathInfo.fullPath)) {
-            // Skip duplicates to prevent circular references
-            continue;
-        }
-        // Mark this preset as processed
-        processedPresets.add(pathInfo.fullPath);
-        const preset = loadPreset(presetPath, cwd);
-        if (!preset)
-            continue;
-        // Expand glob patterns within the preset using its base directory
-        const presetDir = node_path_1.default.dirname(pathInfo.fullPath);
-        const expansion = await (0, glob_handler_1.expandRulesGlobPatterns)(preset.rules, presetDir);
-        preset.rules = expansion.expandedRules;
-        // Process nested presets first (depth-first)
-        if (preset.presets && preset.presets.length > 0) {
-            // Create a temporary config with just the presets from this preset
-            const presetConfig = {
-                rules: {},
-                presets: preset.presets,
-                ides: [],
-            };
-            // Recursively process the nested presets
-            const { config: nestedConfig } = await processPresetsInternal(presetConfig, metadata, cwd);
-            Object.assign(preset.rules, nestedConfig.rules);
-        }
-        const { updatedConfig, updatedMetadata } = mergePresetRules(config, preset.rules, pathInfo, metadata);
-        Object.assign(config.rules, updatedConfig.rules);
-        Object.assign(metadata.ruleSources, updatedMetadata.ruleSources);
-        Object.assign(metadata.originalPresetPaths, updatedMetadata.originalPresetPaths);
-        if (preset.mcpServers) {
-            config.mcpServers = mergePresetMcpServers(config.mcpServers || {}, preset.mcpServers);
+    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 { config, metadata };
-}
-/**
- * Merge preset rules into the config without mutation
- */
-function mergePresetRules(config, presetRules, pathInfo, metadata) {
-    const updatedRules = { ...config.rules };
-    const updatedMetadata = {
-        ruleSources: { ...metadata.ruleSources },
-        originalPresetPaths: { ...metadata.originalPresetPaths },
+    return {
+        rules: allRules,
+        mcpServers: mergedMcpServers,
     };
-    for (const [ruleName, rulePath] of Object.entries(presetRules)) {
-        // Cancel if set to false in config
-        if (Object.prototype.hasOwnProperty.call(config.rules, ruleName) &&
-            config.rules[ruleName] === false) {
-            delete updatedRules[ruleName];
-            delete updatedMetadata.ruleSources[ruleName];
-            delete updatedMetadata.originalPresetPaths[ruleName];
-            continue;
+}
+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`);
         }
-        // Only add if not already defined in config (override handled by config)
-        if (!Object.prototype.hasOwnProperty.call(config.rules, ruleName)) {
-            updatedRules[ruleName] = rulePath;
-            updatedMetadata.ruleSources[ruleName] = pathInfo.fullPath;
-            updatedMetadata.originalPresetPaths[ruleName] = pathInfo.originalPath;
+    }
+    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 {
-        updatedConfig: { ...config, rules: updatedRules },
-        updatedMetadata,
-    };
+    return Array.from(ruleMap.values());
 }
 /**
- * Merge preset mcpServers without mutation
+ * Merge preset MCP servers with local config MCP servers
+ * Local config takes precedence over preset config
  */
 function mergePresetMcpServers(configMcpServers, presetMcpServers) {
     const newMcpServers = { ...configMcpServers };
@@ -217,71 +238,46 @@ function mergePresetMcpServers(configMcpServers, presetMcpServers) {
     }
     return newMcpServers;
 }
-/**
- * Load the aicm config using cosmiconfig, supporting both aicm.json and package.json.
- * Returns the config object or null if not found.
- */
-async function loadAicmConfigCosmiconfig(searchFrom) {
+async function loadConfigFile(searchFrom) {
     const explorer = (0, cosmiconfig_1.cosmiconfig)("aicm", {
-        searchPlaces: ["package.json", "aicm.json"],
+        searchPlaces: ["aicm.json", "package.json"],
     });
     try {
         const result = await explorer.search(searchFrom);
-        if (!result || !result.config)
-            return null;
-        const rawConfig = result.config;
-        const normalizedRules = normalizeRules(rawConfig.rules);
-        const config = {
-            ...rawConfig,
-            ides: rawConfig.ides || ["cursor"],
-            rules: normalizedRules,
-        };
-        return config;
+        return result;
     }
     catch (error) {
-        throw new Error(`Error loading aicm config: ${error instanceof Error ? error.message : String(error)}`);
+        throw new Error(`Failed to load configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
 }
-/**
- * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
- */
-async function getConfig(cwd) {
+async function loadConfig(cwd) {
     const workingDir = cwd || process.cwd();
-    const config = await loadAicmConfigCosmiconfig(workingDir);
-    if (!config) {
-        throw new Error(`No config found in ${workingDir}, create one using "aicm init"`);
+    const configResult = await loadConfigFile(workingDir);
+    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
+        return null;
     }
-    const { config: processedConfig, metadata } = await processPresets(config, workingDir);
-    // Store metadata for later access
-    currentMetadata = metadata;
-    return processedConfig;
-}
-/**
- * Get the source preset path for a rule if it came from a preset
- */
-function getRuleSource(config, ruleName) {
-    var _a;
-    return (_a = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.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 = currentMetadata === null || currentMetadata === void 0 ? void 0 : currentMetadata.originalPresetPaths) === null || _a === void 0 ? void 0 : _a[ruleName];
+    const configWithDefaults = applyDefaults(configResult.config, workingDir);
+    const isWorkspaceMode = configWithDefaults.workspaces;
+    validateConfig(configResult.config, configResult.filepath, workingDir, isWorkspaceMode);
+    const { rules, mcpServers } = await loadAllRules(configWithDefaults, workingDir);
+    let rulesWithOverrides = rules;
+    if (configWithDefaults.overrides) {
+        rulesWithOverrides = applyOverrides(rules, configWithDefaults.overrides, workingDir);
+    }
+    return {
+        config: configWithDefaults,
+        rules: rulesWithOverrides,
+        mcpServers,
+    };
 }
-/**
- * Save the configuration to the aicm.json file
- */
 function saveConfig(config, cwd) {
     const workingDir = cwd || process.cwd();
-    const configPath = node_path_1.default.join(workingDir, CONFIG_FILE);
+    const configPath = node_path_1.default.join(workingDir, "aicm.json");
     try {
-        fs_extra_1.default.writeJsonSync(configPath, config, { spaces: 2 });
+        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
         return true;
     }
-    catch (error) {
-        console.error("Error writing configuration file:", error);
+    catch (_a) {
         return false;
     }
 }

package/dist/utils/config_new.d.ts

@@ -0,0 +1,64 @@
+import { CosmiconfigResult } from "cosmiconfig";
+export interface RawConfig {
+    rulesDir: string;
+    targets?: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
+}
+export interface Config {
+    rulesDir: string;
+    targets: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
+}
+export type MCPServer = {
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: never;
+} | {
+    url: string;
+    env?: Record<string, string>;
+    command?: never;
+    args?: never;
+} | false;
+export interface MCPServers {
+    [serverName: string]: MCPServer;
+}
+export interface RuleFile {
+    name: string;
+    content: string;
+    sourcePath: string;
+    source: "local" | "preset";
+    presetName?: string;
+}
+export interface RuleCollection {
+    [target: string]: RuleFile[];
+}
+export interface ResolvedConfig {
+    config: Config;
+    rules: RuleFile[];
+    mcpServers: MCPServers;
+}
+export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex"];
+export type SupportedTarget = (typeof SUPPORTED_TARGETS)[number];
+export declare function applyDefaults(config: RawConfig): Config;
+export declare function validateConfig(config: unknown, configFilePath: string, cwd: string): asserts config is Config;
+export declare function loadRulesFromDirectory(rulesDir: string, source: "local" | "preset", presetName?: string): Promise<RuleFile[]>;
+export declare function resolvePresetPath(presetPath: string, cwd: string): string | null;
+export declare function loadPreset(presetPath: string, cwd: string): Promise<{
+    config: Config;
+    rulesDir: string;
+}>;
+export declare function loadAllRules(config: Config, cwd: string): Promise<{
+    rules: RuleFile[];
+    mcpServers: MCPServers;
+}>;
+export declare function applyOverrides(rules: RuleFile[], overrides: Record<string, string | false>, cwd: string): RuleFile[];
+export declare function loadConfigFile(searchFrom?: string): Promise<CosmiconfigResult>;
+export declare function loadConfig(cwd?: string): Promise<ResolvedConfig | null>;
+export declare function saveConfig(config: Config, cwd?: string): boolean;