aicm 0.13.1 → 0.14.0

package/dist/commands/install_/327/2242.js

@@ -0,0 +1,546 @@
+"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_new_1 = require("../utils/config_new");
+const working_directory_1 = require("../utils/working-directory");
+/**
+ * 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;
+}
+/**
+ * Get the IDE-specific rule installation paths
+ */
+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"),
+    };
+}
+/**
+ * Write rules to Cursor's rules directory
+ */
+function writeCursorRules(rules, cursorRulesDir) {
+    fs_extra_1.default.emptyDirSync(cursorRulesDir);
+    for (const rule of rules) {
+        let rulePath;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).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);
+    }
+}
+/**
+ * Extract a normalized namespace from a preset path
+ */
+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
+}
+/**
+ * Generate rules file content for Windsurf/Codex
+ */
+function generateRulesFileContent(ruleFiles) {
+    const alwaysApplyRules = [];
+    const optInRules = [];
+    for (const rule of ruleFiles) {
+        // Parse frontmatter to determine rule type
+        const frontmatterMatch = rule.content.match(/^---\n([\s\S]*?)\n---/);
+        let alwaysApply = false;
+        if (frontmatterMatch) {
+            try {
+                const frontmatter = frontmatterMatch[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";
+    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;
+}
+/**
+ * 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;
+    // Check if file exists
+    if (fs_extra_1.default.existsSync(rulesFilePath)) {
+        const existingContent = fs_extra_1.default.readFileSync(rulesFilePath, "utf8");
+        // Check if our markers exist
+        if (existingContent.includes(RULES_BEGIN) &&
+            existingContent.includes(RULES_END)) {
+            // Replace content between markers
+            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;
+        // Parse rule name into path segments using platform-specific path separator
+        const ruleNameParts = rule.name.split(/[/\\]/).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); // Gets '.aicm'
+        // 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 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;
+        }
+    }
+}
+/**
+ * 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_new_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_new_1.loadConfig)(cwd);
+        }
+        if (!resolvedConfig) {
+            return {
+                success: false,
+                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: "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) {
+            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,
+            };
+        }
+    });
+}
+/**
+ * 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,
+                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,
+    };
+}
+/**
+ * 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: "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,
+        };
+    });
+}
+/**
+ * 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 = 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_new_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) {
+    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/list.js

@@ -6,34 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.listCommand = listCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../utils/config");
-const rule_status_1 = require("../utils/rule-status");
-const rule_detector_1 = require("../utils/rule-detector");
 async function listCommand() {
-    const config = await (0, config_1.getConfig)();
+    const config = await (0, config_1.loadConfig)();
     if (!config) {
         console.log(chalk_1.default.red("Configuration file not found!"));
         console.log(`Run ${chalk_1.default.blue("npx aicm init")} to create one.`);
         return;
     }
-    if (!config.rules || Object.keys(config.rules).length === 0) {
+    if (!config.rules || config.rules.length === 0) {
         console.log(chalk_1.default.yellow("No rules defined in configuration."));
         console.log(`Edit your ${chalk_1.default.blue("aicm.json")} file to add rules.`);
         return;
     }
     console.log(chalk_1.default.blue("Configured Rules:"));
     console.log(chalk_1.default.dim("─".repeat(50)));
-    for (const [ruleName, source] of Object.entries(config.rules)) {
-        if (source === false)
-            continue;
-        const ruleType = (0, rule_detector_1.detectRuleType)(source);
-        const status = (0, rule_status_1.checkRuleStatus)(ruleName, config.ides);
-        const statusColor = status
-            ? chalk_1.default.green("Installed")
-            : chalk_1.default.yellow("Not installed");
-        console.log(`${chalk_1.default.bold(ruleName)}`);
-        console.log(`  Source: ${source}`);
-        console.log(`  Type: ${ruleType} (auto-detected)`);
-        console.log(`  Status: ${statusColor}`);
-        console.log(chalk_1.default.dim("─".repeat(50)));
+    for (const rule of config.rules) {
+        console.log(`${chalk_1.default.bold(rule.name)} - ${rule.sourcePath} ${rule.presetName ? `[${rule.presetName}]` : ""}`);
     }
 }

package/dist/utils/config.d.ts

@@ -1,44 +1,64 @@
-import { Config, NormalizedConfig, Rules } from "../types";
-export interface RuleMetadata {
-    ruleSources: Record<string, string>;
-    originalPresetPaths: Record<string, string>;
+import { CosmiconfigResult } from "cosmiconfig";
+export interface RawConfig {
+    rulesDir?: string;
+    targets?: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
 }
-export interface ConfigResult {
-    config: NormalizedConfig;
-    metadata: RuleMetadata;
+export interface Config {
+    rulesDir?: string;
+    targets: string[];
+    presets?: string[];
+    overrides?: Record<string, string | false>;
+    mcpServers?: MCPServers;
+    workspaces?: boolean;
 }
-export declare function normalizeRules(rules: Rules | string | undefined): Rules;
-export interface PresetPathInfo {
-    fullPath: string;
-    originalPath: string;
+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 declare function getFullPresetPath(presetPath: string, cwd?: string): PresetPathInfo | null;
-/**
- * Load a preset file and return its contents
- */
-export declare function loadPreset(presetPath: string, cwd?: string): {
-    rules: Rules;
-    mcpServers?: import("../types").MCPServers;
-    presets?: string[];
-} | null;
-/**
- * Load the aicm config using cosmiconfig, supporting both aicm.json and package.json.
- * Returns the config object or null if not found.
- */
-export declare function loadAicmConfigCosmiconfig(searchFrom?: string): Promise<NormalizedConfig | null>;
-/**
- * Get the configuration from aicm.json or package.json (using cosmiconfigSync) and merge with any presets
- */
-export declare function getConfig(cwd?: string): Promise<NormalizedConfig | null>;
-/**
- * Get the source preset path for a rule if it came from a preset
- */
-export declare function getRuleSource(config: NormalizedConfig, ruleName: string): string | undefined;
-/**
- * Get the original preset path for a rule if it came from a preset
- */
-export declare function getOriginalPresetPath(config: NormalizedConfig, ruleName: string): string | undefined;
-/**
- * Save the configuration to the aicm.json file
- */
+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, cwd?: string): 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;