aicm 0.20.1 → 0.20.5

package/dist/commands/list.d.ts

@@ -1 +0,0 @@
-export declare function listCommand(): Promise<void>;

package/dist/commands/list.js

@@ -1,40 +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.listCommand = listCommand;
-const chalk_1 = __importDefault(require("chalk"));
-const config_1 = require("../utils/config");
-async function listCommand() {
-    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;
-    }
-    const hasRules = config.rules && config.rules.length > 0;
-    const hasCommands = config.commands && config.commands.length > 0;
-    if (!hasRules && !hasCommands) {
-        console.log(chalk_1.default.yellow("No rules or commands defined in configuration."));
-        console.log(`Edit your ${chalk_1.default.blue("aicm.json")} file to add rules or commands.`);
-        return;
-    }
-    if (hasRules) {
-        console.log(chalk_1.default.blue("Configured Rules:"));
-        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}]` : ""}`);
-        }
-    }
-    if (hasCommands) {
-        if (hasRules) {
-            console.log();
-        }
-        console.log(chalk_1.default.blue("Configured Commands:"));
-        console.log(chalk_1.default.dim("─".repeat(50)));
-        for (const command of config.commands) {
-            console.log(`${chalk_1.default.bold(command.name)} - ${command.sourcePath} ${command.presetName ? `[${command.presetName}]` : ""}`);
-        }
-    }
-}

package/dist/utils/config.d.ts

