aicm 0.14.3 → 0.14.5

package/dist/utils/rule-collector.js

@@ -1,169 +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.findPackageRoot = findPackageRoot;
-exports.initRuleCollection = initRuleCollection;
-exports.addRuleToCollection = addRuleToCollection;
-exports.collectLocalRule = collectLocalRule;
-exports.collectNpmRule = collectNpmRule;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-const mdc_parser_1 = require("./mdc-parser");
-/**
- * Find the root directory of a package by name
- * @param packageName The name of the package
- * @returns The absolute path to the package's root directory
- */
-function findPackageRoot(packageName) {
-    try {
-        // Method 1: Try to use require.resolve
-        const packageEntry = require.resolve(packageName, {
-            paths: [process.cwd()],
-        });
-        // Navigate up until we find a package.json or reach a reasonable limit
-        let currentDir = node_path_1.default.dirname(packageEntry);
-        let iterations = 0;
-        const maxIterations = 3; // Prevent infinite loops
-        while (iterations < maxIterations) {
-            // If we found the package.json, this is likely the package root
-            if (fs_extra_1.default.existsSync(node_path_1.default.join(currentDir, "package.json"))) {
-                return currentDir;
-            }
-            // Move up one directory
-            const parentDir = node_path_1.default.dirname(currentDir);
-            // If we've reached the root or haven't changed directory, stop
-            if (parentDir === currentDir) {
-                break;
-            }
-            currentDir = parentDir;
-            iterations++;
-        }
-        // If we couldn't find package.json, use the directory of the entry point
-        return node_path_1.default.dirname(packageEntry);
-    }
-    catch (_a) {
-        // Method 2: Fall back to direct node_modules resolution
-        const nodeModulesPath = node_path_1.default.resolve(process.cwd(), "node_modules", packageName);
-        if (!fs_extra_1.default.existsSync(nodeModulesPath)) {
-            throw new Error(`Package '${packageName}' not found in node_modules.`);
-        }
-        return nodeModulesPath;
-    }
-}
-/**
- * Initialize an empty rule collection
- */
-function initRuleCollection() {
-    return {
-        cursor: [],
-        windsurf: [],
-        codex: [],
-    };
-}
-/**
- * Add a rule to the collection
- * @param collection The rule collection to add to
- * @param rule The rule content to add
- * @param ides The IDEs to add the rule for
- */
-function addRuleToCollection(collection, rule, ides) {
-    for (const ide of ides) {
-        if (ide === "cursor" &&
-            !collection.cursor.some((r) => r.name === rule.name)) {
-            collection.cursor.push(rule);
-        }
-        else if (ide === "windsurf" &&
-            !collection.windsurf.some((r) => r.name === rule.name)) {
-            collection.windsurf.push(rule);
-        }
-        else if (ide === "codex" &&
-            !collection.codex.some((r) => r.name === rule.name)) {
-            collection.codex.push(rule);
-        }
-    }
-}
-/**
- * Collect a rule from a local file source
- * @param ruleName The name of the rule
- * @param source The source path (relative or absolute)
- * @param ruleBasePath Optional base path for resolving relative paths
- * @returns The rule content
- */
-function collectLocalRule(ruleName, source, ruleBasePath) {
-    if (source === false)
-        throw new Error(`Rule '${ruleName}' is canceled and should not be processed.`);
-    // Resolve path relative to base path or current directory
-    let sourcePath = source;
-    if (!node_path_1.default.isAbsolute(source)) {
-        if (ruleBasePath) {
-            // If a base path is provided (e.g., for presets), resolve relative to that
-            sourcePath = node_path_1.default.resolve(node_path_1.default.dirname(ruleBasePath), source);
-        }
-        else {
-            // Otherwise resolve relative to current directory
-            sourcePath = node_path_1.default.resolve(process.cwd(), source);
-        }
-    }
-    if (!fs_extra_1.default.existsSync(sourcePath)) {
-        throw new Error(`Source file ${sourcePath} not found.`);
-    }
-    // Parse the MDC file to extract metadata and content
-    const { metadata, content } = (0, mdc_parser_1.parseMdcFile)(sourcePath);
-    return {
-        name: ruleName,
-        content,
-        metadata,
-        sourcePath,
-    };
-}
-/**
- * Collect a rule from an npm package
- * @param ruleName The name of the rule
- * @param source The npm package source (can include path)
- * @returns The rule content
- */
-function collectNpmRule(ruleName, source) {
-    if (source === false)
-        throw new Error(`Rule '${ruleName}' is canceled and should not be processed.`);
-    // Parse source into package and file path
-    let packageName;
-    let packagePath;
-    if (source.includes("/") && !source.startsWith("@")) {
-        // Format: "package-name/path/to/file.mdc"
-        const firstSlash = source.indexOf("/");
-        packageName = source.substring(0, firstSlash);
-        packagePath = source.substring(firstSlash + 1);
-    }
-    else if (source.startsWith("@")) {
-        // Format: "@scope/package/path/to/file.mdc"
-        const parts = source.split("/");
-        // @scope/package
-        packageName = `${parts[0]}/${parts[1]}`;
-        // Remaining path, if any
-        packagePath = parts.slice(2).join("/");
-    }
-    else {
-        // Format: "package-name" (whole package)
-        packageName = source;
-        packagePath = "";
-    }
-    // Try to find the package and get its root directory
-    const packageRoot = findPackageRoot(packageName);
-    // Resolve the full path to the rule file
-    const ruleFile = packagePath
-        ? node_path_1.default.join(packageRoot, packagePath)
-        : packageRoot;
-    if (!fs_extra_1.default.existsSync(ruleFile)) {
-        throw new Error(`Rule file not found in package: ${ruleFile}`);
-    }
-    // Parse the MDC file to extract metadata and content
-    const { metadata, content } = (0, mdc_parser_1.parseMdcFile)(ruleFile);
-    return {
-        name: ruleName,
-        content,
-        metadata,
-        sourcePath: ruleFile,
-    };
-}

