aicm 0.1.0

package/dist/utils/config.d.ts

@@ -0,0 +1,21 @@
+import { Config, Rules } from "../types";
+/**
+ * Get the full path to a preset file
+ */
+export declare function getFullPresetPath(presetPath: string): string | null;
+/**
+ * Load a preset file and return its rules
+ */
+export declare function loadPreset(presetPath: string): Rules | null;
+/**
+ * Get the configuration from the rules.json file and merge with any presets
+ */
+export declare function getConfig(): Config | null;
+/**
+ * Get the source preset path for a rule if it came from a preset
+ */
+export declare function getRuleSource(config: Config, ruleName: string): string | undefined;
+/**
+ * Save the configuration to the rules.json file
+ */
+export declare function saveConfig(config: Config): boolean;

package/dist/utils/config.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFullPresetPath = getFullPresetPath;
+exports.loadPreset = loadPreset;
+exports.getConfig = getConfig;
+exports.getRuleSource = getRuleSource;
+exports.saveConfig = saveConfig;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const rule_detector_1 = require("./rule-detector");
+const CONFIG_FILE = "rules.json";
+/**
+ * Get the full path to a preset file
+ */
+function getFullPresetPath(presetPath) {
+    try {
+        const ruleType = (0, rule_detector_1.detectRuleType)(presetPath);
+        let fullPresetPath = presetPath;
+        if (ruleType === "npm") {
+            try {
+                fullPresetPath = require.resolve(presetPath, {
+                    paths: [process.cwd()],
+                });
+            }
+            catch (_a) {
+                const directPath = node_path_1.default.join(process.cwd(), "node_modules", presetPath);
+                if (fs_extra_1.default.existsSync(directPath)) {
+                    fullPresetPath = directPath;
+                }
+                else {
+                    return null;
+                }
+            }
+        }
+        else {
+            // For local files, resolve from current directory
+            fullPresetPath = node_path_1.default.resolve(process.cwd(), presetPath);
+        }
+        return fs_extra_1.default.existsSync(fullPresetPath) ? fullPresetPath : null;
+    }
+    catch (_b) {
+        return null;
+    }
+}
+/**
+ * Load a preset file and return its rules
+ */
+function loadPreset(presetPath) {
+    const fullPresetPath = getFullPresetPath(presetPath);
+    if (!fullPresetPath) {
+        throw new Error(`Error loading preset: File not found: ${presetPath}. Make sure the package is installed in your project.`);
+    }
+    const presetContent = fs_extra_1.default.readFileSync(fullPresetPath, "utf8");
+    let preset;
+    try {
+        preset = JSON.parse(presetContent);
+    }
+    catch (error) {
+        const parseError = error;
+        throw new Error(`Error loading preset: Invalid JSON in ${presetPath}: ${parseError.message}`);
+    }
+    if (!preset.rules || typeof preset.rules !== "object") {
+        throw new Error(`Error loading preset: Invalid format in ${presetPath} - missing or invalid 'rules' object`);
+    }
+    return preset.rules;
+}
+/**
+ * Read the raw configuration file without processing presets
+ */
+function readConfigFile() {
+    const configPath = node_path_1.default.join(process.cwd(), CONFIG_FILE);
+    if (!fs_extra_1.default.existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const configContent = fs_extra_1.default.readFileSync(configPath, "utf8");
+        const config = JSON.parse(configContent);
+        // Initialize rules object if it doesn't exist
+        if (!config.rules) {
+            config.rules = {};
+        }
+        return config;
+    }
+    catch (error) {
+        console.error("Error reading configuration file:", error);
+        return null;
+    }
+}
+/**
+ * Process presets and merge their rules into the config
+ */
+function processPresets(config) {
+    if (!config.presets || !Array.isArray(config.presets)) {
+        return;
+    }
+    for (const presetPath of config.presets) {
+        const presetRules = loadPreset(presetPath);
+        if (!presetRules)
+            continue;
+        const fullPresetPath = getFullPresetPath(presetPath);
+        if (!fullPresetPath)
+            continue;
+        mergePresetRules(config, presetRules, fullPresetPath);
+    }
+}
+/**
+ * Merge preset rules into the config
+ */
+function mergePresetRules(config, presetRules, presetPath) {
+    // Add preset rules, but don't override existing rules
+    for (const [ruleName, rulePath] of Object.entries(presetRules)) {
+        // Only add if not already defined in config
+        if (!config.rules[ruleName]) {
+            config.rules[ruleName] = rulePath;
+            // Store the source preset path in metadata
+            config.__ruleSources = config.__ruleSources || {};
+            config.__ruleSources[ruleName] = presetPath;
+        }
+    }
+}
+/**
+ * Get the configuration from the rules.json file and merge with any presets
+ */
+function getConfig() {
+    const config = readConfigFile();
+    if (!config) {
+        return null;
+    }
+    processPresets(config);
+    return config;
+}
+/**
+ * Get the source preset path for a rule if it came from a preset
+ */
+function getRuleSource(config, ruleName) {
+    var _a;
+    return (_a = config.__ruleSources) === null || _a === void 0 ? void 0 : _a[ruleName];
+}
+/**
+ * Save the configuration to the rules.json file
+ */
+function saveConfig(config) {
+    const configPath = node_path_1.default.join(process.cwd(), CONFIG_FILE);
+    try {
+        fs_extra_1.default.writeJsonSync(configPath, config, { spaces: 2 });
+        return true;
+    }
+    catch (error) {
+        console.error("Error writing configuration file:", error);
+        return false;
+    }
+}

