@adobe-commerce/aio-toolkit 1.0.13 → 1.0.15

package/dist/aio-toolkit-cursor-context/bin/cli.js

@@ -0,0 +1,1089 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/framework/command/base-context-help/index.ts
+var _BaseContextHelp, BaseContextHelp;
+var init_base_context_help = __esm({
+  "src/commands/framework/command/base-context-help/index.ts"() {
+    "use strict";
+    _BaseContextHelp = class _BaseContextHelp {
+      /**
+       * Static method to get the commands - must be implemented by subclasses
+       *
+       * @returns {CommandDescriptor[]} The commands
+       */
+      static getCliName() {
+        throw new Error("getCliName() must be implemented by subclass");
+      }
+      /**
+       * Get the commands dynamically
+       *
+       * @returns {CommandDescriptor[]} The commands array
+       */
+      static getCommands() {
+        throw new Error("getCommands() must be implemented by subclass");
+      }
+      /**
+       * Static execute method that returns the help text
+       *
+       * @returns {CommandResult} The command result with help text
+       */
+      static execute() {
+        const helpText = [
+          this.getUsageSection(),
+          this.getCommandsSection(),
+          this.getExamplesSection(),
+          this.getFooterSection()
+        ].join("\n");
+        return {
+          success: true,
+          message: helpText
+        };
+      }
+      /**
+       * Get the usage section
+       *
+       * @returns {string} The usage section
+       */
+      static getUsageSection() {
+        return `Usage: npx ${this.getCliName()} <command>`;
+      }
+      /**
+       * Get the commands section
+       *
+       * @returns {string} The commands section
+       */
+      static getCommandsSection() {
+        const commands = this.getCommands();
+        const maxNameLength = Math.max(...commands.map((cmd) => cmd.name.length));
+        const commandsList = commands.map((cmd) => `  ${cmd.name.padEnd(maxNameLength + 2)}${cmd.description}`).join("\n");
+        return `
+Commands:
+${commandsList}`;
+      }
+      /**
+       * Get the examples section
+       *
+       * @returns {string} The examples section
+       */
+      static getExamplesSection() {
+        const commands = this.getCommands();
+        const examples = commands.map((cmd) => `  npx ${this.getCliName()} ${cmd.name}`).join("\n");
+        return `
+Examples:
+${examples}`;
+      }
+      /**
+       * Get the footer section with additional information
+       *
+       * @returns {string} The footer section
+       */
+      static getFooterSection() {
+        return `
+For more information, visit:
+  ${this.repositoryUrl}
+`;
+      }
+    };
+    __name(_BaseContextHelp, "BaseContextHelp");
+    /**
+     * Static command name
+     */
+    _BaseContextHelp.NAME = "help";
+    /**
+     * Static command description
+     */
+    _BaseContextHelp.DESCRIPTION = "Show help for the rules commands";
+    /**
+     * Static repository URL
+     */
+    _BaseContextHelp.repositoryUrl = "https://github.com/adobe-commerce/aio-toolkit";
+    BaseContextHelp = _BaseContextHelp;
+  }
+});
+
+// src/commands/cursor-context/lib/help/index.ts
+var _CursorContextHelp, CursorContextHelp;
+var init_help = __esm({
+  "src/commands/cursor-context/lib/help/index.ts"() {
+    "use strict";
+    init_base_context_help();
+    _CursorContextHelp = class _CursorContextHelp extends BaseContextHelp {
+      /**
+       * Get the CLI name
+       * This is used to display the correct help text for the CLI.
+       *
+       * @returns {string} The CLI name
+       */
+      static getCliName() {
+        return "aio-toolkit-cursor-context";
+      }
+      /**
+       * Get commands dynamically to avoid circular dependency
+       * This will be populated when CursorRules is initialized
+       *
+       * @returns {CommandDescriptor[]} The commands array
+       */
+      static getCommands() {
+        const { CursorRules: CursorRules2 } = (init_lib(), __toCommonJS(lib_exports));
+        return CursorRules2.getCommands();
+      }
+    };
+    __name(_CursorContextHelp, "CursorContextHelp");
+    CursorContextHelp = _CursorContextHelp;
+  }
+});
+
+// src/commands/framework/helpers/package-rules-path/index.ts
+var fs, path, _PackageRulesPath, PackageRulesPath;
+var init_package_rules_path = __esm({
+  "src/commands/framework/helpers/package-rules-path/index.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    _PackageRulesPath = class _PackageRulesPath {
+      /**
+       * Get the package rules path
+       * @param {string} rulesPath - The relative path to rules within the package (e.g., 'src/cursor/rules')
+       * @returns {string | null} The absolute path to rules in the installed package, or null if not found
+       */
+      static get(rulesPath) {
+        try {
+          const packageRoot = this.findPackageRoot();
+          if (packageRoot) {
+            const fullRulesPath = path.join(packageRoot, rulesPath);
+            if (fs.existsSync(fullRulesPath)) {
+              return fullRulesPath;
+            }
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      }
+      /**
+       * Find the package root directory
+       * @returns {string | null} The package root path or null if not found
+       */
+      static findPackageRoot() {
+        let currentDir = __dirname;
+        for (let i = 0; i < 10; i++) {
+          const packageJsonPath = path.join(currentDir, "package.json");
+          if (fs.existsSync(packageJsonPath)) {
+            try {
+              const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+              if (packageJson.name === "@adobe-commerce/aio-toolkit") {
+                return currentDir;
+              }
+            } catch {
+            }
+          }
+          const parentDir = path.dirname(currentDir);
+          if (parentDir === currentDir) break;
+          currentDir = parentDir;
+        }
+        return null;
+      }
+    };
+    __name(_PackageRulesPath, "PackageRulesPath");
+    PackageRulesPath = _PackageRulesPath;
+  }
+});
+
+// src/commands/framework/helpers/rule-files/index.ts
+var fs2, _RuleFiles, RuleFiles;
+var init_rule_files = __esm({
+  "src/commands/framework/helpers/rule-files/index.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"));
+    _RuleFiles = class _RuleFiles {
+      /**
+       * Get all rule files from a directory
+       * @param {string} dirPath - The path to the directory containing rule files
+       * @returns {string[]} Array of rule file names
+       */
+      static get(dirPath) {
+        try {
+          if (!fs2.existsSync(dirPath)) {
+            return [];
+          }
+          const files = fs2.readdirSync(dirPath);
+          return files.filter((file) => this.ruleExtensions.some((ext) => file.endsWith(ext)));
+        } catch {
+          return [];
+        }
+      }
+    };
+    __name(_RuleFiles, "RuleFiles");
+    _RuleFiles.ruleExtensions = [".mdc", ".md"];
+    RuleFiles = _RuleFiles;
+  }
+});
+
+// src/commands/framework/helpers/directory-exists/index.ts
+var fs3, _DirectoryExists, DirectoryExists;
+var init_directory_exists = __esm({
+  "src/commands/framework/helpers/directory-exists/index.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    _DirectoryExists = class _DirectoryExists {
+      /**
+       * Check if a directory exists
+       * @param {string} dirPath - The directory path to check
+       * @returns {boolean} True if directory exists and is a directory
+       */
+      static is(dirPath) {
+        try {
+          return fs3.existsSync(dirPath) && fs3.statSync(dirPath).isDirectory();
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Ensure a directory exists, create if it doesn't
+       * @param {string} dirPath - The directory path to ensure
+       * @returns {void}
+       */
+      static ensure(dirPath) {
+        if (!this.is(dirPath)) {
+          fs3.mkdirSync(dirPath, { recursive: true });
+        }
+      }
+    };
+    __name(_DirectoryExists, "DirectoryExists");
+    DirectoryExists = _DirectoryExists;
+  }
+});
+
+// src/commands/framework/helpers/format-messages/index.ts
+var _FormatMessages, FormatMessages;
+var init_format_messages = __esm({
+  "src/commands/framework/helpers/format-messages/index.ts"() {
+    "use strict";
+    _FormatMessages = class _FormatMessages {
+      /**
+       * Format an array of messages into a single string
+       * @param {string[]} messages - Array of message lines
+       * @returns {string} Formatted message string
+       */
+      static execute(messages) {
+        return messages.join("\n");
+      }
+    };
+    __name(_FormatMessages, "FormatMessages");
+    FormatMessages = _FormatMessages;
+  }
+});
+
+// src/commands/framework/helpers/package-path/index.ts
+var fs4, path2, _PackagePath, PackagePath;
+var init_package_path = __esm({
+  "src/commands/framework/helpers/package-path/index.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    _PackagePath = class _PackagePath {
+      /**
+       * Find the path to a package in node_modules
+       *
+       * @param {string} packageName - The name of the package to find (e.g., '@adobe-commerce/commerce-extensibility-tools')
+       * @param {string} projectPath - The project root path (defaults to current directory)
+       * @returns {string | null} The absolute path to the package, or null if not found
+       */
+      static find(packageName, projectPath = process.cwd()) {
+        try {
+          let currentDir = projectPath;
+          const maxIterations = 10;
+          for (let i = 0; i < maxIterations; i++) {
+            const nodeModulesPath = path2.join(currentDir, "node_modules");
+            if (fs4.existsSync(nodeModulesPath)) {
+              const packagePath = path2.join(nodeModulesPath, packageName);
+              if (fs4.existsSync(packagePath)) {
+                return packagePath;
+              }
+            }
+            const parentDir = path2.dirname(currentDir);
+            if (parentDir === currentDir) {
+              break;
+            }
+            currentDir = parentDir;
+          }
+          return null;
+        } catch (error) {
+          return null;
+        }
+      }
+      /**
+       * Get the entry point file path for a package
+       *
+       * @param {string} packageName - The name of the package
+       * @param {string} projectPath - The project root path (defaults to current directory)
+       * @returns {string | null} The relative path from project root to the package entry point, or null if not found
+       */
+      static getEntryPoint(packageName, projectPath = process.cwd()) {
+        try {
+          const packagePath = this.find(packageName, projectPath);
+          if (!packagePath) {
+            return null;
+          }
+          const packageJsonPath = path2.join(packagePath, "package.json");
+          if (!fs4.existsSync(packageJsonPath)) {
+            const defaultEntry = path2.join(packagePath, "index.js");
+            if (fs4.existsSync(defaultEntry)) {
+              return path2.relative(projectPath, defaultEntry);
+            }
+            return null;
+          }
+          const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf-8"));
+          const entryPoint = packageJson.main || "index.js";
+          const entryPointPath = path2.join(packagePath, entryPoint);
+          if (!fs4.existsSync(entryPointPath)) {
+            return null;
+          }
+          return path2.relative(projectPath, entryPointPath);
+        } catch (error) {
+          return null;
+        }
+      }
+    };
+    __name(_PackagePath, "PackagePath");
+    PackagePath = _PackagePath;
+  }
+});
+
+// src/commands/framework/helpers/mcp-config/index.ts
+var fs5, path3, _McpConfig, McpConfig;
+var init_mcp_config = __esm({
+  "src/commands/framework/helpers/mcp-config/index.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    init_package_path();
+    _McpConfig = class _McpConfig {
+      /**
+       * Create or update MCP configuration file
+       *
+       * @param {string} projectPath - The project root path (defaults to current directory)
+       * @returns {McpConfigResult} Result object with success status and reason
+       */
+      static createOrUpdate(projectPath = process.cwd()) {
+        try {
+          const mcpFilePath = path3.join(projectPath, ".cursor", "mcp.json");
+          const packageName = "@adobe-commerce/commerce-extensibility-tools";
+          const packageEntryPoint = PackagePath.getEntryPoint(packageName, projectPath);
+          if (!packageEntryPoint) {
+            return {
+              success: false,
+              reason: "peer-dependency-missing",
+              message: `Package '${packageName}' not found. Install it to enable MCP server integration:
+  npm install ${packageName}`
+            };
+          }
+          const commerceExtensibilityConfig = {
+            command: "node",
+            args: [packageEntryPoint.replace(/\\/g, "/")],
+            // Normalize path separators for cross-platform
+            env: {}
+          };
+          let existingConfig = null;
+          const fileExists = fs5.existsSync(mcpFilePath);
+          if (fileExists) {
+            try {
+              const existingContent = fs5.readFileSync(mcpFilePath, "utf-8");
+              existingConfig = JSON.parse(existingContent);
+            } catch (error) {
+              existingConfig = null;
+            }
+          }
+          const mcpConfig = {
+            mcpServers: existingConfig?.mcpServers ? {
+              ...existingConfig.mcpServers,
+              "commerce-extensibility": commerceExtensibilityConfig
+            } : {
+              "commerce-extensibility": commerceExtensibilityConfig
+            }
+          };
+          fs5.writeFileSync(mcpFilePath, JSON.stringify(mcpConfig, null, 2) + "\n", "utf-8");
+          return {
+            success: true,
+            reason: fileExists ? "updated" : "created",
+            message: fileExists ? "MCP configuration updated at .cursor/mcp.json" : "MCP configuration created at .cursor/mcp.json"
+          };
+        } catch (error) {
+          return {
+            success: false,
+            reason: "error",
+            message: `Failed to create MCP config: ${error instanceof Error ? error.message : String(error)}`
+          };
+        }
+      }
+      /**
+       * Check if MCP configuration exists
+       *
+       * @param {string} projectPath - The project root path (defaults to current directory)
+       * @returns {boolean} True if mcp.json exists, false otherwise
+       */
+      static exists(projectPath = process.cwd()) {
+        const mcpFilePath = path3.join(projectPath, ".cursor", "mcp.json");
+        return fs5.existsSync(mcpFilePath);
+      }
+      /**
+       * Get the path to the MCP configuration file
+       *
+       * @param {string} projectPath - The project root path (defaults to current directory)
+       * @returns {string} The path to mcp.json
+       */
+      static getPath(projectPath = process.cwd()) {
+        return path3.join(projectPath, ".cursor", "mcp.json");
+      }
+    };
+    __name(_McpConfig, "McpConfig");
+    McpConfig = _McpConfig;
+  }
+});
+
+// src/commands/framework/helpers/cursor-ide-detector/index.ts
+var os, _CursorIdeDetector, CursorIdeDetector;
+var init_cursor_ide_detector = __esm({
+  "src/commands/framework/helpers/cursor-ide-detector/index.ts"() {
+    "use strict";
+    os = __toESM(require("os"));
+    _CursorIdeDetector = class _CursorIdeDetector {
+      /**
+       * Check if Cursor IDE is being used
+       * @returns {boolean} True if Cursor IDE is detected, false otherwise
+       */
+      static isCursorIde() {
+        try {
+          if (process.env.CURSOR || process.env.CURSOR_IDE || process.env.CURSOR_TRACE_ID || process.env.CURSOR_AGENT || process.env.__CFBundleIdentifier && process.env.__CFBundleIdentifier.startsWith("com.todesktop.")) {
+            return true;
+          }
+          const execPath = process.execPath.toLowerCase();
+          const cursorPaths = ["cursor.app", "cursor.exe"];
+          const isMacOsSpecificPath = execPath.includes("/applications/cursor.app/contents");
+          if (cursorPaths.some((cursorPath) => execPath.includes(cursorPath)) && !isMacOsSpecificPath) {
+            return true;
+          }
+          if (process.env._) {
+            const parentProcess = process.env._.toLowerCase();
+            if (parentProcess.includes("cursor.app") || parentProcess.includes("cursor.exe") || parentProcess.endsWith("/cursor")) {
+              return true;
+            }
+          }
+          const platform2 = os.platform();
+          if (platform2 === "darwin") {
+            if (execPath.includes("/applications/cursor.app/contents")) {
+              return true;
+            }
+          } else if (platform2 === "win32") {
+            if (execPath.includes("cursor") && (execPath.includes("program files") || execPath.includes("localappdata") || execPath.includes("appdata"))) {
+              return true;
+            }
+          } else if (platform2 === "linux") {
+            if (execPath.includes("cursor") && (execPath.includes("/opt/cursor") || execPath.includes("/usr/share/cursor") || execPath.includes("/.local/share/cursor"))) {
+              return true;
+            }
+          }
+          return false;
+        } catch {
+          return false;
+        }
+      }
+      /**
+       * Get a user-friendly message about Cursor IDE detection
+       * @returns {string} Message about Cursor IDE status
+       */
+      static getDetectionMessage() {
+        if (this.isCursorIde()) {
+          return "\u2705 Cursor IDE detected";
+        }
+        return "\u26A0\uFE0F  Cursor IDE not detected - cursor rules may not work in other IDEs";
+      }
+    };
+    __name(_CursorIdeDetector, "CursorIdeDetector");
+    CursorIdeDetector = _CursorIdeDetector;
+  }
+});
+
+// src/commands/framework/helpers/index.ts
+var init_helpers = __esm({
+  "src/commands/framework/helpers/index.ts"() {
+    "use strict";
+    init_package_rules_path();
+    init_rule_files();
+    init_directory_exists();
+    init_format_messages();
+    init_package_path();
+    init_mcp_config();
+    init_cursor_ide_detector();
+  }
+});
+
+// src/commands/framework/command/base-context-check/index.ts
+var path4, _BaseContextCheck, BaseContextCheck;
+var init_base_context_check = __esm({
+  "src/commands/framework/command/base-context-check/index.ts"() {
+    "use strict";
+    path4 = __toESM(require("path"));
+    init_helpers();
+    _BaseContextCheck = class _BaseContextCheck {
+      /**
+       * Get the directory paths to check
+       * This is used to check if the context directories exist.
+       *
+       * @returns {string[]} Array of directory paths relative to project root
+       */
+      static getDirs() {
+        throw new Error("getDirs() must be implemented by subclass");
+      }
+      /**
+       * Static execute method to check and return the result
+       *
+       * @param {string} projectPath - The path to the project root (defaults to current directory)
+       * @returns {Promise<CommandResult>} The check result
+       */
+      static async execute(projectPath = process.cwd()) {
+        const dirs = this.getDirs();
+        const missingDirs = [];
+        const existingDirs = [];
+        const allContextFiles = [];
+        for (const dir of dirs) {
+          const contextPath = path4.join(projectPath, dir);
+          if (!DirectoryExists.is(contextPath)) {
+            missingDirs.push(dir);
+          } else {
+            existingDirs.push(dir);
+            const contextFiles = RuleFiles.get(contextPath);
+            if (contextFiles.length > 0) {
+              allContextFiles.push({ dir, files: contextFiles });
+            }
+          }
+        }
+        if (existingDirs.length === 0) {
+          return {
+            success: false,
+            message: FormatMessages.execute([
+              "\u274C Context directories not found",
+              "--------------------------------",
+              CursorIdeDetector.getDetectionMessage(),
+              "",
+              `The following directories do not exist:`,
+              ...missingDirs.map((dir) => `  - ${dir}`),
+              "Run: npx aio-toolkit-cursor-context apply"
+            ])
+          };
+        }
+        if (allContextFiles.length === 0) {
+          return {
+            success: false,
+            message: FormatMessages.execute([
+              "\u274C No context files found",
+              "--------------------------------",
+              CursorIdeDetector.getDetectionMessage(),
+              "",
+              `No context files (.mdc, .md) found in:`,
+              ...existingDirs.map((dir) => `  - ${dir}`),
+              "Run: npx aio-toolkit-cursor-context apply"
+            ])
+          };
+        }
+        const totalFiles = allContextFiles.reduce((sum, item) => sum + item.files.length, 0);
+        const messages = [
+          "\u2705 Contexts are applied to the project",
+          "--------------------------------",
+          CursorIdeDetector.getDetectionMessage(),
+          "",
+          `Found ${totalFiles} context file${totalFiles > 1 ? "s" : ""} across ${allContextFiles.length} director${allContextFiles.length > 1 ? "ies" : "y"}:`
+        ];
+        for (const { dir, files } of allContextFiles) {
+          messages.push(`
+${dir}:`);
+          files.forEach((file) => messages.push(`  - ${file}`));
+        }
+        if (missingDirs.length > 0) {
+          messages.push("\n\u26A0\uFE0F  Missing directories:");
+          missingDirs.forEach((dir) => messages.push(`  - ${dir}`));
+        }
+        const mcpExists = McpConfig.exists(projectPath);
+        messages.push("");
+        if (mcpExists) {
+          messages.push("\u2705 MCP server configuration found at .cursor/mcp.json");
+        } else {
+          messages.push("\u26A0\uFE0F  MCP server configuration not found");
+          messages.push("   Run: npx aio-toolkit-cursor-context apply");
+        }
+        return {
+          success: true,
+          message: FormatMessages.execute(messages)
+        };
+      }
+    };
+    __name(_BaseContextCheck, "BaseContextCheck");
+    /**
+     * Static command name
+     */
+    _BaseContextCheck.NAME = "check";
+    /**
+     * Static command description
+     */
+    _BaseContextCheck.DESCRIPTION = "Check contexts are applied to the project";
+    BaseContextCheck = _BaseContextCheck;
+  }
+});
+
+// src/commands/cursor-context/lib/check/index.ts
+var path5, _CursorContextCheck, CursorContextCheck;
+var init_check = __esm({
+  "src/commands/cursor-context/lib/check/index.ts"() {
+    "use strict";
+    path5 = __toESM(require("path"));
+    init_base_context_check();
+    _CursorContextCheck = class _CursorContextCheck extends BaseContextCheck {
+      /**
+       * Get the directory paths to check
+       * This is used to check if the context directories exist.
+       *
+       * @returns {string[]} Array of directory paths relative to project root
+       */
+      static getDirs() {
+        return [path5.join(".cursor", "rules"), path5.join(".cursor", "commands")];
+      }
+    };
+    __name(_CursorContextCheck, "CursorContextCheck");
+    CursorContextCheck = _CursorContextCheck;
+  }
+});
+
+// src/commands/framework/command/base-rule-apply/index.ts
+var fs6, path6, _BaseRuleApply, BaseRuleApply;
+var init_base_rule_apply = __esm({
+  "src/commands/framework/command/base-rule-apply/index.ts"() {
+    "use strict";
+    fs6 = __toESM(require("fs"));
+    path6 = __toESM(require("path"));
+    init_format_messages();
+    init_helpers();
+    _BaseRuleApply = class _BaseRuleApply {
+      /**
+       * Get the copy directories configuration
+       * @returns {Record<string, { from: string; to: string }>} Object with directory pairs to copy
+       */
+      static getCopyDirs() {
+        throw new Error("getCopyDirs() must be implemented by subclass");
+      }
+      /**
+       * Check if IDE detection is required before applying contexts
+       * Override this method in subclasses to enable IDE detection
+       * @returns {boolean} True if IDE detection should be performed
+       */
+      static shouldCheckIde() {
+        return false;
+      }
+      /**
+       * Static execute method to apply contexts
+       * @param {string} projectPath - The path to the project root (defaults to current directory)
+       * @param {string[]} args - Command arguments
+       * @returns {Promise<CommandResult>} The apply result
+       */
+      static async execute(projectPath = process.cwd(), args2 = []) {
+        let actualProjectPath = projectPath;
+        let actualArgs = args2;
+        if (projectPath.startsWith("-")) {
+          actualProjectPath = process.cwd();
+          actualArgs = [projectPath, ...args2];
+        }
+        const forceOverwrite = actualArgs.includes("--force") || actualArgs.includes("-f");
+        if (!forceOverwrite && this.shouldCheckIde() && !CursorIdeDetector.isCursorIde()) {
+          return {
+            success: false,
+            message: FormatMessages.execute([
+              "\u274C Cursor IDE not detected",
+              "--------------------------------",
+              CursorIdeDetector.getDetectionMessage(),
+              "",
+              "Cursor contexts can only be applied when using Cursor IDE.",
+              "Please run this command from within Cursor IDE.",
+              "",
+              "\u2139\uFE0F  Use --force or -f to bypass this check and apply contexts anyway."
+            ])
+          };
+        }
+        try {
+          const copyDirs = this.getCopyDirs();
+          const dirKeys = Object.keys(copyDirs);
+          if (dirKeys.length === 0) {
+            return {
+              success: false,
+              message: FormatMessages.execute([
+                "\u274C No directories configured",
+                "--------------------------------",
+                "The getCopyDirs() method must return at least one directory pair"
+              ])
+            };
+          }
+          const allResults = {};
+          for (const dirKey of dirKeys) {
+            const dirConfig = copyDirs[dirKey];
+            if (!dirConfig) {
+              continue;
+            }
+            const { from: sourceRelativePath, to: destRelativePath } = dirConfig;
+            const sourcePath = PackageRulesPath.get(sourceRelativePath);
+            if (!sourcePath) {
+              return {
+                success: false,
+                message: FormatMessages.execute([
+                  "\u274C Could not find contexts in package",
+                  "--------------------------------",
+                  "The package context directory does not exist",
+                  `Expected at: ${sourceRelativePath}`
+                ])
+              };
+            }
+            const contextFiles = RuleFiles.get(sourcePath);
+            if (contextFiles.length === 0) {
+              return {
+                success: false,
+                message: FormatMessages.execute([
+                  "\u274C No contexts found to apply",
+                  "--------------------------------",
+                  "The package does not contain any context files",
+                  `Checked directory: ${sourceRelativePath}`
+                ])
+              };
+            }
+            const destPath = path6.join(actualProjectPath, destRelativePath);
+            DirectoryExists.ensure(destPath);
+            allResults[dirKey] = {
+              copiedFiles: [],
+              skippedFiles: [],
+              overwrittenFiles: [],
+              sourcePath,
+              destPath: destRelativePath
+            };
+            for (const file of contextFiles) {
+              const sourceFilePath = path6.join(sourcePath, file);
+              const destFilePath = path6.join(destPath, file);
+              const fileExists = fs6.existsSync(destFilePath);
+              if (forceOverwrite) {
+                fs6.copyFileSync(sourceFilePath, destFilePath);
+                if (fileExists) {
+                  allResults[dirKey].overwrittenFiles.push(file);
+                } else {
+                  allResults[dirKey].copiedFiles.push(file);
+                }
+              } else {
+                if (!fileExists) {
+                  fs6.copyFileSync(sourceFilePath, destFilePath);
+                  allResults[dirKey].copiedFiles.push(file);
+                } else {
+                  allResults[dirKey].skippedFiles.push(file);
+                }
+              }
+            }
+          }
+          const mcpResult = McpConfig.createOrUpdate(actualProjectPath);
+          const messages = [];
+          const totalCopied = Object.values(allResults).reduce(
+            (sum, r) => sum + r.copiedFiles.length,
+            0
+          );
+          const totalSkipped = Object.values(allResults).reduce(
+            (sum, r) => sum + r.skippedFiles.length,
+            0
+          );
+          if (forceOverwrite) {
+            messages.push(
+              "\u2705 Contexts applied successfully (force mode)!",
+              "--------------------------------"
+            );
+            for (const dirKey of dirKeys) {
+              const result = allResults[dirKey];
+              if (!result) {
+                continue;
+              }
+              if (result.copiedFiles.length > 0 || result.overwrittenFiles.length > 0) {
+                messages.push(`
+${dirKey.toUpperCase()}:`);
+                if (result.copiedFiles.length > 0) {
+                  messages.push(
+                    `  Copied ${result.copiedFiles.length} new context file${result.copiedFiles.length > 1 ? "s" : ""} to ${result.destPath}:`,
+                    ...result.copiedFiles.map((file) => `    \u2713 ${file}`)
+                  );
+                }
+                if (result.overwrittenFiles.length > 0) {
+                  if (result.copiedFiles.length > 0) {
+                    messages.push("");
+                  }
+                  messages.push(
+                    `  Overwritten ${result.overwrittenFiles.length} existing context file${result.overwrittenFiles.length > 1 ? "s" : ""}:`,
+                    ...result.overwrittenFiles.map((file) => `    \u21BB ${file}`)
+                  );
+                }
+              }
+            }
+            messages.push("");
+            if (mcpResult.success) {
+              messages.push(`\u2713 ${mcpResult.message}`, "");
+            } else if (mcpResult.reason === "peer-dependency-missing") {
+              messages.push(`\u26A0\uFE0F  ${mcpResult.message}`, "");
+            }
+            messages.push("\u26A0\uFE0F  Please restart your IDE to load the updated contexts");
+          } else {
+            if (totalCopied === 0 && totalSkipped > 0) {
+              messages.push("\u2705 All contexts are already applied!", "--------------------------------");
+              for (const dirKey of dirKeys) {
+                const result = allResults[dirKey];
+                if (!result) {
+                  continue;
+                }
+                if (result.skippedFiles.length > 0) {
+                  messages.push(
+                    `
+${dirKey.toUpperCase()}:`,
+                    `  All ${result.skippedFiles.length} context file${result.skippedFiles.length > 1 ? "s" : ""} already exist in ${result.destPath}:`,
+                    ...result.skippedFiles.map((file) => `    \u229D ${file}`)
+                  );
+                }
+              }
+              if (mcpResult.success) {
+                messages.push("", `\u2713 ${mcpResult.message}`);
+              } else if (mcpResult.reason === "peer-dependency-missing") {
+                messages.push("", `\u26A0\uFE0F  ${mcpResult.message}`);
+              }
+              messages.push("", "\u2139\uFE0F  Use --force or -f to overwrite existing contexts");
+            } else {
+              messages.push("\u2705 Contexts applied successfully!", "--------------------------------");
+              for (const dirKey of dirKeys) {
+                const result = allResults[dirKey];
+                if (!result) {
+                  continue;
+                }
+                if (result.copiedFiles.length > 0 || result.skippedFiles.length > 0) {
+                  messages.push(`
+${dirKey.toUpperCase()}:`);
+                  if (result.copiedFiles.length > 0) {
+                    messages.push(
+                      `  Copied ${result.copiedFiles.length} new context file${result.copiedFiles.length > 1 ? "s" : ""} to ${result.destPath}:`,
+                      ...result.copiedFiles.map((file) => `    \u2713 ${file}`)
+                    );
+                  }
+                  if (result.skippedFiles.length > 0) {
+                    if (result.copiedFiles.length > 0) {
+                      messages.push("");
+                    }
+                    messages.push(
+                      `  Skipped ${result.skippedFiles.length} existing context file${result.skippedFiles.length > 1 ? "s" : ""}:`,
+                      ...result.skippedFiles.map((file) => `    \u229D ${file}`),
+                      "",
+                      "  \u2139\uFE0F  Use --force or -f to overwrite existing contexts"
+                    );
+                  }
+                }
+              }
+              if (totalCopied > 0) {
+                messages.push("");
+                if (mcpResult.success) {
+                  messages.push(`\u2713 ${mcpResult.message}`, "");
+                } else if (mcpResult.reason === "peer-dependency-missing") {
+                  messages.push(`\u26A0\uFE0F  ${mcpResult.message}`, "");
+                }
+                messages.push("\u26A0\uFE0F  Please restart your IDE to load the new contexts");
+              }
+            }
+          }
+          return {
+            success: true,
+            message: FormatMessages.execute(messages)
+          };
+        } catch (error) {
+          return {
+            success: false,
+            message: FormatMessages.execute([
+              "\u274C Failed to apply contexts to the project",
+              "--------------------------------",
+              `Error: ${error instanceof Error ? error.message : String(error)}`
+            ])
+          };
+        }
+      }
+    };
+    __name(_BaseRuleApply, "BaseRuleApply");
+    /**
+     * Static command name
+     */
+    _BaseRuleApply.NAME = "apply";
+    /**
+     * Static command description
+     */
+    _BaseRuleApply.DESCRIPTION = "Apply contexts to your project (use --force or -f to overwrite existing)";
+    BaseRuleApply = _BaseRuleApply;
+  }
+});
+
+// src/commands/cursor-context/lib/apply/index.ts
+var path7, _CursorRuleApply, CursorRuleApply;
+var init_apply = __esm({
+  "src/commands/cursor-context/lib/apply/index.ts"() {
+    "use strict";
+    path7 = __toESM(require("path"));
+    init_base_rule_apply();
+    _CursorRuleApply = class _CursorRuleApply extends BaseRuleApply {
+      /**
+       * Enable IDE detection for Cursor-specific contexts
+       * @returns {boolean} True to enable IDE detection
+       */
+      static shouldCheckIde() {
+        return true;
+      }
+      /**
+       * Get the rules directory path
+       * @returns {string} The rules directory path
+       */
+      static getCopyDirs() {
+        return {
+          rules: {
+            from: path7.join("files", "cursor-context", "rules"),
+            to: path7.join(".cursor", "rules")
+          },
+          commands: {
+            from: path7.join("files", "cursor-context", "commands"),
+            to: path7.join(".cursor", "commands")
+          }
+        };
+      }
+    };
+    __name(_CursorRuleApply, "CursorRuleApply");
+    CursorRuleApply = _CursorRuleApply;
+  }
+});
+
+// src/commands/framework/command/base-rules/index.ts
+var _BaseRules, BaseRules;
+var init_base_rules = __esm({
+  "src/commands/framework/command/base-rules/index.ts"() {
+    "use strict";
+    _BaseRules = class _BaseRules {
+      /**
+       * Static method to get the commands - must be implemented by subclasses
+       *
+       * @returns {CommandDescriptor[]} The commands
+       */
+      static getCommands() {
+        throw new Error("getCommands() must be implemented by subclass");
+      }
+      /**
+       * Static execute method to execute a command
+       *
+       * @param {string} type - The name of the command to execute
+       * @param {...any} args - The arguments to pass to the command
+       * @returns {Promise<CommandResult>} The execution result
+       */
+      static async execute(type = "help", ...args2) {
+        const command2 = this.getCommands().find((cmd) => cmd.name === type);
+        if (!command2) {
+          return {
+            success: false,
+            message: `Unknown command: ${type}`
+          };
+        }
+        return await command2.execute(...args2);
+      }
+    };
+    __name(_BaseRules, "BaseRules");
+    BaseRules = _BaseRules;
+  }
+});
+
+// src/commands/cursor-context/lib/index.ts
+var lib_exports = {};
+__export(lib_exports, {
+  CursorRules: () => CursorRules
+});
+var _CursorRules, CursorRules;
+var init_lib = __esm({
+  "src/commands/cursor-context/lib/index.ts"() {
+    "use strict";
+    init_help();
+    init_check();
+    init_apply();
+    init_base_rules();
+    _CursorRules = class _CursorRules extends BaseRules {
+      /**
+       * Static commands array
+       *
+       * @returns {CommandDescriptor[]} The commands array
+       */
+      static getCommands() {
+        return [
+          {
+            name: CursorContextHelp.NAME,
+            description: CursorContextHelp.DESCRIPTION,
+            execute: CursorContextHelp.execute.bind(CursorContextHelp)
+          },
+          {
+            name: CursorContextCheck.NAME,
+            description: CursorContextCheck.DESCRIPTION,
+            execute: CursorContextCheck.execute.bind(CursorContextCheck)
+          },
+          {
+            name: CursorRuleApply.NAME,
+            description: CursorRuleApply.DESCRIPTION,
+            execute: CursorRuleApply.execute.bind(CursorRuleApply)
+          }
+        ];
+      }
+    };
+    __name(_CursorRules, "CursorRules");
+    CursorRules = _CursorRules;
+  }
+});
+
+// src/commands/cursor-context/bin/cli.ts
+init_lib();
+var command = process.argv[2] || "help";
+var args = process.argv.slice(3);
+async function main() {
+  const result = await CursorRules.execute(command, ...args);
+  console.log(result.message);
+  if (!result.success) {
+    process.exit(1);
+  }
+}
+__name(main, "main");
+main().catch((error) => {
+  console.error("Error:", error.message);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map