@@ -1,117 +0,0 @@
-import { CosmiconfigResult } from "cosmiconfig";
-import { HooksJson, HookFile } from "./hooks";
-export interface RawConfig {
-    rootDir?: string;
-    targets?: string[];
-    presets?: string[];
-    mcpServers?: MCPServers;
-    workspaces?: boolean;
-    skipInstall?: boolean;
-}
-export interface Config {
-    rootDir?: string;
-    targets: string[];
-    presets?: string[];
-    mcpServers?: MCPServers;
-    workspaces?: boolean;
-    skipInstall?: 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 ManagedFile {
-    name: string;
-    content: string;
-    sourcePath: string;
-    source: "local" | "preset";
-    presetName?: string;
-}
-export interface AssetFile {
-    name: string;
-    content: Buffer;
-    sourcePath: string;
-    source: "local" | "preset";
-    presetName?: string;
-}
-export type RuleFile = ManagedFile;
-export type CommandFile = ManagedFile;
-export interface SkillFile {
-    name: string;
-    sourcePath: string;
-    source: "local" | "preset";
-    presetName?: string;
-}
-export type AgentFile = ManagedFile;
-export interface RuleCollection {
-    [target: string]: RuleFile[];
-}
-export interface ResolvedConfig {
-    config: Config;
-    rules: RuleFile[];
-    commands: CommandFile[];
-    assets: AssetFile[];
-    skills: SkillFile[];
-    agents: AgentFile[];
-    mcpServers: MCPServers;
-    hooks: HooksJson;
-    hookFiles: HookFile[];
-}
-export declare const ALLOWED_CONFIG_KEYS: readonly ["rootDir", "targets", "presets", "mcpServers", "workspaces", "skipInstall"];
-export declare const SUPPORTED_TARGETS: readonly ["cursor", "windsurf", "codex", "claude"];
-export type SupportedTarget = (typeof SUPPORTED_TARGETS)[number];
-export declare function detectWorkspacesFromPackageJson(cwd: string): boolean;
-export declare function resolveWorkspaces(config: unknown, configFilePath: string, cwd: string): boolean;
-export declare function applyDefaults(config: RawConfig, workspaces: boolean): Config;
-export declare function validateConfig(config: unknown, configFilePath: string, cwd: string, isWorkspaceMode?: boolean): asserts config is Config;
-export declare function loadRulesFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<RuleFile[]>;
-export declare function loadCommandsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<CommandFile[]>;
-export declare function loadAssetsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<AssetFile[]>;
-/**
- * Load skills from a skills/ directory
- * Each direct subdirectory containing a SKILL.md file is considered a skill
- */
-export declare function loadSkillsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<SkillFile[]>;
-/**
- * Load agents from an agents/ directory
- * Agents are markdown files (.md) with YAML frontmatter
- */
-export declare function loadAgentsFromDirectory(directoryPath: string, source: "local" | "preset", presetName?: string): Promise<AgentFile[]>;
-/**
- * Extract namespace from preset path for directory structure
- * Handles both npm packages and local paths consistently
- */
-export declare function extractNamespaceFromPresetPath(presetPath: string): string[];
-export declare function resolvePresetPath(presetPath: string, cwd: string): string | null;
-export declare function loadPreset(presetPath: string, cwd: string): Promise<{
-    config: Config;
-    rootDir: string;
-}>;
-export declare function loadAllRules(config: Config, cwd: string): Promise<{
-    rules: RuleFile[];
-    commands: CommandFile[];
-    assets: AssetFile[];
-    skills: SkillFile[];
-    agents: AgentFile[];
-    mcpServers: MCPServers;
-    hooks: HooksJson;
-    hookFiles: HookFile[];
-}>;
-export declare function loadConfigFile(searchFrom?: string): Promise<CosmiconfigResult>;
-/**
- * Check if workspaces mode is enabled without loading all rules/presets
- * This is useful for commands that only need to know the workspace setting
- */
-export declare function checkWorkspacesEnabled(cwd?: string): Promise<boolean>;
-export declare function loadConfig(cwd?: string): Promise<ResolvedConfig | null>;
-export declare function saveConfig(config: Config, cwd?: string): boolean;

package/dist/utils/config.js

@@ -1,529 +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 = exports.ALLOWED_CONFIG_KEYS = void 0;
-exports.detectWorkspacesFromPackageJson = detectWorkspacesFromPackageJson;
-exports.resolveWorkspaces = resolveWorkspaces;
-exports.applyDefaults = applyDefaults;
-exports.validateConfig = validateConfig;
-exports.loadRulesFromDirectory = loadRulesFromDirectory;
-exports.loadCommandsFromDirectory = loadCommandsFromDirectory;
-exports.loadAssetsFromDirectory = loadAssetsFromDirectory;
-exports.loadSkillsFromDirectory = loadSkillsFromDirectory;
-exports.loadAgentsFromDirectory = loadAgentsFromDirectory;
-exports.extractNamespaceFromPresetPath = extractNamespaceFromPresetPath;
-exports.resolvePresetPath = resolvePresetPath;
-exports.loadPreset = loadPreset;
-exports.loadAllRules = loadAllRules;
-exports.loadConfigFile = loadConfigFile;
-exports.checkWorkspacesEnabled = checkWorkspacesEnabled;
-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"));
-const hooks_1 = require("./hooks");
-exports.ALLOWED_CONFIG_KEYS = [
-    "rootDir",
-    "targets",
-    "presets",
-    "mcpServers",
-    "workspaces",
-    "skipInstall",
-];
-exports.SUPPORTED_TARGETS = [
-    "cursor",
-    "windsurf",
-    "codex",
-    "claude",
-];
-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;
-    }
-}
-function resolveWorkspaces(config, configFilePath, cwd) {
-    const hasConfigWorkspaces = typeof config === "object" && config !== null && "workspaces" in config;
-    if (hasConfigWorkspaces) {
-        if (typeof config.workspaces === "boolean") {
-            return config.workspaces;
-        }
-        throw new Error(`workspaces must be a boolean in config at ${configFilePath}`);
-    }
-    return detectWorkspacesFromPackageJson(cwd);
-}
-function applyDefaults(config, workspaces) {
-    return {
-        rootDir: config.rootDir,
-        targets: config.targets || ["cursor"],
-        presets: config.presets || [],
-        mcpServers: config.mcpServers || {},
-        workspaces,
-        skipInstall: config.skipInstall || false,
-    };
-}
-function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
-    if (typeof config !== "object" || config === null) {
-        throw new Error(`Config is not an object at ${configFilePath}`);
-    }
-    const unknownKeys = Object.keys(config).filter((key) => !exports.ALLOWED_CONFIG_KEYS.includes(key));
-    if (unknownKeys.length > 0) {
-        throw new Error(`Invalid configuration at ${configFilePath}: unknown keys: ${unknownKeys.join(", ")}`);
-    }
-    // Validate rootDir
-    const hasRootDir = "rootDir" in config && typeof config.rootDir === "string";
-    const hasPresets = "presets" in config &&
-        Array.isArray(config.presets) &&
-        config.presets.length > 0;
-    if (hasRootDir) {
-        const rootPath = node_path_1.default.resolve(cwd, config.rootDir);
-        if (!fs_extra_1.default.existsSync(rootPath)) {
-            throw new Error(`Root directory does not exist: ${rootPath}`);
-        }
-        if (!fs_extra_1.default.statSync(rootPath).isDirectory()) {
-            throw new Error(`Root path is not a directory: ${rootPath}`);
-        }
-        // Check for at least one valid subdirectory or file
-        const hasRules = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "rules"));
-        const hasCommands = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "commands"));
-        const hasHooks = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "hooks.json"));
-        const hasSkills = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "skills"));
-        const hasAgents = fs_extra_1.default.existsSync(node_path_1.default.join(rootPath, "agents"));
-        // In workspace mode, root config doesn't need these directories
-        // since packages will have their own configurations
-        if (!isWorkspaceMode &&
-            !hasRules &&
-            !hasCommands &&
-            !hasHooks &&
-            !hasSkills &&
-            !hasAgents &&
-            !hasPresets) {
-            throw new Error(`Root directory must contain at least one of: rules/, commands/, skills/, agents/, hooks.json, or have presets configured`);
-        }
-    }
-    else if (!isWorkspaceMode && !hasPresets) {
-        // If no rootDir specified and not in workspace mode, must have presets
-        throw new Error(`At least one of rootDir or presets must be specified in config at ${configFilePath}`);
-    }
-    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(", ")}`);
-            }
-        }
-    }
-}
-async function loadRulesFromDirectory(directoryPath, source, presetName) {
-    const rules = [];
-    if (!fs_extra_1.default.existsSync(directoryPath)) {
-        return rules;
-    }
-    const pattern = node_path_1.default.join(directoryPath, "**/*.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 source directory
-        const relativePath = node_path_1.default.relative(directoryPath, filePath);
-        const ruleName = relativePath.replace(/\.mdc$/, "").replace(/\\/g, "/");
-        rules.push({
-            name: ruleName,
-            content,
-            sourcePath: filePath,
-            source,
-            presetName,
-        });
-    }
-    return rules;
-}
-async function loadCommandsFromDirectory(directoryPath, source, presetName) {
-    const commands = [];
-    if (!fs_extra_1.default.existsSync(directoryPath)) {
-        return commands;
-    }
-    const pattern = node_path_1.default.join(directoryPath, "**/*.md").replace(/\\/g, "/");
-    const filePaths = await (0, fast_glob_1.default)(pattern, {
-        onlyFiles: true,
-        absolute: true,
-    });
-    filePaths.sort();
-    for (const filePath of filePaths) {
-        const content = await fs_extra_1.default.readFile(filePath, "utf8");
-        const relativePath = node_path_1.default.relative(directoryPath, filePath);
-        const commandName = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
-        commands.push({
-            name: commandName,
-            content,
-            sourcePath: filePath,
-            source,
-            presetName,
-        });
-    }
-    return commands;
-}
-async function loadAssetsFromDirectory(directoryPath, source, presetName) {
-    const assets = [];
-    if (!fs_extra_1.default.existsSync(directoryPath)) {
-        return assets;
-    }
-    // Find all files except .mdc files and hidden files
-    const pattern = node_path_1.default.join(directoryPath, "**/*").replace(/\\/g, "/");
-    const filePaths = await (0, fast_glob_1.default)(pattern, {
-        onlyFiles: true,
-        absolute: true,
-        ignore: ["**/*.mdc", "**/.*"],
-    });
-    for (const filePath of filePaths) {
-        const content = await fs_extra_1.default.readFile(filePath);
-        // Preserve directory structure by using relative path from source directory
-        const relativePath = node_path_1.default.relative(directoryPath, filePath);
-        // Keep extension for assets
-        const assetName = relativePath.replace(/\\/g, "/");
-        assets.push({
-            name: assetName,
-            content,
-            sourcePath: filePath,
-            source,
-            presetName,
-        });
-    }
-    return assets;
-}
-/**
- * Load skills from a skills/ directory
- * Each direct subdirectory containing a SKILL.md file is considered a skill
- */
-async function loadSkillsFromDirectory(directoryPath, source, presetName) {
-    const skills = [];
-    if (!fs_extra_1.default.existsSync(directoryPath)) {
-        return skills;
-    }
-    // Get all direct subdirectories
-    const entries = await fs_extra_1.default.readdir(directoryPath, { withFileTypes: true });
-    for (const entry of entries) {
-        if (!entry.isDirectory()) {
-            continue;
-        }
-        const skillPath = node_path_1.default.join(directoryPath, entry.name);
-        const skillMdPath = node_path_1.default.join(skillPath, "SKILL.md");
-        // Only include directories that contain a SKILL.md file
-        if (!fs_extra_1.default.existsSync(skillMdPath)) {
-            continue;
-        }
-        skills.push({
-            name: entry.name,
-            sourcePath: skillPath,
-            source,
-            presetName,
-        });
-    }
-    return skills;
-}
-/**
- * Load agents from an agents/ directory
- * Agents are markdown files (.md) with YAML frontmatter
- */
-async function loadAgentsFromDirectory(directoryPath, source, presetName) {
-    const agents = [];
-    if (!fs_extra_1.default.existsSync(directoryPath)) {
-        return agents;
-    }
-    const pattern = node_path_1.default.join(directoryPath, "**/*.md").replace(/\\/g, "/");
-    const filePaths = await (0, fast_glob_1.default)(pattern, {
-        onlyFiles: true,
-        absolute: true,
-    });
-    filePaths.sort();
-    for (const filePath of filePaths) {
-        const content = await fs_extra_1.default.readFile(filePath, "utf8");
-        const relativePath = node_path_1.default.relative(directoryPath, filePath);
-        const agentName = relativePath.replace(/\.md$/, "").replace(/\\/g, "/");
-        agents.push({
-            name: agentName,
-            content,
-            sourcePath: filePath,
-            source,
-            presetName,
-        });
-    }
-    return agents;
-}
-/**
- * Extract namespace from preset path for directory structure
- * Handles both npm packages and local paths consistently
- */
-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 && part !== "." && part !== "..");
-}
-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"}`);
-    }
-    const presetDir = node_path_1.default.dirname(resolvedPresetPath);
-    const presetRootDir = node_path_1.default.resolve(presetDir, presetConfig.rootDir || "./");
-    // Check for at least one valid subdirectory
-    const hasRules = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "rules"));
-    const hasCommands = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "commands"));
-    const hasHooks = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "hooks.json"));
-    const hasAssets = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "assets"));
-    const hasSkills = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "skills"));
-    const hasAgents = fs_extra_1.default.existsSync(node_path_1.default.join(presetRootDir, "agents"));
-    if (!hasRules &&
-        !hasCommands &&
-        !hasHooks &&
-        !hasAssets &&
-        !hasSkills &&
-        !hasAgents) {
-        throw new Error(`Preset "${presetPath}" must have at least one of: rules/, commands/, skills/, agents/, hooks.json, or assets/`);
-    }
-    return {
-        config: presetConfig,
-        rootDir: presetRootDir,
-    };
-}
-async function loadAllRules(config, cwd) {
-    const allRules = [];
-    const allCommands = [];
-    const allAssets = [];
-    const allSkills = [];
-    const allAgents = [];
-    const allHookFiles = [];
-    const allHooksConfigs = [];
-    let mergedMcpServers = { ...config.mcpServers };
-    // Load local files from rootDir only if specified
-    if (config.rootDir) {
-        const rootPath = node_path_1.default.resolve(cwd, config.rootDir);
-        // Load rules from rules/ subdirectory
-        const rulesPath = node_path_1.default.join(rootPath, "rules");
-        if (fs_extra_1.default.existsSync(rulesPath)) {
-            const localRules = await loadRulesFromDirectory(rulesPath, "local");
-            allRules.push(...localRules);
-        }
-        // Load commands from commands/ subdirectory
-        const commandsPath = node_path_1.default.join(rootPath, "commands");
-        if (fs_extra_1.default.existsSync(commandsPath)) {
-            const localCommands = await loadCommandsFromDirectory(commandsPath, "local");
-            allCommands.push(...localCommands);
-        }
-        // Load hooks from hooks.json (sibling to hooks/ directory)
-        const hooksFilePath = node_path_1.default.join(rootPath, "hooks.json");
-        if (fs_extra_1.default.existsSync(hooksFilePath)) {
-            const { config: localHooksConfig, files: localHookFiles } = await (0, hooks_1.loadHooksFromDirectory)(rootPath, "local");
-            allHooksConfigs.push(localHooksConfig);
-            allHookFiles.push(...localHookFiles);
-        }
-        // Load assets from assets/ subdirectory
-        const assetsPath = node_path_1.default.join(rootPath, "assets");
-        if (fs_extra_1.default.existsSync(assetsPath)) {
-            const localAssets = await loadAssetsFromDirectory(assetsPath, "local");
-            allAssets.push(...localAssets);
-        }
-        // Load skills from skills/ subdirectory
-        const skillsPath = node_path_1.default.join(rootPath, "skills");
-        if (fs_extra_1.default.existsSync(skillsPath)) {
-            const localSkills = await loadSkillsFromDirectory(skillsPath, "local");
-            allSkills.push(...localSkills);
-        }
-        // Load agents from agents/ subdirectory
-        const agentsPath = node_path_1.default.join(rootPath, "agents");
-        if (fs_extra_1.default.existsSync(agentsPath)) {
-            const localAgents = await loadAgentsFromDirectory(agentsPath, "local");
-            allAgents.push(...localAgents);
-        }
-    }
-    // Load presets
-    if (config.presets) {
-        for (const presetPath of config.presets) {
-            const preset = await loadPreset(presetPath, cwd);
-            const presetRootDir = preset.rootDir;
-            // Load preset rules from rules/ subdirectory
-            const presetRulesPath = node_path_1.default.join(presetRootDir, "rules");
-            if (fs_extra_1.default.existsSync(presetRulesPath)) {
-                const presetRules = await loadRulesFromDirectory(presetRulesPath, "preset", presetPath);
-                allRules.push(...presetRules);
-            }
-            // Load preset commands from commands/ subdirectory
-            const presetCommandsPath = node_path_1.default.join(presetRootDir, "commands");
-            if (fs_extra_1.default.existsSync(presetCommandsPath)) {
-                const presetCommands = await loadCommandsFromDirectory(presetCommandsPath, "preset", presetPath);
-                allCommands.push(...presetCommands);
-            }
-            // Load preset hooks from hooks.json (sibling to hooks/ directory)
-            const presetHooksFile = node_path_1.default.join(presetRootDir, "hooks.json");
-            if (fs_extra_1.default.existsSync(presetHooksFile)) {
-                const { config: presetHooksConfig, files: presetHookFiles } = await (0, hooks_1.loadHooksFromDirectory)(presetRootDir, "preset", presetPath);
-                allHooksConfigs.push(presetHooksConfig);
-                allHookFiles.push(...presetHookFiles);
-            }
-            // Load preset assets from assets/ subdirectory
-            const presetAssetsPath = node_path_1.default.join(presetRootDir, "assets");
-            if (fs_extra_1.default.existsSync(presetAssetsPath)) {
-                const presetAssets = await loadAssetsFromDirectory(presetAssetsPath, "preset", presetPath);
-                allAssets.push(...presetAssets);
-            }
-            // Load preset skills from skills/ subdirectory
-            const presetSkillsPath = node_path_1.default.join(presetRootDir, "skills");
-            if (fs_extra_1.default.existsSync(presetSkillsPath)) {
-                const presetSkills = await loadSkillsFromDirectory(presetSkillsPath, "preset", presetPath);
-                allSkills.push(...presetSkills);
-            }
-            // Load preset agents from agents/ subdirectory
-            const presetAgentsPath = node_path_1.default.join(presetRootDir, "agents");
-            if (fs_extra_1.default.existsSync(presetAgentsPath)) {
-                const presetAgents = await loadAgentsFromDirectory(presetAgentsPath, "preset", presetPath);
-                allAgents.push(...presetAgents);
-            }
-            // Merge MCP servers from preset
-            if (preset.config.mcpServers) {
-                mergedMcpServers = mergePresetMcpServers(mergedMcpServers, preset.config.mcpServers);
-            }
-        }
-    }
-    // Merge all hooks configurations
-    const mergedHooks = (0, hooks_1.mergeHooksConfigs)(allHooksConfigs);
-    return {
-        rules: allRules,
-        commands: allCommands,
-        assets: allAssets,
-        skills: allSkills,
-        agents: allAgents,
-        mcpServers: mergedMcpServers,
-        hooks: mergedHooks,
-        hookFiles: allHookFiles,
-    };
-}
-/**
- * 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 (local config takes precedence)
-        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"}`);
-    }
-}
-/**
- * Check if workspaces mode is enabled without loading all rules/presets
- * This is useful for commands that only need to know the workspace setting
- */
-async function checkWorkspacesEnabled(cwd) {
-    const workingDir = cwd || process.cwd();
-    const configResult = await loadConfigFile(workingDir);
-    if (!(configResult === null || configResult === void 0 ? void 0 : configResult.config)) {
-        return detectWorkspacesFromPackageJson(workingDir);
-    }
-    return resolveWorkspaces(configResult.config, configResult.filepath, workingDir);
-}
-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;
-    }
-    const config = configResult.config;
-    const isWorkspaces = resolveWorkspaces(config, configResult.filepath, workingDir);
-    validateConfig(config, configResult.filepath, workingDir, isWorkspaces);
-    const configWithDefaults = applyDefaults(config, isWorkspaces);
-    const { rules, commands, assets, skills, agents, mcpServers, hooks, hookFiles, } = await loadAllRules(configWithDefaults, workingDir);
-    return {
-        config: configWithDefaults,
-        rules,
-        commands,
-        assets,
-        skills,
-        agents,
-        mcpServers,
-        hooks,
-        hookFiles,
-    };
-}
-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;
-    }
-}