package/dist/utils/rule-detector.d.ts

@@ -1,4 +0,0 @@
-/**
- * Detects the rule type from the source string
- */
-export declare function detectRuleType(source: string): "npm" | "local";

package/dist/utils/rule-detector.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectRuleType = detectRuleType;
-/**
- * Detects the rule type from the source string
- */
-function detectRuleType(source) {
-    if (source.startsWith("http://") || source.startsWith("https://")) {
-        throw new Error("URL-based rules are not supported due to security concerns. Please use npm packages or local files instead.");
-    }
-    // Check if it's a local file path
-    if (source.startsWith("/") ||
-        source.startsWith("./") ||
-        source.startsWith("../") ||
-        source.startsWith("\\") ||
-        source.startsWith(".\\") ||
-        (source.includes(":\\") && source.includes("\\")) || // Windows absolute path with backslash
-        (source.includes(":") &&
-            (source.startsWith("file:") || source.includes(":\\"))) // Path with protocol or Windows drive letter
-    ) {
-        return "local";
-    }
-    try {
-        const packageName = source.split(/[/\\]/)[0];
-        require.resolve(packageName, { paths: [__dirname, process.cwd()] });
-        return "npm";
-    }
-    catch (_a) {
-        return "local";
-    }
-}

package/dist/utils/rule-status.d.ts

@@ -1,8 +0,0 @@
-/**
- * Get the IDE-specific rule installation paths
- */
-export declare function getIdePaths(): Record<string, string>;
-/**
- * Check if a rule is installed in the specified IDEs
- */
-export declare function checkRuleStatus(ruleName: string, ides: string[]): boolean;

package/dist/utils/rule-status.js

