aicm 0.19.1 → 0.20.1

package/dist/commands/install.d.ts

@@ -1,4 +1,4 @@
-import { ResolvedConfig, CommandFile, AssetFile, MCPServers, SupportedTarget } from "../utils/config";
+import { ResolvedConfig, CommandFile, AssetFile, SkillFile, AgentFile, MCPServers, SupportedTarget } from "../utils/config";
 export interface InstallOptions {
     /**
      * Base directory to use instead of process.cwd()
@@ -49,6 +49,14 @@ export interface InstallResult {
      * Number of hooks installed
      */
     installedHookCount: number;
+    /**
+     * Number of skills installed
+     */
+    installedSkillCount: number;
+    /**
+     * Number of agents installed
+     */
+    installedAgentCount: number;
     /**
      * Number of packages installed
      */
@@ -56,6 +64,32 @@ export interface InstallResult {
 }
 export declare function writeAssetsToTargets(assets: AssetFile[], targets: SupportedTarget[]): void;
 export declare function writeCommandsToTargets(commands: CommandFile[], targets: SupportedTarget[]): void;
+/**
+ * Write skills to all supported target directories
+ */
+export declare function writeSkillsToTargets(skills: SkillFile[], targets: SupportedTarget[]): void;
+/**
+ * Warn about skill name collisions from different presets
+ */
+export declare function warnPresetSkillCollisions(skills: SkillFile[]): void;
+/**
+ * Dedupe skills by name (last one wins)
+ */
+export declare function dedupeSkillsForInstall(skills: SkillFile[]): SkillFile[];
+/**
+ * Write agents to all supported target directories
+ * Similar to skills, agents are written directly to the agents directory
+ * with a .aicm.json metadata file tracking which agents are managed
+ */
+export declare function writeAgentsToTargets(agents: AgentFile[], targets: SupportedTarget[]): void;
+/**
+ * Warn about agent name collisions from different presets
+ */
+export declare function warnPresetAgentCollisions(agents: AgentFile[]): void;
+/**
+ * Dedupe agents by name (last one wins)
+ */
+export declare function dedupeAgentsForInstall(agents: AgentFile[]): AgentFile[];
 export declare function warnPresetCommandCollisions(commands: CommandFile[]): void;
 export declare function dedupeCommandsForInstall(commands: CommandFile[]): CommandFile[];
 /**

package/dist/commands/install.js

@@ -5,6 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeAssetsToTargets = writeAssetsToTargets;
 exports.writeCommandsToTargets = writeCommandsToTargets;
+exports.writeSkillsToTargets = writeSkillsToTargets;
+exports.warnPresetSkillCollisions = warnPresetSkillCollisions;
+exports.dedupeSkillsForInstall = dedupeSkillsForInstall;
+exports.writeAgentsToTargets = writeAgentsToTargets;
+exports.warnPresetAgentCollisions = warnPresetAgentCollisions;
+exports.dedupeAgentsForInstall = dedupeAgentsForInstall;
 exports.warnPresetCommandCollisions = warnPresetCommandCollisions;
 exports.dedupeCommandsForInstall = dedupeCommandsForInstall;
 exports.writeMcpServersToFile = writeMcpServersToFile;
@@ -228,6 +234,214 @@ function writeCommandsToTargets(commands, targets) {
         // Other targets do not support commands yet
     }
 }
+/**
+ * Get the skills installation path for a target
+ * Returns null for targets that don't support skills
+ */
+function getSkillsTargetPath(target) {
+    const projectDir = process.cwd();
+    switch (target) {
+        case "cursor":
+            return node_path_1.default.join(projectDir, ".cursor", "skills");
+        case "claude":
+            return node_path_1.default.join(projectDir, ".claude", "skills");
+        case "codex":
+            return node_path_1.default.join(projectDir, ".codex", "skills");
+        case "windsurf":
+            // Windsurf does not support skills
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Write a single skill to the target directory
+ * Copies the entire skill directory and writes .aicm.json metadata
+ */
+function writeSkillToTarget(skill, targetSkillsDir) {
+    const skillTargetPath = node_path_1.default.join(targetSkillsDir, skill.name);
+    // Remove existing skill directory if it exists (to ensure clean install)
+    if (fs_extra_1.default.existsSync(skillTargetPath)) {
+        fs_extra_1.default.removeSync(skillTargetPath);
+    }
+    // Copy the entire skill directory
+    fs_extra_1.default.copySync(skill.sourcePath, skillTargetPath);
+    // Write .aicm.json metadata file
+    // The presence of this file indicates the skill is managed by aicm
+    const metadata = {
+        source: skill.source,
+    };
+    if (skill.presetName) {
+        metadata.presetName = skill.presetName;
+    }
+    const metadataPath = node_path_1.default.join(skillTargetPath, ".aicm.json");
+    fs_extra_1.default.writeJsonSync(metadataPath, metadata, { spaces: 2 });
+}
+/**
+ * Write skills to all supported target directories
+ */
+function writeSkillsToTargets(skills, targets) {
+    if (skills.length === 0)
+        return;
+    for (const target of targets) {
+        const targetSkillsDir = getSkillsTargetPath(target);
+        if (!targetSkillsDir) {
+            // Target doesn't support skills
+            continue;
+        }
+        // Ensure the skills directory exists
+        fs_extra_1.default.ensureDirSync(targetSkillsDir);
+        for (const skill of skills) {
+            writeSkillToTarget(skill, targetSkillsDir);
+        }
+    }
+}
+/**
+ * Warn about skill name collisions from different presets
+ */
+function warnPresetSkillCollisions(skills) {
+    const collisions = new Map();
+    for (const skill of skills) {
+        if (!skill.presetName)
+            continue;
+        const entry = collisions.get(skill.name);
+        if (entry) {
+            entry.presets.add(skill.presetName);
+            entry.lastPreset = skill.presetName;
+        }
+        else {
+            collisions.set(skill.name, {
+                presets: new Set([skill.presetName]),
+                lastPreset: skill.presetName,
+            });
+        }
+    }
+    for (const [skillName, { presets, lastPreset }] of collisions) {
+        if (presets.size > 1) {
+            const presetList = Array.from(presets).sort().join(", ");
+            console.warn(chalk_1.default.yellow(`Warning: multiple presets provide the "${skillName}" skill (${presetList}). Using definition from ${lastPreset}.`));
+        }
+    }
+}
+/**
+ * Dedupe skills by name (last one wins)
+ */
+function dedupeSkillsForInstall(skills) {
+    const unique = new Map();
+    for (const skill of skills) {
+        unique.set(skill.name, skill);
+    }
+    return Array.from(unique.values());
+}
+/**
+ * Get the agents installation path for a target
+ * Returns null for targets that don't support agents
+ */
+function getAgentsTargetPath(target) {
+    const projectDir = process.cwd();
+    switch (target) {
+        case "cursor":
+            return node_path_1.default.join(projectDir, ".cursor", "agents");
+        case "claude":
+            return node_path_1.default.join(projectDir, ".claude", "agents");
+        case "codex":
+        case "windsurf":
+            // Codex and Windsurf do not support agents
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Write agents to all supported target directories
+ * Similar to skills, agents are written directly to the agents directory
+ * with a .aicm.json metadata file tracking which agents are managed
+ */
+function writeAgentsToTargets(agents, targets) {
+    if (agents.length === 0)
+        return;
+    for (const target of targets) {
+        const targetAgentsDir = getAgentsTargetPath(target);
+        if (!targetAgentsDir) {
+            // Target doesn't support agents
+            continue;
+        }
+        // Ensure the agents directory exists
+        fs_extra_1.default.ensureDirSync(targetAgentsDir);
+        // Read existing metadata to clean up old managed agents
+        const metadataPath = node_path_1.default.join(targetAgentsDir, ".aicm.json");
+        if (fs_extra_1.default.existsSync(metadataPath)) {
+            try {
+                const existingMetadata = fs_extra_1.default.readJsonSync(metadataPath);
+                // Remove previously managed agents
+                for (const agentName of existingMetadata.managedAgents || []) {
+                    // Skip invalid names containing path separators
+                    if (agentName.includes("/") || agentName.includes("\\")) {
+                        console.warn(chalk_1.default.yellow(`Warning: Skipping invalid agent name "${agentName}" (contains path separator)`));
+                        continue;
+                    }
+                    const fullPath = node_path_1.default.join(targetAgentsDir, agentName + ".md");
+                    if (fs_extra_1.default.existsSync(fullPath)) {
+                        fs_extra_1.default.removeSync(fullPath);
+                    }
+                }
+            }
+            catch (_a) {
+                // Ignore errors reading metadata
+            }
+        }
+        const managedAgents = [];
+        for (const agent of agents) {
+            // Use base name only
+            const agentName = node_path_1.default.basename(agent.name, node_path_1.default.extname(agent.name));
+            const agentFile = node_path_1.default.join(targetAgentsDir, agentName + ".md");
+            fs_extra_1.default.writeFileSync(agentFile, agent.content);
+            managedAgents.push(agentName);
+        }
+        // Write metadata file to track managed agents
+        const metadata = {
+            managedAgents,
+        };
+        fs_extra_1.default.writeJsonSync(metadataPath, metadata, { spaces: 2 });
+    }
+}
+/**
+ * Warn about agent name collisions from different presets
+ */
+function warnPresetAgentCollisions(agents) {
+    const collisions = new Map();
+    for (const agent of agents) {
+        if (!agent.presetName)
+            continue;
+        const entry = collisions.get(agent.name);
+        if (entry) {
+            entry.presets.add(agent.presetName);
+            entry.lastPreset = agent.presetName;
+        }
+        else {
+            collisions.set(agent.name, {
+                presets: new Set([agent.presetName]),
+                lastPreset: agent.presetName,
+            });
+        }
+    }
+    for (const [agentName, { presets, lastPreset }] of collisions) {
+        if (presets.size > 1) {
+            const presetList = Array.from(presets).sort().join(", ");
+            console.warn(chalk_1.default.yellow(`Warning: multiple presets provide the "${agentName}" agent (${presetList}). Using definition from ${lastPreset}.`));
+        }
+    }
+}
+/**
+ * Dedupe agents by name (last one wins)
+ */
+function dedupeAgentsForInstall(agents) {
+    const unique = new Map();
+    for (const agent of agents) {
+        unique.set(agent.name, agent);
+    }
+    return Array.from(unique.values());
+}
 function warnPresetCommandCollisions(commands) {
     const collisions = new Map();
     for (const command of commands) {
@@ -348,10 +562,12 @@ async function installPackage(options = {}) {
                 installedCommandCount: 0,
                 installedAssetCount: 0,
                 installedHookCount: 0,
+                installedSkillCount: 0,
+                installedAgentCount: 0,
                 packagesCount: 0,
             };
         }
-        const { config, rules, commands, assets, mcpServers, hooks, hookFiles } = resolvedConfig;
+        const { config, rules, commands, assets, skills, agents, mcpServers, hooks, hookFiles, } = resolvedConfig;
         if (config.skipInstall === true) {
             return {
                 success: true,
@@ -359,15 +575,23 @@ async function installPackage(options = {}) {
                 installedCommandCount: 0,
                 installedAssetCount: 0,
                 installedHookCount: 0,
+                installedSkillCount: 0,
+                installedAgentCount: 0,
                 packagesCount: 0,
             };
         }
         warnPresetCommandCollisions(commands);
         const commandsToInstall = dedupeCommandsForInstall(commands);
+        warnPresetSkillCollisions(skills);
+        const skillsToInstall = dedupeSkillsForInstall(skills);
+        warnPresetAgentCollisions(agents);
+        const agentsToInstall = dedupeAgentsForInstall(agents);
         try {
             if (!options.dryRun) {
                 writeRulesToTargets(rules, assets, config.targets);
                 writeCommandsToTargets(commandsToInstall, config.targets);
+                writeSkillsToTargets(skillsToInstall, config.targets);
+                writeAgentsToTargets(agentsToInstall, config.targets);
                 if (mcpServers && Object.keys(mcpServers).length > 0) {
                     writeMcpServersToTargets(mcpServers, config.targets, cwd);
                 }
@@ -378,12 +602,16 @@ async function installPackage(options = {}) {
             const uniqueRuleCount = new Set(rules.map((rule) => rule.name)).size;
             const uniqueCommandCount = new Set(commandsToInstall.map((command) => command.name)).size;
             const uniqueHookCount = (0, hooks_1.countHooks)(hooks);
+            const uniqueSkillCount = skillsToInstall.length;
+            const uniqueAgentCount = agentsToInstall.length;
             return {
                 success: true,
                 installedRuleCount: uniqueRuleCount,
                 installedCommandCount: uniqueCommandCount,
                 installedAssetCount: assets.length,
                 installedHookCount: uniqueHookCount,
+                installedSkillCount: uniqueSkillCount,
+                installedAgentCount: uniqueAgentCount,
                 packagesCount: 1,
             };
         }
@@ -395,6 +623,8 @@ async function installPackage(options = {}) {
                 installedCommandCount: 0,
                 installedAssetCount: 0,
                 installedHookCount: 0,
+                installedSkillCount: 0,
+                installedAgentCount: 0,
                 packagesCount: 0,
             };
         }
@@ -415,6 +645,8 @@ async function install(options = {}) {
             installedCommandCount: 0,
             installedAssetCount: 0,
             installedHookCount: 0,
+            installedSkillCount: 0,
+            installedAgentCount: 0,
             packagesCount: 0,
         };
     }
@@ -447,11 +679,19 @@ async function installCommand(installOnCI, verbose, dryRun) {
         const ruleCount = result.installedRuleCount;
         const commandCount = result.installedCommandCount;
         const hookCount = result.installedHookCount;
+        const skillCount = result.installedSkillCount;
+        const agentCount = result.installedAgentCount;
         const ruleMessage = ruleCount > 0 ? `${ruleCount} rule${ruleCount === 1 ? "" : "s"}` : null;
         const commandMessage = commandCount > 0
             ? `${commandCount} command${commandCount === 1 ? "" : "s"}`
             : null;
         const hookMessage = hookCount > 0 ? `${hookCount} hook${hookCount === 1 ? "" : "s"}` : null;
+        const skillMessage = skillCount > 0
+            ? `${skillCount} skill${skillCount === 1 ? "" : "s"}`
+            : null;
+        const agentMessage = agentCount > 0
+            ? `${agentCount} agent${agentCount === 1 ? "" : "s"}`
+            : null;
         const countsParts = [];
         if (ruleMessage) {
             countsParts.push(ruleMessage);
@@ -462,6 +702,12 @@ async function installCommand(installOnCI, verbose, dryRun) {
         if (hookMessage) {
             countsParts.push(hookMessage);
         }
+        if (skillMessage) {
+            countsParts.push(skillMessage);
+        }
+        if (agentMessage) {
+            countsParts.push(agentMessage);
+        }
         const countsMessage = countsParts.length > 0
             ? countsParts.join(", ").replace(/, ([^,]*)$/, " and $1")
             : "0 rules";
@@ -473,8 +719,12 @@ async function installCommand(installOnCI, verbose, dryRun) {
                 console.log(`Dry run: validated ${countsMessage}`);
             }
         }
-        else if (ruleCount === 0 && commandCount === 0 && hookCount === 0) {
-            console.log("No rules, commands, or hooks installed");
+        else if (ruleCount === 0 &&
+            commandCount === 0 &&
+            hookCount === 0 &&
+            skillCount === 0 &&
+            agentCount === 0) {
+            console.log("No rules, commands, hooks, skills, or agents installed");
         }
         else if (result.packagesCount > 1) {
             console.log(`Successfully installed ${countsMessage} across ${result.packagesCount} packages`);

package/dist/utils/config.d.ts

@@ -46,6 +46,13 @@ export interface AssetFile {
 }
 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[];
 }
@@ -54,6 +61,8 @@ export interface ResolvedConfig {
     rules: RuleFile[];
     commands: CommandFile[];
     assets: AssetFile[];
+    skills: SkillFile[];
+    agents: AgentFile[];
     mcpServers: MCPServers;
     hooks: HooksJson;
     hookFiles: HookFile[];
@@ -68,6 +77,16 @@ export declare function validateConfig(config: unknown, configFilePath: string,
 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
@@ -82,6 +101,8 @@ 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[];

package/dist/utils/config.js

@@ -11,6 +11,8 @@ 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;
@@ -96,14 +98,18 @@ function validateConfig(config, configFilePath, cwd, isWorkspaceMode = false) {
         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/, hooks.json, or have presets configured`);
+            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) {
@@ -202,6 +208,65 @@ async function loadAssetsFromDirectory(directoryPath, 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
@@ -258,8 +323,15 @@ async function loadPreset(presetPath, cwd) {
     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"));
-    if (!hasRules && !hasCommands && !hasHooks && !hasAssets) {
-        throw new Error(`Preset "${presetPath}" must have at least one of: rules/, commands/, hooks.json, or 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,
@@ -270,6 +342,8 @@ async function loadAllRules(config, cwd) {
     const allRules = [];
     const allCommands = [];
     const allAssets = [];
+    const allSkills = [];
+    const allAgents = [];
     const allHookFiles = [];
     const allHooksConfigs = [];
     let mergedMcpServers = { ...config.mcpServers };
@@ -301,6 +375,18 @@ async function loadAllRules(config, cwd) {
             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) {
@@ -332,6 +418,18 @@ async function loadAllRules(config, cwd) {
                 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);
@@ -344,6 +442,8 @@ async function loadAllRules(config, cwd) {
         rules: allRules,
         commands: allCommands,
         assets: allAssets,
+        skills: allSkills,
+        agents: allAgents,
         mcpServers: mergedMcpServers,
         hooks: mergedHooks,
         hookFiles: allHookFiles,
@@ -403,12 +503,14 @@ async function loadConfig(cwd) {
     const isWorkspaces = resolveWorkspaces(config, configResult.filepath, workingDir);
     validateConfig(config, configResult.filepath, workingDir, isWorkspaces);
     const configWithDefaults = applyDefaults(config, isWorkspaces);
-    const { rules, commands, assets, mcpServers, hooks, hookFiles } = await loadAllRules(configWithDefaults, workingDir);
+    const { rules, commands, assets, skills, agents, mcpServers, hooks, hookFiles, } = await loadAllRules(configWithDefaults, workingDir);
     return {
         config: configWithDefaults,
         rules,
         commands,
         assets,
+        skills,
+        agents,
         mcpServers,
         hooks,
         hookFiles,

package/dist/utils/safe-path.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Check if a resolved path is safely within the specified base directory.
+ * This prevents path traversal attacks where malicious paths like "../../../etc"
+ * or absolute paths could escape the intended directory.
+ *
+ * @param baseDir - The directory that should contain the path
+ * @param relativePath - The potentially untrusted relative path
+ * @returns The safely resolved full path, or null if the path would escape baseDir
+ */
+export declare function resolveSafePath(baseDir: string, relativePath: string): string | null;

package/dist/utils/safe-path.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSafePath = resolveSafePath;
+const node_path_1 = __importDefault(require("node:path"));
+/**
+ * Check if a resolved path is safely within the specified base directory.
+ * This prevents path traversal attacks where malicious paths like "../../../etc"
+ * or absolute paths could escape the intended directory.
+ *
+ * @param baseDir - The directory that should contain the path
+ * @param relativePath - The potentially untrusted relative path
+ * @returns The safely resolved full path, or null if the path would escape baseDir
+ */
+function resolveSafePath(baseDir, relativePath) {
+    // Resolve both to absolute paths
+    const resolvedBase = node_path_1.default.resolve(baseDir);
+    const resolvedTarget = node_path_1.default.resolve(baseDir, relativePath);
+    // The resolved path must start with the base directory + separator
+    // This ensures it's truly inside the directory, not a sibling with similar prefix
+    // e.g., /foo/bar should not match /foo/bar-other
+    if (!resolvedTarget.startsWith(resolvedBase + node_path_1.default.sep)) {
+        return null;
+    }
+    return resolvedTarget;
+}