package/dist/utils/mdc-parser.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse an MDC file and extract its content
+ * MDC files are Markdown files with metadata
+ * https://docs.cursor.com/context/rules
+ */
+export declare function parseMdcFile(filePath: string): {
+    metadata: Record<string, boolean | string | string[]>;
+    content: string;
+};

package/dist/utils/mdc-parser.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMdcFile = parseMdcFile;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * Parse an MDC file and extract its content
+ * MDC files are Markdown files with metadata
+ * https://docs.cursor.com/context/rules
+ */
+function parseMdcFile(filePath) {
+    const fileContent = fs_extra_1.default.readFileSync(filePath, "utf8");
+    if (!fileContent.startsWith("---")) {
+        return {
+            metadata: {},
+            content: fileContent,
+        };
+    }
+    const endOfMetadata = fileContent.indexOf("---", 3);
+    if (endOfMetadata === -1) {
+        return {
+            metadata: {},
+            content: fileContent,
+        };
+    }
+    const metadataStr = fileContent.substring(3, endOfMetadata).trim();
+    const content = fileContent.substring(endOfMetadata + 3).trim();
+    const metadata = {};
+    metadataStr.split("\n").forEach((line) => {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex !== -1) {
+            const key = line.substring(0, colonIndex).trim();
+            const valueStr = line.substring(colonIndex + 1).trim();
+            // Handle different value types
+            let value = "";
+            if (valueStr === "true") {
+                value = true;
+            }
+            else if (valueStr === "false") {
+                value = false;
+            }
+            else if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+                // Remove quotes from string values
+                value = valueStr.substring(1, valueStr.length - 1);
+            }
+            else {
+                // Default to using the string value as is
+                value = valueStr;
+            }
+            metadata[key] = value;
+        }
+    });
+    return {
+        metadata,
+        content,
+    };
+}

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

@@ -0,0 +1,33 @@
+import { RuleCollection, RuleContent } from "../types";
+/**
+ * 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
+ */
+export declare function findPackageRoot(packageName: string): string;
+/**
+ * Initialize an empty rule collection
+ */
+export declare function initRuleCollection(): RuleCollection;
+/**
+ * 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
+ */
+export declare function addRuleToCollection(collection: RuleCollection, rule: RuleContent, ides: string[]): void;
+/**
+ * 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
+ */
+export declare function collectLocalRule(ruleName: string, source: string, ruleBasePath?: string): RuleContent;
+/**
+ * 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
+ */
+export declare function collectNpmRule(ruleName: string, source: string): RuleContent;

package/dist/utils/rule-collector.js