@@ -1,53 +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.getIdePaths = getIdePaths;
-exports.checkRuleStatus = checkRuleStatus;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Get the IDE-specific rule installation paths
- */
-function getIdePaths() {
-    const projectDir = process.cwd(); // Get current working directory (project root)
-    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"),
-    };
-}
-/**
- * Check if a rule is installed in the specified IDEs
- */
-function checkRuleStatus(ruleName, ides) {
-    const idePaths = getIdePaths();
-    return ides.every((ide) => {
-        if (!idePaths[ide]) {
-            return false;
-        }
-        if (ide === "cursor") {
-            return fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.mdc`));
-        }
-        if (ide === "windsurf") {
-            const ruleExists = fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.md`));
-            const windsurfRulesPath = node_path_1.default.join(process.cwd(), ".windsurfrules");
-            if (fs_extra_1.default.existsSync(windsurfRulesPath)) {
-                const windsurfRulesContent = fs_extra_1.default.readFileSync(windsurfRulesPath, "utf8");
-                return (ruleExists && windsurfRulesContent.includes(`.aicm/${ruleName}.md`));
-            }
-            return false;
-        }
-        if (ide === "codex") {
-            const ruleExists = fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.md`));
-            const codexFilePath = node_path_1.default.join(process.cwd(), "AGENTS.md");
-            if (fs_extra_1.default.existsSync(codexFilePath)) {
-                const codexContent = fs_extra_1.default.readFileSync(codexFilePath, "utf8");
-                return ruleExists && codexContent.includes(`.aicm/${ruleName}.md`);
-            }
-            return false;
-        }
-        return false;
-    });
-}

package/dist/utils/rule-writer.d.ts

@@ -1,6 +0,0 @@
-import { RuleCollection } from "../types";
-/**
- * Write all collected rules to their respective IDE targets
- * @param collection The collection of rules to write
- */
-export declare function writeRulesToTargets(collection: RuleCollection): void;

package/dist/utils/rule-writer.js

@@ -1,118 +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.writeRulesToTargets = writeRulesToTargets;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const node_path_1 = __importDefault(require("node:path"));
-const rules_file_writer_1 = require("./rules-file-writer");
-/**
- * Write all collected rules to their respective IDE targets
- * @param collection The collection of rules to write
- */
-function writeRulesToTargets(collection) {
-    // Write Cursor rules
-    if (collection.cursor.length > 0) {
-        writeCursorRules(collection.cursor, ".cursor/rules/aicm");
-    }
-    // Write Windsurf rules
-    if (collection.windsurf.length > 0) {
-        writeRulesForFile(collection.windsurf, ".aicm", ".windsurfrules");
-    }
-    if (collection.codex.length > 0) {
-        writeRulesForFile(collection.codex, ".aicm", "AGENTS.md");
-    }
-}
-/**
- * Extract a normalized namespace from a preset path
- * @param presetPath The original preset path
- * @returns An array of path segments to use for namespacing
- */
-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
-}
-/**
- * Write rules to Cursor's rules directory
- * @param rules The rules to write
- * @param cursorRulesDir The path 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.presetPath) {
-            // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
-            // 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));
-        if (fs_extra_1.default.existsSync(rule.sourcePath)) {
-            fs_extra_1.default.copyFileSync(rule.sourcePath, ruleFile);
-        }
-        else {
-            const mdcContent = `---\n${JSON.stringify(rule.metadata, null, 2)}\n---\n\n${rule.content}`;
-            fs_extra_1.default.writeFileSync(ruleFile, mdcContent);
-        }
-    }
-}
-/**
- * Write rules to a shared directory and update the given rules file
- * @param rules The rules to write
- */
-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.presetPath) {
-            // For rules from presets, create a namespaced directory structure
-            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
-            // 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 '.rules'
-        // For the rules file, maintain the same structure
-        let windsurfPath;
-        if (rule.presetPath) {
-            const namespace = extractNamespaceFromPresetPath(rule.presetPath);
-            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 in .windsurfrules
-        const windsurfPathPosix = windsurfPath.replace(/\\/g, "/");
-        return {
-            name: rule.name,
-            path: windsurfPathPosix,
-            metadata: rule.metadata,
-        };
-    });
-    const windsurfRulesContent = (0, rules_file_writer_1.generateRulesFileContent)(ruleFiles);
-    (0, rules_file_writer_1.writeRulesFile)(windsurfRulesContent, node_path_1.default.join(process.cwd(), rulesFile));
-}