aicm 0.20.1 → 0.20.6

package/dist/utils/config.d.ts

@@ -96,6 +96,7 @@ export declare function resolvePresetPath(presetPath: string, cwd: string): stri
 export declare function loadPreset(presetPath: string, cwd: string): Promise<{
     config: Config;
     rootDir: string;
+    resolvedPath: string;
 }>;
 export declare function loadAllRules(config: Config, cwd: string): Promise<{
     rules: RuleFile[];

package/dist/utils/config.js

@@ -277,7 +277,8 @@ function extractNamespaceFromPresetPath(presetPath) {
         // For scoped packages like @scope/package/subdir, create nested directories
         return presetPath.split("/");
     }
-    const parts = presetPath.split(node_path_1.default.sep);
+    // Always split by forward slash since JSON config files use forward slashes on all platforms
+    const parts = presetPath.split(node_path_1.default.posix.sep);
     return parts.filter((part) => part.length > 0 && part !== "." && part !== "..");
 }
 function resolvePresetPath(presetPath, cwd) {
@@ -318,26 +319,110 @@ async function loadPreset(presetPath, cwd) {
     }
     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
+    // Check if preset has content or inherits from other presets
     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/`);
+    const hasNestedPresets = Array.isArray(presetConfig.presets) && presetConfig.presets.length > 0;
+    const hasAnyContent = hasRules ||
+        hasCommands ||
+        hasHooks ||
+        hasAssets ||
+        hasSkills ||
+        hasAgents ||
+        hasNestedPresets;
+    if (!hasAnyContent) {
+        throw new Error(`Preset "${presetPath}" must have at least one of: rules/, commands/, skills/, agents/, hooks.json, assets/, or presets`);
     }
     return {
         config: presetConfig,
         rootDir: presetRootDir,
+        resolvedPath: resolvedPresetPath,
     };
 }
+/**
+ * Recursively load a preset and all its dependencies
+ * @param presetPath The original preset path (used for namespacing)
+ * @param cwd The current working directory for resolving paths
+ * @param visited Set of already visited preset paths (by resolved absolute path) for cycle detection
+ */
+async function loadPresetRecursively(presetPath, cwd, visited) {
+    const preset = await loadPreset(presetPath, cwd);
+    const presetRootDir = preset.rootDir;
+    const presetDir = node_path_1.default.dirname(preset.resolvedPath);
+    // Check for circular dependency
+    if (visited.has(preset.resolvedPath)) {
+        throw new Error(`Circular preset dependency detected: "${presetPath}" has already been loaded`);
+    }
+    visited.add(preset.resolvedPath);
+    const result = {
+        rules: [],
+        commands: [],
+        assets: [],
+        skills: [],
+        agents: [],
+        mcpServers: {},
+        hooksConfigs: [],
+        hookFiles: [],
+    };
+    // Load entities from this preset's rootDir
+    const presetRulesPath = node_path_1.default.join(presetRootDir, "rules");
+    if (fs_extra_1.default.existsSync(presetRulesPath)) {
+        const presetRules = await loadRulesFromDirectory(presetRulesPath, "preset", presetPath);
+        result.rules.push(...presetRules);
+    }
+    const presetCommandsPath = node_path_1.default.join(presetRootDir, "commands");
+    if (fs_extra_1.default.existsSync(presetCommandsPath)) {
+        const presetCommands = await loadCommandsFromDirectory(presetCommandsPath, "preset", presetPath);
+        result.commands.push(...presetCommands);
+    }
+    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);
+        result.hooksConfigs.push(presetHooksConfig);
+        result.hookFiles.push(...presetHookFiles);
+    }
+    const presetAssetsPath = node_path_1.default.join(presetRootDir, "assets");
+    if (fs_extra_1.default.existsSync(presetAssetsPath)) {
+        const presetAssets = await loadAssetsFromDirectory(presetAssetsPath, "preset", presetPath);
+        result.assets.push(...presetAssets);
+    }
+    const presetSkillsPath = node_path_1.default.join(presetRootDir, "skills");
+    if (fs_extra_1.default.existsSync(presetSkillsPath)) {
+        const presetSkills = await loadSkillsFromDirectory(presetSkillsPath, "preset", presetPath);
+        result.skills.push(...presetSkills);
+    }
+    const presetAgentsPath = node_path_1.default.join(presetRootDir, "agents");
+    if (fs_extra_1.default.existsSync(presetAgentsPath)) {
+        const presetAgents = await loadAgentsFromDirectory(presetAgentsPath, "preset", presetPath);
+        result.agents.push(...presetAgents);
+    }
+    // Add MCP servers from this preset
+    if (preset.config.mcpServers) {
+        result.mcpServers = { ...preset.config.mcpServers };
+    }
+    // Recursively load nested presets
+    if (preset.config.presets && preset.config.presets.length > 0) {
+        for (const nestedPresetPath of preset.config.presets) {
+            const nestedResult = await loadPresetRecursively(nestedPresetPath, presetDir, // Use preset's directory as cwd for relative paths
+            visited);
+            // Merge results from nested preset
+            result.rules.push(...nestedResult.rules);
+            result.commands.push(...nestedResult.commands);
+            result.assets.push(...nestedResult.assets);
+            result.skills.push(...nestedResult.skills);
+            result.agents.push(...nestedResult.agents);
+            result.hooksConfigs.push(...nestedResult.hooksConfigs);
+            result.hookFiles.push(...nestedResult.hookFiles);
+            // Merge MCP servers (current preset takes precedence over nested)
+            result.mcpServers = mergePresetMcpServers(result.mcpServers, nestedResult.mcpServers);
+        }
+    }
+    return result;
+}
 async function loadAllRules(config, cwd) {
     const allRules = [];
     const allCommands = [];
@@ -388,52 +473,20 @@ async function loadAllRules(config, cwd) {
             allAgents.push(...localAgents);
         }
     }
-    // Load presets
-    if (config.presets) {
+    // Load presets recursively
+    if (config.presets && config.presets.length > 0) {
+        const visited = new Set();
         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);
-            }
+            const presetResult = await loadPresetRecursively(presetPath, cwd, visited);
+            allRules.push(...presetResult.rules);
+            allCommands.push(...presetResult.commands);
+            allAssets.push(...presetResult.assets);
+            allSkills.push(...presetResult.skills);
+            allAgents.push(...presetResult.agents);
+            allHooksConfigs.push(...presetResult.hooksConfigs);
+            allHookFiles.push(...presetResult.hookFiles);
+            // Merge MCP servers (local config takes precedence)
+            mergedMcpServers = mergePresetMcpServers(mergedMcpServers, presetResult.mcpServers);
         }
     }
     // Merge all hooks configurations

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aicm",
-  "version": "0.20.1",
+  "version": "0.20.6",
   "description": "A TypeScript CLI tool for managing AI IDE rules across different projects and teams",
   "main": "dist/api.js",
   "types": "dist/api.d.ts",
@@ -25,7 +25,7 @@
     "lint": "eslint",
     "prepare": "husky install && npx ts-node src/bin/aicm.ts install",
     "version": "auto-changelog -p && git add CHANGELOG.md",
-    "release": "np --no-tests"
+    "release": "np --no-tests --no-publish"
   },
   "keywords": [
     "ai",
@@ -37,6 +37,10 @@
   ],
   "author": "Ran Yitzhaki <ranyitz@gmail.com>",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ranyitz/aicm"
+  },
   "dependencies": {
     "arg": "^5.0.2",
     "chalk": "^4.1.2",

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

@@ -1,10 +0,0 @@
-/**
- * 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

@@ -1,28 +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.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;
-}