@@ -0,0 +1,160 @@
+"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: [],
+    };
+}
+/**
+ * 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);
+        }
+    }
+}
+/**
+ * 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) {
+    // 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) {
+    // 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

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

package/dist/utils/rule-detector.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectRuleType = detectRuleType;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+/**
+ * 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";
+    }
+    // Check if it's an npm package with a direct node_modules reference
+    const packageName = source.split(/[/\\]/)[0]; // Support both slash types
+    if (fs_extra_1.default.existsSync(node_path_1.default.resolve(process.cwd(), "node_modules", packageName))) {
+        return "npm";
+    }
+    // Try to interpret as npm package
+    try {
+        require.resolve(packageName, { paths: [process.cwd()] });
+        return "npm";
+    }
+    catch (_a) {
+        // If we couldn't resolve it as an npm package, assume it's a local path
+        return "local";
+    }
+}

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

@@ -0,0 +1,8 @@
+/**
+ * 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, ruleType: string, ides: string[]): boolean;

package/dist/utils/rule-status.js

@@ -0,0 +1,47 @@
+"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"),
+        windsurf: node_path_1.default.join(projectDir, ".rules"),
+    };
+}
+/**
+ * Check if a rule is installed in the specified IDEs
+ */
+function checkRuleStatus(ruleName, ruleType, ides) {
+    const idePaths = getIdePaths();
+    // Check if rule is installed in all specified IDEs
+    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") {
+            // For Windsurf, check if the rule exists in .rules directory
+            // and if it's referenced in .windsurfrules
+            const ruleExists = fs_extra_1.default.existsSync(node_path_1.default.join(idePaths[ide], `${ruleName}.md`));
+            // Check if .windsurfrules exists and contains a reference to this rule
+            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(`.rules/${ruleName}.md`));
+            }
+            return false;
+        }
+        return false;
+    });
+}

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,68 @@
+"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 rule_status_1 = require("./rule-status");
+const windsurf_writer_1 = require("./windsurf-writer");
+/**
+ * Write all collected rules to their respective IDE targets
+ * @param collection The collection of rules to write
+ */
+function writeRulesToTargets(collection) {
+    const idePaths = (0, rule_status_1.getIdePaths)();
+    // Write Cursor rules
+    if (collection.cursor.length > 0) {
+        writeCursorRules(collection.cursor, idePaths.cursor);
+    }
+    // Write Windsurf rules
+    if (collection.windsurf.length > 0) {
+        writeWindsurfRulesFromCollection(collection.windsurf);
+    }
+}
+/**
+ * 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.ensureDirSync(cursorRulesDir);
+    for (const rule of rules) {
+        const ruleFile = node_path_1.default.join(cursorRulesDir, `${rule.name}.mdc`);
+        // For Cursor, we either copy the file or create a symlink to the original
+        if (fs_extra_1.default.existsSync(rule.sourcePath)) {
+            // Copy the file (safer than symlink)
+            fs_extra_1.default.copyFileSync(rule.sourcePath, ruleFile);
+        }
+        else {
+            // If source path doesn't exist (shouldn't happen), write content directly
+            const mdcContent = `---\n${JSON.stringify(rule.metadata, null, 2)}\n---\n\n${rule.content}`;
+            fs_extra_1.default.writeFileSync(ruleFile, mdcContent);
+        }
+    }
+}
+/**
+ * Write rules to Windsurf's rules directory and update .windsurfrules file
+ * @param rules The rules to write
+ */
+function writeWindsurfRulesFromCollection(rules) {
+    const idePaths = (0, rule_status_1.getIdePaths)();
+    const ruleDir = idePaths.windsurf;
+    fs_extra_1.default.ensureDirSync(ruleDir);
+    // First write individual rule files
+    const ruleFiles = rules.map((rule) => {
+        const ruleFile = node_path_1.default.join(ruleDir, `${rule.name}.md`);
+        fs_extra_1.default.writeFileSync(ruleFile, rule.content);
+        return {
+            name: rule.name,
+            path: `.rules/${rule.name}.md`,
+            metadata: rule.metadata,
+        };
+    });
+    // Then generate and write the .windsurfrules file
+    const windsurfRulesContent = (0, windsurf_writer_1.generateWindsurfRulesContent)(ruleFiles);
+    (0, windsurf_writer_1.writeWindsurfRules)(windsurfRulesContent);
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Write rules to the .windsurfrules file
+ * This will update the content between the RULES_BEGIN and RULES_END markers
+ * If the file doesn't exist, it will create it
+ * If the markers don't exist, it will append them to the existing content
+ */
+export declare function writeWindsurfRules(rulesContent: string, rulesFilePath?: string): void;
+/**
+ * Generate the Windsurf rules content based on rule files
+ */
+export declare function generateWindsurfRulesContent(ruleFiles: {
+    name: string;
+    path: string;
+    metadata: Record<string, string | boolean | string[]>;
+}[]): string;