@jvittechs/jai1-cli 0.1.85 → 0.1.87

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command47 } from "commander";
+import { Command as Command55 } from "commander";
 
 // src/errors/index.ts
 var Jai1Error = class extends Error {
@@ -33,7 +33,7 @@ var NetworkError = class extends Jai1Error {
 // package.json
 var package_default = {
   name: "@jvittechs/jai1-cli",
-  version: "0.1.85",
+  version: "0.1.87",
   description: "A unified CLI tool for JV-IT TECHS developers to manage Jai1 Framework. Please contact TeamAI for usage instructions.",
   type: "module",
   bin: {
@@ -895,9 +895,9 @@ var UnifiedApplyApp = ({
       (c) => c.filepath.toLowerCase().includes(query) || c.name.toLowerCase().includes(query) || c.tags && c.tags.some((t) => t.toLowerCase().includes(query))
     );
   }, [components, searchQuery]);
-  useInput((input2, key) => {
+  useInput((input4, key) => {
     if (viewState === "summary") {
-      if (key.return || input2 === "q" || key.escape) {
+      if (key.return || input4 === "q" || key.escape) {
         onExit();
       }
       return;
@@ -911,7 +911,7 @@ var UnifiedApplyApp = ({
       else setFocusArea("search");
       return;
     }
-    if (key.escape || input2 === "q") {
+    if (key.escape || input4 === "q") {
       onExit();
       return;
     }
@@ -926,7 +926,7 @@ var UnifiedApplyApp = ({
         setCursorIndex((prev) => Math.max(0, prev - 1));
       } else if (key.downArrow) {
         setCursorIndex((prev) => Math.min(filteredComponents.length - 1, prev + 1));
-      } else if (input2 === " ") {
+      } else if (input4 === " ") {
         const current = filteredComponents[cursorIndex];
         if (current) {
           setSelectedPaths((prev) => {
@@ -939,13 +939,13 @@ var UnifiedApplyApp = ({
             return next;
           });
         }
-      } else if (input2 === "a") {
+      } else if (input4 === "a") {
         setSelectedPaths((prev) => {
           const next = new Set(prev);
           filteredComponents.forEach((c) => next.add(c.filepath));
           return next;
         });
-      } else if (input2 === "c") {
+      } else if (input4 === "c") {
         setSelectedPaths(/* @__PURE__ */ new Set());
       }
     }
@@ -954,7 +954,7 @@ var UnifiedApplyApp = ({
         setSelectedPackageIndex((prev) => Math.max(0, prev - 1));
       } else if (key.rightArrow) {
         setSelectedPackageIndex((prev) => Math.min(tags.length - 1, prev + 1));
-      } else if (input2 === " " || key.return) {
+      } else if (input4 === " " || key.return) {
         const tag = tags[selectedPackageIndex];
         if (tag) {
           const packageComponents = components.filter((c) => c.tags?.includes(tag.tag));
@@ -1286,7 +1286,7 @@ async function handleCheck(options) {
 }
 
 // src/commands/ide/index.ts
-import { Command as Command9 } from "commander";
+import { Command as Command10 } from "commander";
 
 // src/commands/ide/context.ts
 import React10 from "react";
@@ -1332,7 +1332,7 @@ var MainMenuView = ({ ideContexts, onSelect }) => {
       available: ideContexts.some((ctx) => ctx.ide === "jai1")
     }
   ];
-  useInput2((input2, key) => {
+  useInput2((input4, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -1434,13 +1434,13 @@ var IDEOverviewView = ({
       count: ideContext.stats.byType.context
     });
   }
-  useInput3((input2, key) => {
+  useInput3((input4, key) => {
     if (key.tab || key.rightArrow) {
       setSelectedTabIndex((prev) => Math.min(tabs.length - 1, prev + 1));
     } else if (key.leftArrow) {
       setSelectedTabIndex((prev) => Math.max(0, prev - 1));
     }
-    const num = parseInt(input2, 10);
+    const num = parseInt(input4, 10);
     if (!isNaN(num) && num >= 1 && num <= tabs.length) {
       setSelectedTabIndex(num - 1);
     }
@@ -1502,7 +1502,7 @@ import React7, { useState as useState4 } from "react";
 import { Box as Box5, Text as Text6, useInput as useInput4 } from "ink";
 var ListView = ({ items, contentType, onSelect, onBack }) => {
   const [selectedIndex, setSelectedIndex] = useState4(0);
-  useInput4((input2, key) => {
+  useInput4((input4, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -1553,18 +1553,18 @@ var DetailView = ({ item, scrollPosition: initialScroll, onBack }) => {
   const [scrollPosition, setScrollPosition] = useState5(initialScroll);
   const maxVisibleLines = 25;
   const maxScroll = Math.max(0, item.previewLines.length - maxVisibleLines);
-  useInput5((input2, key) => {
-    if (key.upArrow || input2 === "k") {
+  useInput5((input4, key) => {
+    if (key.upArrow || input4 === "k") {
       setScrollPosition((prev) => Math.max(0, prev - 1));
-    } else if (key.downArrow || input2 === "j") {
+    } else if (key.downArrow || input4 === "j") {
       setScrollPosition((prev) => Math.min(maxScroll, prev + 1));
-    } else if (key.pageDown || input2 === "d") {
+    } else if (key.pageDown || input4 === "d") {
       setScrollPosition((prev) => Math.min(maxScroll, prev + 5));
-    } else if (key.pageUp || input2 === "u") {
+    } else if (key.pageUp || input4 === "u") {
       setScrollPosition((prev) => Math.max(0, prev - 5));
-    } else if (input2 === "g") {
+    } else if (input4 === "g") {
       setScrollPosition(0);
-    } else if (input2 === "G") {
+    } else if (input4 === "G") {
       setScrollPosition(maxScroll);
     } else if (key.escape || key.backspace) {
       onBack();
@@ -1960,8 +1960,8 @@ var ContextApp = ({ initialIDE, initialType, onExit }) => {
       setLoading(false);
     });
   }, [initialIDE]);
-  useInput6((input2, key) => {
-    if (input2 === "q") {
+  useInput6((input4, key) => {
+    if (input4 === "q") {
       onExit();
       return;
     }
@@ -2823,12 +2823,471 @@ async function runSync(options) {
   console.log("");
 }
 
+// src/commands/ide/status.ts
+import { Command as Command9 } from "commander";
+
+// src/services/ide-detection.service.ts
+import { promises as fs7 } from "fs";
+import { join as join4 } from "path";
+
+// src/config/ide-formats.ts
+var IDE_FORMATS = {
+  cursor: {
+    id: "cursor",
+    name: "Cursor",
+    description: "Cursor IDE (.cursor/rules/)",
+    rulesPath: ".cursor/rules",
+    workflowsPath: ".cursor/commands",
+    fileExtension: ".mdc",
+    metadataFormat: "yaml-frontmatter",
+    supportsReference: true
+  },
+  windsurf: {
+    id: "windsurf",
+    name: "Windsurf",
+    description: "Windsurf IDE (.windsurf/rules/)",
+    rulesPath: ".windsurf/rules",
+    workflowsPath: ".windsurf/workflows",
+    fileExtension: ".md",
+    metadataFormat: "yaml-frontmatter",
+    supportsReference: true
+  },
+  antigravity: {
+    id: "antigravity",
+    name: "Antigravity",
+    description: "Antigravity IDE (.agent/rules/)",
+    rulesPath: ".agent/rules",
+    workflowsPath: ".agent/workflows",
+    fileExtension: ".md",
+    metadataFormat: "yaml-frontmatter",
+    supportsReference: true
+  },
+  claude: {
+    id: "claude",
+    name: "Claude Code",
+    description: "Claude Code (.claude/rules/)",
+    rulesPath: ".claude/rules",
+    fileExtension: ".md",
+    metadataFormat: "yaml-frontmatter",
+    supportsReference: true
+  },
+  agentsmd: {
+    id: "agentsmd",
+    name: "AGENTS.md",
+    description: "Single AGENTS.md file",
+    rulesPath: ".",
+    workflowsPath: void 0,
+    fileExtension: ".md",
+    metadataFormat: "none",
+    supportsReference: false
+  },
+  gemini: {
+    id: "gemini",
+    name: "Gemini CLI",
+    description: "Gemini CLI (GEMINI.md)",
+    rulesPath: ".",
+    fileExtension: ".md",
+    metadataFormat: "none",
+    supportsReference: false,
+    dependencies: ["agentsmd"]
+    // Gemini requires AGENTS.md
+  }
+};
+var JAI1_BASE_RULE = `# Jai1 Framework Agent
+
+You are an AI coding assistant integrated with the Jai1 Framework.
+
+## Skills Reference
+
+The Jai1 Framework provides specialized skills that you can reference and apply:
+
+### Pattern Detection
+
+When you encounter:
+- **Component creation**: Reference \`@jai1-component-patterns\`
+- **API development**: Reference \`@jai1-api-patterns\`
+- **Database operations**: Reference \`@jai1-database-patterns\`
+- **Testing**: Reference \`@jai1-testing-patterns\`
+- **Deployment**: Reference \`@jai1-deployment-patterns\`
+
+### Skill Loading Procedure
+
+1. **Detect the task type** from user request
+2. **Load relevant skill** using \`@jai1-[skill-name]\` syntax
+3. **Apply patterns** from the skill to your response
+4. **Follow conventions** defined in the skill
+
+Example:
+\`\`\`
+User: "Create a new API endpoint for users"
+Assistant:
+1. Loading @jai1-api-patterns
+2. Applying RESTful conventions
+3. Following project structure from @jai1-component-patterns
+4. Implementing validation using @jai1-testing-patterns
+\`\`\`
+
+### Application
+
+- **Always reference skills** before implementing patterns
+- **Follow naming conventions** from loaded skills
+- **Apply best practices** defined in skills
+- **Maintain consistency** with existing codebase patterns
+
+### Naming Convention
+
+Skills are named using the pattern: \`@jai1-[domain]-patterns\`
+
+Examples:
+- \`@jai1-component-patterns\`
+- \`@jai1-api-patterns\`
+- \`@jai1-database-patterns\`
+- \`@jai1-testing-patterns\`
+- \`@jai1-deployment-patterns\`
+
+## Best Practices
+
+1. **Load before applying**: Always reference the appropriate skill before implementing
+2. **Follow project structure**: Use patterns from \`@jai1-component-patterns\`
+3. **Maintain consistency**: Apply conventions consistently across the codebase
+4. **Document decisions**: Explain why specific patterns are used
+
+## Integration
+
+This base rule works in conjunction with:
+- Project-specific rules (e.g., 01-project.md)
+- Technology-specific rules (e.g., 03-frontend.md)
+- Custom rules (e.g., 09-custom.md)
+- AGENTS.md (if present)
+
+When conflicts arise, prioritize:
+1. Custom rules (09-custom.*)
+2. Project rules (01-project.*)
+3. This base rule (00-jai1.*)
+`;
+
+// src/services/ide-detection.service.ts
+var IdeDetectionService = class {
+  projectPath;
+  constructor(projectPath = process.cwd()) {
+    this.projectPath = projectPath;
+  }
+  /**
+   * Detect all active IDEs in the project
+   */
+  async detectActiveIdes() {
+    const detected = [];
+    for (const [ideId, format] of Object.entries(IDE_FORMATS)) {
+      const detection = await this.detectIde(ideId, format);
+      detected.push(detection);
+    }
+    return detected.filter((d) => d.detected);
+  }
+  /**
+   * Detect a specific IDE
+   */
+  async detectIde(ideId, format) {
+    const detection = {
+      id: ideId,
+      name: format.name,
+      detected: false,
+      hasRules: false,
+      hasWorkflows: false,
+      ruleCount: 0,
+      workflowCount: 0,
+      confidence: "low"
+    };
+    if (ideId === "agentsmd") {
+      const exists = await this.pathExists("AGENTS.md");
+      detection.detected = exists;
+      detection.hasRules = exists;
+      detection.ruleCount = exists ? 1 : 0;
+      detection.confidence = exists ? "high" : "low";
+      return detection;
+    }
+    if (ideId === "gemini") {
+      const exists = await this.pathExists("GEMINI.md");
+      detection.detected = exists;
+      detection.hasRules = exists;
+      detection.ruleCount = exists ? 1 : 0;
+      detection.confidence = exists ? "high" : "low";
+      return detection;
+    }
+    const rulesPath = join4(this.projectPath, format.rulesPath);
+    const rulesExist = await this.pathExists(rulesPath);
+    if (rulesExist) {
+      detection.hasRules = true;
+      detection.ruleCount = await this.countFiles(rulesPath, format.fileExtension);
+      if (detection.ruleCount > 0) {
+        detection.detected = true;
+      }
+    }
+    if (format.workflowsPath) {
+      const workflowsPath = join4(this.projectPath, format.workflowsPath);
+      const workflowsExist = await this.pathExists(workflowsPath);
+      if (workflowsExist) {
+        detection.hasWorkflows = true;
+        detection.workflowCount = await this.countFiles(workflowsPath, format.fileExtension);
+        if (detection.workflowCount > 0) {
+          detection.detected = true;
+        }
+      }
+    }
+    if (detection.ruleCount > 3 || detection.workflowCount > 0) {
+      detection.confidence = "high";
+    } else if (detection.ruleCount > 0) {
+      detection.confidence = "medium";
+    }
+    return detection;
+  }
+  /**
+   * Get the most likely active IDE (highest confidence)
+   */
+  async getPrimaryIde() {
+    const active = await this.detectActiveIdes();
+    if (active.length === 0) {
+      return null;
+    }
+    active.sort((a, b) => {
+      const confidenceScore = { high: 3, medium: 2, low: 1 };
+      const aScore = confidenceScore[a.confidence] * 10 + a.ruleCount;
+      const bScore = confidenceScore[b.confidence] * 10 + b.ruleCount;
+      return bScore - aScore;
+    });
+    return active[0];
+  }
+  /**
+   * Get IDE IDs that are active
+   */
+  async getActiveIdeIds() {
+    const active = await this.detectActiveIdes();
+    return active.map((d) => d.id);
+  }
+  /**
+   * Check if a specific IDE is active
+   */
+  async isIdeActive(ideId) {
+    const format = IDE_FORMATS[ideId];
+    if (!format) {
+      return false;
+    }
+    const detection = await this.detectIde(ideId, format);
+    return detection.detected;
+  }
+  /**
+   * Detect IDEs with existing rule files (for backward compatibility)
+   */
+  async detectExistingIdes() {
+    const detected = [];
+    for (const [ideId, format] of Object.entries(IDE_FORMATS)) {
+      if (ideId === "agentsmd") {
+        if (await this.pathExists("AGENTS.md")) {
+          detected.push(ideId);
+        }
+      } else if (ideId === "gemini") {
+        if (await this.pathExists("GEMINI.md")) {
+          detected.push(ideId);
+        }
+      } else {
+        const rulesPath = join4(this.projectPath, format.rulesPath);
+        if (await this.pathExists(rulesPath)) {
+          const count = await this.countFiles(rulesPath, format.fileExtension);
+          if (count > 0) {
+            detected.push(ideId);
+          }
+        }
+      }
+    }
+    return detected;
+  }
+  /**
+   * Get detection summary
+   */
+  async getSummary() {
+    const all = await Promise.all(
+      Object.entries(IDE_FORMATS).map(([ideId, format]) => this.detectIde(ideId, format))
+    );
+    const active = all.filter((d) => d.detected);
+    const inactive = all.filter((d) => !d.detected).map((d) => d.id);
+    const primary = await this.getPrimaryIde();
+    return {
+      total: all.length,
+      active,
+      inactive,
+      primary
+    };
+  }
+  /**
+   * Check if a path exists
+   */
+  async pathExists(path8) {
+    try {
+      await fs7.access(path8);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Count files with specific extension in a directory
+   */
+  async countFiles(dirPath, extension) {
+    try {
+      const entries = await fs7.readdir(dirPath, { withFileTypes: true });
+      return entries.filter((entry) => entry.isFile() && entry.name.endsWith(extension)).length;
+    } catch {
+      return 0;
+    }
+  }
+  /**
+   * Get IDE format by ID
+   */
+  getIdeFormat(ideId) {
+    return IDE_FORMATS[ideId];
+  }
+  /**
+   * Suggest IDEs to configure based on project structure
+   */
+  async suggestIdes() {
+    const suggestions = [];
+    if (await this.pathExists(join4(this.projectPath, ".vscode"))) {
+      suggestions.push({
+        ideId: "cursor",
+        name: "Cursor",
+        reason: "VSCode configuration detected",
+        priority: "high"
+      });
+    }
+    if (await this.pathExists(join4(this.projectPath, "package.json"))) {
+      suggestions.push({
+        ideId: "windsurf",
+        name: "Windsurf",
+        reason: "JavaScript/TypeScript project detected",
+        priority: "medium"
+      });
+    }
+    suggestions.push({
+      ideId: "agentsmd",
+      name: "AGENTS.md",
+      reason: "Universal format, works with all IDEs",
+      priority: "high"
+    });
+    const hasClaudeConfig = await this.pathExists(join4(this.projectPath, ".claude"));
+    if (hasClaudeConfig) {
+      suggestions.push({
+        ideId: "claude",
+        name: "Claude Code",
+        reason: ".claude directory detected",
+        priority: "high"
+      });
+    }
+    return suggestions;
+  }
+};
+
+// src/commands/ide/status.ts
+function createStatusSubcommand() {
+  const cmd = new Command9("status").description("Show detected IDEs and their configuration status").option("--json", "Output as JSON").option("--suggestions", "Show IDE suggestions based on project structure").action(async (options) => {
+    await runStatus(options);
+  });
+  return cmd;
+}
+async function runStatus(options) {
+  const service = new IdeDetectionService();
+  if (options.json) {
+    const summary2 = await service.getSummary();
+    console.log(JSON.stringify(summary2, null, 2));
+    return;
+  }
+  console.log("\n\u{1F50D} IDE Detection Status\n");
+  const summary = await service.getSummary();
+  if (summary.active.length === 0) {
+    console.log("\u26A0\uFE0F  No active IDEs detected\n");
+    console.log("\u{1F4A1} Tips:");
+    console.log('   \u2022 Run "jai1 rules apply" to configure IDE rules');
+    console.log("   \u2022 Create rules in .cursor/rules/, .windsurf/rules/, etc.");
+    console.log("   \u2022 Create AGENTS.md for universal IDE support\n");
+  } else {
+    console.log(`\u{1F4CA} Found ${summary.active.length} active IDE(s):
+`);
+    if (summary.primary) {
+      const confidence = getConfidenceEmoji(summary.primary.confidence);
+      console.log(`\u{1F3AF} Primary IDE: ${summary.primary.name} ${confidence}
+`);
+    }
+    for (const ide of summary.active) {
+      const confidence = getConfidenceEmoji(ide.confidence);
+      const isPrimary = summary.primary?.id === ide.id;
+      const marker = isPrimary ? "\u{1F3AF}" : "  ";
+      console.log(`${marker} ${ide.name} ${confidence}`);
+      if (ide.hasRules) {
+        console.log(`     Rules: ${ide.ruleCount} file(s)`);
+      }
+      if (ide.hasWorkflows) {
+        console.log(`     Workflows: ${ide.workflowCount} file(s)`);
+      }
+      const format = service.getIdeFormat(ide.id);
+      if (format) {
+        if (ide.id === "agentsmd") {
+          console.log(`     Location: AGENTS.md`);
+        } else if (ide.id === "gemini") {
+          console.log(`     Location: GEMINI.md`);
+        } else {
+          console.log(`     Location: ${format.rulesPath}/`);
+        }
+      }
+      console.log("");
+    }
+  }
+  if (summary.inactive.length > 0) {
+    console.log(`\u{1F4CB} Available IDEs (not configured):
+`);
+    for (const ideId of summary.inactive) {
+      const format = service.getIdeFormat(ideId);
+      if (format) {
+        console.log(`   \u2022 ${format.name} - ${format.description}`);
+      }
+    }
+    console.log("");
+  }
+  if (options.suggestions) {
+    const suggestions = await service.suggestIdes();
+    if (suggestions.length > 0) {
+      console.log("\u{1F4A1} Suggested IDEs for this project:\n");
+      for (const suggestion of suggestions) {
+        const priorityEmoji = suggestion.priority === "high" ? "\u2B50" : suggestion.priority === "medium" ? "\u{1F538}" : "\u25AB\uFE0F";
+        console.log(`${priorityEmoji} ${suggestion.name}`);
+        console.log(`   Reason: ${suggestion.reason}
+`);
+      }
+    }
+  }
+  console.log("\u{1F4DD} Commands:\n");
+  console.log('   \u2022 "jai1 rules apply" - Configure rules for IDEs');
+  console.log('   \u2022 "jai1 rules sync" - Regenerate IDE outputs');
+  console.log('   \u2022 "jai1 ide sync" - Sync .jai1/ content to IDEs');
+  console.log('   \u2022 "jai1 ide status --suggestions" - Get IDE recommendations\n');
+}
+function getConfidenceEmoji(confidence) {
+  switch (confidence) {
+    case "high":
+      return "\u{1F7E2}";
+    case "medium":
+      return "\u{1F7E1}";
+    case "low":
+      return "\u{1F534}";
+    default:
+      return "\u26AA";
+  }
+}
+
 // src/commands/ide/index.ts
 function createIdeCommand() {
-  const ideCommand = new Command9("ide").description("IDE integration and configuration commands");
+  const ideCommand = new Command10("ide").description("IDE integration and configuration commands");
   ideCommand.addCommand(createContextSubcommand());
   ideCommand.addCommand(createSetupSubcommand());
   ideCommand.addCommand(createSyncSubcommand());
+  ideCommand.addCommand(createStatusSubcommand());
   ideCommand.action(() => {
     ideCommand.help();
   });
@@ -2838,7 +3297,7 @@ function createIdeCommand() {
 // src/commands/learn.ts
 import React20 from "react";
 import { render as render3 } from "ink";
-import { Command as Command10 } from "commander";
+import { Command as Command11 } from "commander";
 
 // src/ui/guide/GuideApp.tsx
 import React19, { useState as useState9, useEffect as useEffect3 } from "react";
@@ -2888,7 +3347,7 @@ var MENU_ITEMS = [
 ];
 var MenuView = ({ onSelect }) => {
   const [selectedIndex, setSelectedIndex] = useState7(0);
-  useInput7((input2, key) => {
+  useInput7((input4, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -3501,7 +3960,7 @@ var AgenticGuideView = ({ onBack }) => {
   const [isTyping, setIsTyping] = useState8(false);
   const [selectedSuggestion, setSelectedSuggestion] = useState8(0);
   const [focusArea, setFocusArea] = useState8("input");
-  useInput8((input2, key) => {
+  useInput8((input4, key) => {
     if (key.escape) {
       onBack();
       return;
@@ -3633,7 +4092,7 @@ var GuideApp = ({ initialTopic, onExit }) => {
       setCurrentTopic(TOPIC_MAP[initialTopic]);
     }
   }, [initialTopic]);
-  useInput9((input2, key) => {
+  useInput9((input4, key) => {
     if (key.escape || currentTopic !== "menu" && key.backspace) {
       if (currentTopic === "menu") {
         onExit();
@@ -3643,7 +4102,7 @@ var GuideApp = ({ initialTopic, onExit }) => {
       }
       return;
     }
-    if (input2 === "q") {
+    if (input4 === "q") {
       onExit();
       return;
     }
@@ -3692,7 +4151,7 @@ var GuideApp = ({ initialTopic, onExit }) => {
 
 // src/commands/learn.ts
 function createLearnCommand() {
-  const cmd = new Command10("learn").description("Interactive Agentic Coding learning center").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
+  const cmd = new Command11("learn").description("Interactive Agentic Coding learning center").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
     const { waitUntilExit } = render3(
       React20.createElement(GuideApp, {
         initialTopic: options.topic,
@@ -3707,7 +4166,7 @@ function createLearnCommand() {
 }
 
 // src/commands/chat.ts
-import { Command as Command11 } from "commander";
+import { Command as Command12 } from "commander";
 import React26 from "react";
 import { render as render4 } from "ink";
 
@@ -4142,7 +4601,7 @@ var ModelSelector = ({
   const allowedModels = models.filter((m) => m.allowed);
   const currentIndex = allowedModels.findIndex((m) => m.id === currentModel);
   const [selectedIndex, setSelectedIndex] = useState12(Math.max(0, currentIndex));
-  useInput10((input2, key) => {
+  useInput10((input4, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -4268,7 +4727,7 @@ var ChatApp = ({ service, initialModel }) => {
     }
     return false;
   }, [refetch, exit]);
-  useInput11((input2, key) => {
+  useInput11((input4, key) => {
     if (showSlashMenu) {
       if (key.upArrow) {
         setSlashMenuIndex((i) => Math.max(0, i - 1));
@@ -4296,7 +4755,7 @@ var ChatApp = ({ service, initialModel }) => {
       }
       return;
     }
-    if (currentView === "error" && (key.return || input2 === "r")) {
+    if (currentView === "error" && (key.return || input4 === "r")) {
       setCurrentView("loading");
       refetch();
       return;
@@ -4386,14 +4845,14 @@ async function handleChatCommand(options) {
   clear();
 }
 function createChatCommand() {
-  const cmd = new Command11("chat").description("Interactive AI chat with Jai1 LLM Proxy").option("--model <model>", "Initial model to use (e.g., gpt-4o, claude-3-opus)").action(async (options) => {
+  const cmd = new Command12("chat").description("Interactive AI chat with Jai1 LLM Proxy").option("--model <model>", "Initial model to use (e.g., gpt-4o, claude-3-opus)").action(async (options) => {
     await handleChatCommand(options);
   });
   return cmd;
 }
 
 // src/commands/openai-keys.ts
-import { Command as Command12 } from "commander";
+import { Command as Command13 } from "commander";
 function maskKey2(key) {
   if (key.length <= 8) return "****";
   return key.slice(0, 8) + "****" + key.slice(-4);
@@ -4447,14 +4906,14 @@ async function handleOpenAiKeysCommand(options) {
   }
 }
 function createOpenAiKeysCommand() {
-  const cmd = new Command12("openai-keys").description("Show OpenAI-compatible API credentials and info").option("--full", "Show full API key (unmasked)").action(async (options) => {
+  const cmd = new Command13("openai-keys").description("Show OpenAI-compatible API credentials and info").option("--full", "Show full API key (unmasked)").action(async (options) => {
     await handleOpenAiKeysCommand(options);
   });
   return cmd;
 }
 
 // src/commands/stats.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 async function handleStatsCommand() {
   const configService = new ConfigService();
   const config = await configService.load();
@@ -4524,17 +4983,17 @@ async function handleStatsCommand() {
   }
 }
 function createStatsCommand() {
-  const cmd = new Command13("stats").description("Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA s\u1EED d\u1EE5ng LLM v\xE0 gi\u1EDBi h\u1EA1n").action(async () => {
+  const cmd = new Command14("stats").description("Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA s\u1EED d\u1EE5ng LLM v\xE0 gi\u1EDBi h\u1EA1n").action(async () => {
     await handleStatsCommand();
   });
   return cmd;
 }
 
 // src/commands/translate.ts
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 
 // src/services/translation.service.ts
-import { promises as fs7 } from "fs";
+import { promises as fs8 } from "fs";
 import path4 from "path";
 import pLimit from "p-limit";
 import pRetry from "p-retry";
@@ -4551,9 +5010,9 @@ var TranslationService = class {
   /**
    * Detect input type
    */
-  async detectInputType(input2) {
+  async detectInputType(input4) {
     try {
-      const stat = await fs7.stat(input2);
+      const stat = await fs8.stat(input4);
       if (stat.isDirectory()) return "folder";
       if (stat.isFile()) return "file";
     } catch {
@@ -4590,13 +5049,13 @@ var TranslationService = class {
    */
   async translateFile(filePath) {
     try {
-      const content = await fs7.readFile(filePath, "utf-8");
+      const content = await fs8.readFile(filePath, "utf-8");
       const ext = path4.extname(filePath).toLowerCase();
       const fileType = this.getFileType(ext);
       const translatedContent = await this.translateWithRetry(content, fileType);
       const outputPath = this.generateOutputPath(filePath);
       if (!this.options.dryRun) {
-        await fs7.writeFile(outputPath, translatedContent, "utf-8");
+        await fs8.writeFile(outputPath, translatedContent, "utf-8");
       }
       return {
         inputPath: filePath,
@@ -4661,7 +5120,7 @@ var TranslationService = class {
    * Discover translatable files in folder recursively
    */
   async discoverFiles(folderPath) {
-    const entries = await fs7.readdir(folderPath, { withFileTypes: true });
+    const entries = await fs8.readdir(folderPath, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
       const fullPath = path4.join(folderPath, entry.name);
@@ -4785,7 +5244,7 @@ Return ONLY the translated content, no explanations.`;
 };
 
 // src/commands/translate.ts
-async function handleTranslate(input2, options) {
+async function handleTranslate(input4, options) {
   const configService = new ConfigService();
   const config = await configService.load();
   if (!config) {
@@ -4793,16 +5252,16 @@ async function handleTranslate(input2, options) {
   }
   const llmService = new LlmProxyService(config);
   const translationService = new TranslationService(llmService, options, options.model);
-  const inputType = await translationService.detectInputType(input2);
+  const inputType = await translationService.detectInputType(input4);
   switch (inputType) {
     case "text":
-      await handleTextTranslation(translationService, input2, options);
+      await handleTextTranslation(translationService, input4, options);
       break;
     case "file":
-      await handleFileTranslation(translationService, input2, options);
+      await handleFileTranslation(translationService, input4, options);
       break;
     case "folder":
-      await handleFolderTranslation(translationService, input2, options);
+      await handleFolderTranslation(translationService, input4, options);
       break;
   }
 }
@@ -4879,17 +5338,17 @@ async function handleFolderTranslation(service, folderPath, options) {
   }
 }
 function createTranslateCommand() {
-  const cmd = new Command14("translate").description("D\u1ECBch v\u0103n b\u1EA3n, file ho\u1EB7c th\u01B0 m\u1EE5c b\u1EB1ng AI").argument("<input>", "Chu\u1ED7i v\u0103n b\u1EA3n, \u0111\u01B0\u1EDDng d\u1EABn file ho\u1EB7c th\u01B0 m\u1EE5c").option("--to <language>", "M\xE3 ng\xF4n ng\u1EEF \u0111\xEDch (m\u1EB7c \u0111\u1ECBnh: vi)", "vi").option("-o, --output <path>", "\u0110\u01B0\u1EDDng d\u1EABn output (file/th\u01B0 m\u1EE5c)").option("--dry-run", "Xem tr\u01B0\u1EDBc kh\xF4ng l\u01B0u file").option("--concurrency <number>", "S\u1ED1 file x\u1EED l\xFD song song (m\u1EB7c \u0111\u1ECBnh: 3)", "3").option("--model <model>", "Model LLM (m\u1EB7c \u0111\u1ECBnh: gpt-5.1-codex-mini)").option("--json", "Xu\u1EA5t k\u1EBFt qu\u1EA3 d\u1EA1ng JSON").action(async (input2, options) => {
-    await handleTranslate(input2, options);
+  const cmd = new Command15("translate").description("D\u1ECBch v\u0103n b\u1EA3n, file ho\u1EB7c th\u01B0 m\u1EE5c b\u1EB1ng AI").argument("<input>", "Chu\u1ED7i v\u0103n b\u1EA3n, \u0111\u01B0\u1EDDng d\u1EABn file ho\u1EB7c th\u01B0 m\u1EE5c").option("--to <language>", "M\xE3 ng\xF4n ng\u1EEF \u0111\xEDch (m\u1EB7c \u0111\u1ECBnh: vi)", "vi").option("-o, --output <path>", "\u0110\u01B0\u1EDDng d\u1EABn output (file/th\u01B0 m\u1EE5c)").option("--dry-run", "Xem tr\u01B0\u1EDBc kh\xF4ng l\u01B0u file").option("--concurrency <number>", "S\u1ED1 file x\u1EED l\xFD song song (m\u1EB7c \u0111\u1ECBnh: 3)", "3").option("--model <model>", "Model LLM (m\u1EB7c \u0111\u1ECBnh: gpt-5.1-codex-mini)").option("--json", "Xu\u1EA5t k\u1EBFt qu\u1EA3 d\u1EA1ng JSON").action(async (input4, options) => {
+    await handleTranslate(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/index.ts
-import { Command as Command28 } from "commander";
+import { Command as Command29 } from "commander";
 
 // src/commands/utils/password.ts
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/services/utils.service.ts
 import crypto from "crypto";
@@ -4940,12 +5399,12 @@ var UtilsService = class {
   /**
    * Hash text or file using specified algorithm
    */
-  async hash(input2, algorithm) {
+  async hash(input4, algorithm) {
     if (algorithm === "bcrypt") {
       throw new Error("Use hashBcrypt for bcrypt algorithm");
     }
     const hash = crypto.createHash(algorithm);
-    hash.update(input2);
+    hash.update(input4);
     return hash.digest("hex");
   }
   /**
@@ -4958,14 +5417,14 @@ var UtilsService = class {
   /**
    * Hash using bcrypt
    */
-  async hashBcrypt(input2, rounds = 10) {
-    return bcrypt.hash(input2, rounds);
+  async hashBcrypt(input4, rounds = 10) {
+    return bcrypt.hash(input4, rounds);
   }
   /**
    * Base64 encode
    */
-  base64Encode(input2, urlSafe = false) {
-    const buffer = typeof input2 === "string" ? Buffer.from(input2, "utf-8") : input2;
+  base64Encode(input4, urlSafe = false) {
+    const buffer = typeof input4 === "string" ? Buffer.from(input4, "utf-8") : input4;
     let encoded = buffer.toString("base64");
     if (urlSafe) {
       encoded = encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -4975,8 +5434,8 @@ var UtilsService = class {
   /**
    * Base64 decode
    */
-  base64Decode(input2) {
-    let normalized = input2.replace(/-/g, "+").replace(/_/g, "/");
+  base64Decode(input4) {
+    let normalized = input4.replace(/-/g, "+").replace(/_/g, "/");
     while (normalized.length % 4) {
       normalized += "=";
     }
@@ -5105,14 +5564,14 @@ var UtilsService = class {
   /**
    * URL encode
    */
-  urlEncode(input2, full = false) {
-    return full ? encodeURI(input2) : encodeURIComponent(input2);
+  urlEncode(input4, full = false) {
+    return full ? encodeURI(input4) : encodeURIComponent(input4);
   }
   /**
    * URL decode
    */
-  urlDecode(input2, full = false) {
-    return full ? decodeURI(input2) : decodeURIComponent(input2);
+  urlDecode(input4, full = false) {
+    return full ? decodeURI(input4) : decodeURIComponent(input4);
   }
   /**
    * Format bytes to human-readable size
@@ -5158,7 +5617,7 @@ async function handlePasswordGeneration(options) {
   }
 }
 function createPasswordCommand() {
-  const cmd = new Command15("password").description("Generate secure random password").option("-l, --length <number>", "Password length", "16").option("--no-lowercase", "Exclude lowercase letters").option("--no-uppercase", "Exclude uppercase letters").option("--no-digits", "Exclude digits").option("--no-symbols", "Exclude symbols").option("--symbol-chars <chars>", "Custom symbol characters").option("-c, --count <number>", "Number of passwords to generate", "1").addHelpText("after", `
+  const cmd = new Command16("password").description("Generate secure random password").option("-l, --length <number>", "Password length", "16").option("--no-lowercase", "Exclude lowercase letters").option("--no-uppercase", "Exclude uppercase letters").option("--no-digits", "Exclude digits").option("--no-symbols", "Exclude symbols").option("--symbol-chars <chars>", "Custom symbol characters").option("-c, --count <number>", "Number of passwords to generate", "1").addHelpText("after", `
 Examples:
   $ jai1 utils password
   $ jai1 utils password --length 24
@@ -5176,7 +5635,7 @@ Examples:
 }
 
 // src/commands/utils/uuid.ts
-import { Command as Command16 } from "commander";
+import { Command as Command17 } from "commander";
 async function handleUuidGeneration(options) {
   const service = new UtilsService();
   try {
@@ -5204,7 +5663,7 @@ async function handleUuidGeneration(options) {
   }
 }
 function createUuidCommand() {
-  const cmd = new Command16("uuid").description("Generate UUID v4 identifier").option("-c, --count <number>", "Number of UUIDs to generate", "1").option("--uppercase", "Output in uppercase").option("--no-hyphens", "Remove hyphens from output").addHelpText("after", `
+  const cmd = new Command17("uuid").description("Generate UUID v4 identifier").option("-c, --count <number>", "Number of UUIDs to generate", "1").option("--uppercase", "Output in uppercase").option("--no-hyphens", "Remove hyphens from output").addHelpText("after", `
 Examples:
   $ jai1 utils uuid
   $ jai1 utils uuid --count 10
@@ -5221,8 +5680,8 @@ Examples:
 }
 
 // src/commands/utils/hash.ts
-import { Command as Command17 } from "commander";
-async function handleHashGeneration(input2, options) {
+import { Command as Command18 } from "commander";
+async function handleHashGeneration(input4, options) {
   const service = new UtilsService();
   try {
     let hash;
@@ -5233,14 +5692,14 @@ async function handleHashGeneration(input2, options) {
       }
       hash = await service.hashFile(options.file, options.algorithm);
     } else {
-      if (!input2) {
+      if (!input4) {
         console.error("\u274C Please provide input text or use --file option");
         process.exit(1);
       }
       if (options.algorithm === "bcrypt") {
-        hash = await service.hashBcrypt(input2, options.rounds);
+        hash = await service.hashBcrypt(input4, options.rounds);
       } else {
-        hash = await service.hash(input2, options.algorithm);
+        hash = await service.hash(input4, options.algorithm);
       }
     }
     console.log("\u{1F512} Hash Result:");
@@ -5261,7 +5720,7 @@ async function handleHashGeneration(input2, options) {
   }
 }
 function createHashCommand() {
-  const cmd = new Command17("hash").description("Generate hash (MD5, SHA, bcrypt)").argument("[input]", "Text to hash").option(
+  const cmd = new Command18("hash").description("Generate hash (MD5, SHA, bcrypt)").argument("[input]", "Text to hash").option(
     "-a, --algorithm <algorithm>",
     "Hash algorithm (md5, sha1, sha256, sha512, bcrypt)",
     "sha256"
@@ -5273,8 +5732,8 @@ Examples:
   $ jai1 utils hash "password" --algorithm bcrypt --rounds 12
   $ jai1 utils hash --file ./myfile.txt
   $ jai1 utils hash --file ./image.png --algorithm sha512
-`).action(async (input2, options) => {
-    await handleHashGeneration(input2, {
+`).action(async (input4, options) => {
+    await handleHashGeneration(input4, {
       ...options,
       rounds: parseInt(options.rounds, 10)
     });
@@ -5283,9 +5742,9 @@ Examples:
 }
 
 // src/commands/utils/base64-encode.ts
-import { Command as Command18 } from "commander";
+import { Command as Command19 } from "commander";
 import { readFile as readFile2 } from "fs/promises";
-async function handleBase64Encode(input2, options) {
+async function handleBase64Encode(input4, options) {
   const service = new UtilsService();
   try {
     let encoded;
@@ -5293,11 +5752,11 @@ async function handleBase64Encode(input2, options) {
       const content = await readFile2(options.file);
       encoded = service.base64Encode(content, options.urlSafe);
     } else {
-      if (!input2) {
+      if (!input4) {
         console.error("\u274C Please provide input text or use --file option");
         process.exit(1);
       }
-      encoded = service.base64Encode(input2, options.urlSafe);
+      encoded = service.base64Encode(input4, options.urlSafe);
     }
     console.log("\u{1F4DD} Base64 Encoded:");
     console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
@@ -5316,33 +5775,33 @@ async function handleBase64Encode(input2, options) {
   }
 }
 function createBase64EncodeCommand() {
-  const cmd = new Command18("base64-encode").description("Encode text or file to Base64").argument("[input]", "Text to encode").option("-f, --file <path>", "Encode file contents").option("--url-safe", "Use URL-safe Base64 encoding").addHelpText("after", `
+  const cmd = new Command19("base64-encode").description("Encode text or file to Base64").argument("[input]", "Text to encode").option("-f, --file <path>", "Encode file contents").option("--url-safe", "Use URL-safe Base64 encoding").addHelpText("after", `
 Examples:
   $ jai1 utils base64-encode "hello world"
   $ jai1 utils base64-encode "hello world" --url-safe
   $ jai1 utils base64-encode --file ./document.txt
   $ jai1 utils base64-encode --file ./image.png
-`).action(async (input2, options) => {
-    await handleBase64Encode(input2, options);
+`).action(async (input4, options) => {
+    await handleBase64Encode(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/base64-decode.ts
-import { Command as Command19 } from "commander";
+import { Command as Command20 } from "commander";
 import { readFile as readFile3, writeFile } from "fs/promises";
-async function handleBase64Decode(input2, options) {
+async function handleBase64Decode(input4, options) {
   const service = new UtilsService();
   try {
     let encodedInput;
     if (options.file) {
       encodedInput = await readFile3(options.file, "utf-8");
     } else {
-      if (!input2) {
+      if (!input4) {
         console.error("\u274C Please provide Base64 input or use --file option");
         process.exit(1);
       }
-      encodedInput = input2;
+      encodedInput = input4;
     }
     const decoded = service.base64Decode(encodedInput.trim());
     if (options.output) {
@@ -5361,20 +5820,20 @@ async function handleBase64Decode(input2, options) {
   }
 }
 function createBase64DecodeCommand() {
-  const cmd = new Command19("base64-decode").description("Decode Base64 string").argument("[input]", "Base64 string to decode").option("-f, --file <path>", "Decode from file").option("-o, --output <path>", "Write decoded output to file").addHelpText("after", `
+  const cmd = new Command20("base64-decode").description("Decode Base64 string").argument("[input]", "Base64 string to decode").option("-f, --file <path>", "Decode from file").option("-o, --output <path>", "Write decoded output to file").addHelpText("after", `
 Examples:
   $ jai1 utils base64-decode "aGVsbG8gd29ybGQ="
   $ jai1 utils base64-decode --file ./encoded.txt
   $ jai1 utils base64-decode "aGVsbG8=" --output ./decoded.txt
   $ jai1 utils base64-decode --file ./encoded.txt --output ./image.png
-`).action(async (input2, options) => {
-    await handleBase64Decode(input2, options);
+`).action(async (input4, options) => {
+    await handleBase64Decode(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/http.ts
-import { Command as Command20 } from "commander";
+import { Command as Command21 } from "commander";
 import { readFile as readFile4 } from "fs/promises";
 async function handleHttpRequest(url, options) {
   const service = new UtilsService();
@@ -5440,7 +5899,7 @@ async function handleHttpRequest(url, options) {
   }
 }
 function createHttpCommand() {
-  const cmd = new Command20("http").description("Make HTTP request with formatted output").argument("<url>", "Target URL").option("-X, --method <method>", "HTTP method", "GET").option("-H, --header <header...>", "Request headers (repeatable)").option("-d, --data <data>", "Request body (JSON string)").option("--file <path>", "Read body from file").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--no-follow", "Do not follow redirects").option("--only-headers", "Show only response headers").option("--only-body", "Show only response body").addHelpText("after", `
+  const cmd = new Command21("http").description("Make HTTP request with formatted output").argument("<url>", "Target URL").option("-X, --method <method>", "HTTP method", "GET").option("-H, --header <header...>", "Request headers (repeatable)").option("-d, --data <data>", "Request body (JSON string)").option("--file <path>", "Read body from file").option("--timeout <ms>", "Request timeout in milliseconds", "30000").option("--no-follow", "Do not follow redirects").option("--only-headers", "Show only response headers").option("--only-body", "Show only response body").addHelpText("after", `
 Examples:
   $ jai1 utils http https://api.example.com/users
   $ jai1 utils http https://api.example.com/users -X POST -d '{"name":"John"}'
@@ -5458,7 +5917,7 @@ Examples:
 }
 
 // src/commands/utils/jwt.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 async function handleJwtDecode(token) {
   const service = new UtilsService();
   try {
@@ -5497,7 +5956,7 @@ async function handleJwtEncode(options) {
   }
 }
 function createJwtCommand() {
-  const jwtCommand = new Command21("jwt").description("Decode and encode JWT tokens");
+  const jwtCommand = new Command22("jwt").description("Decode and encode JWT tokens");
   jwtCommand.command("decode").description("Decode JWT token").argument("<token>", "JWT token to decode").addHelpText("after", `
 Examples:
   $ jai1 utils jwt decode "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
@@ -5518,11 +5977,11 @@ Examples:
 }
 
 // src/commands/utils/unix-time.ts
-import { Command as Command22 } from "commander";
-async function handleUnixTime(input2, options) {
+import { Command as Command23 } from "commander";
+async function handleUnixTime(input4, options) {
   const service = new UtilsService();
   try {
-    if (!input2) {
+    if (!input4) {
       const now = /* @__PURE__ */ new Date();
       const timestamp = service.dateToUnix(now, options.ms);
       console.log("\u{1F552} Current Unix Timestamp:");
@@ -5532,8 +5991,8 @@ async function handleUnixTime(input2, options) {
       console.log(`   ISO: ${now.toISOString()}`);
       console.log(`   Local: ${now.toLocaleString()}`);
       console.log();
-    } else if (/^\d+$/.test(input2)) {
-      const timestamp = parseInt(input2, 10);
+    } else if (/^\d+$/.test(input4)) {
+      const timestamp = parseInt(input4, 10);
       const date = service.unixToDate(timestamp, options.ms);
       console.log("\u{1F552} Unix Timestamp to Date:");
       console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
@@ -5546,7 +6005,7 @@ async function handleUnixTime(input2, options) {
       }
       console.log();
     } else {
-      const date = new Date(input2);
+      const date = new Date(input4);
       if (isNaN(date.getTime())) {
         console.error("\u274C Invalid date format");
         process.exit(1);
@@ -5554,7 +6013,7 @@ async function handleUnixTime(input2, options) {
       const timestamp = service.dateToUnix(date, options.ms);
       console.log("\u{1F552} Date to Unix Timestamp:");
       console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
-      console.log(`   Input: ${input2}`);
+      console.log(`   Input: ${input4}`);
       console.log(`   Parsed: ${date.toISOString()}`);
       console.log();
       console.log(`   ${timestamp}${options.ms ? " (ms)" : ""}`);
@@ -5566,7 +6025,7 @@ async function handleUnixTime(input2, options) {
   }
 }
 function createUnixTimeCommand() {
-  const cmd = new Command22("unix-time").description("Convert unix timestamps to/from dates").argument("[input]", "Unix timestamp or date string").option("-f, --format <format>", "Output format (iso, local, utc)", "iso").option("--ms", "Use milliseconds instead of seconds").addHelpText("after", `
+  const cmd = new Command23("unix-time").description("Convert unix timestamps to/from dates").argument("[input]", "Unix timestamp or date string").option("-f, --format <format>", "Output format (iso, local, utc)", "iso").option("--ms", "Use milliseconds instead of seconds").addHelpText("after", `
 Examples:
   $ jai1 utils unix-time
   $ jai1 utils unix-time 1702550400
@@ -5574,14 +6033,14 @@ Examples:
   $ jai1 utils unix-time "2024-01-15 10:30:00"
   $ jai1 utils unix-time "2024-01-15" --format local
   $ jai1 utils unix-time --ms
-`).action(async (input2, options) => {
-    await handleUnixTime(input2, options);
+`).action(async (input4, options) => {
+    await handleUnixTime(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/timezone.ts
-import { Command as Command23 } from "commander";
+import { Command as Command24 } from "commander";
 async function handleTimezoneConversion(time, options) {
   const service = new UtilsService();
   try {
@@ -5618,7 +6077,7 @@ async function handleTimezoneConversion(time, options) {
   }
 }
 function createTimezoneCommand() {
-  const cmd = new Command23("timezone").description("Convert time between timezones").argument("[time]", 'Time to convert (e.g., "2024-01-15 10:00")').option("--from <timezone>", "Source timezone").option("--to <timezone>", "Target timezone").option("--list", "Show available timezones").addHelpText("after", `
+  const cmd = new Command24("timezone").description("Convert time between timezones").argument("[time]", 'Time to convert (e.g., "2024-01-15 10:00")').option("--from <timezone>", "Source timezone").option("--to <timezone>", "Target timezone").option("--list", "Show available timezones").addHelpText("after", `
 Examples:
   $ jai1 utils timezone --list
   $ jai1 utils timezone "2024-01-15 10:00" --from "America/New_York" --to "Asia/Tokyo"
@@ -5631,11 +6090,11 @@ Examples:
 }
 
 // src/commands/utils/url-encode.ts
-import { Command as Command24 } from "commander";
-async function handleUrlEncode(input2, options) {
+import { Command as Command25 } from "commander";
+async function handleUrlEncode(input4, options) {
   const service = new UtilsService();
   try {
-    const encoded = service.urlEncode(input2, options.full);
+    const encoded = service.urlEncode(input4, options.full);
     console.log("\u{1F517} URL Encoded:");
     console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     if (options.full) {
@@ -5652,24 +6111,24 @@ async function handleUrlEncode(input2, options) {
   }
 }
 function createUrlEncodeCommand() {
-  const cmd = new Command24("url-encode").description("Encode URL component or full URL").argument("<input>", "Text to encode").option("--full", "Encode full URL (use encodeURI instead of encodeURIComponent)").addHelpText("after", `
+  const cmd = new Command25("url-encode").description("Encode URL component or full URL").argument("<input>", "Text to encode").option("--full", "Encode full URL (use encodeURI instead of encodeURIComponent)").addHelpText("after", `
 Examples:
   $ jai1 utils url-encode "hello world"
   $ jai1 utils url-encode "hello world & test"
   $ jai1 utils url-encode "name=John Doe&age=30"
   $ jai1 utils url-encode "https://example.com/path with spaces" --full
-`).showHelpAfterError("(add --help for additional examples)").action(async (input2, options) => {
-    await handleUrlEncode(input2, options);
+`).showHelpAfterError("(add --help for additional examples)").action(async (input4, options) => {
+    await handleUrlEncode(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/url-decode.ts
-import { Command as Command25 } from "commander";
-async function handleUrlDecode(input2, options) {
+import { Command as Command26 } from "commander";
+async function handleUrlDecode(input4, options) {
   const service = new UtilsService();
   try {
-    const decoded = service.urlDecode(input2, options.full);
+    const decoded = service.urlDecode(input4, options.full);
     console.log("\u{1F517} URL Decoded:");
     console.log("\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     if (options.full) {
@@ -5686,20 +6145,20 @@ async function handleUrlDecode(input2, options) {
   }
 }
 function createUrlDecodeCommand() {
-  const cmd = new Command25("url-decode").description("Decode URL-encoded string").argument("<input>", "Text to decode").option("--full", "Decode full URL (use decodeURI instead of decodeURIComponent)").addHelpText("after", `
+  const cmd = new Command26("url-decode").description("Decode URL-encoded string").argument("<input>", "Text to decode").option("--full", "Decode full URL (use decodeURI instead of decodeURIComponent)").addHelpText("after", `
 Examples:
   $ jai1 utils url-decode "hello%20world"
   $ jai1 utils url-decode "hello%20world%20%26%20test"
   $ jai1 utils url-decode "name%3DJohn%20Doe%26age%3D30"
   $ jai1 utils url-decode "https://example.com/path%20with%20spaces" --full
-`).showHelpAfterError("(add --help for additional examples)").action(async (input2, options) => {
-    await handleUrlDecode(input2, options);
+`).showHelpAfterError("(add --help for additional examples)").action(async (input4, options) => {
+    await handleUrlDecode(input4, options);
   });
   return cmd;
 }
 
 // src/commands/utils/cron.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 import cronstrue from "cronstrue";
 async function handleCronParse(expression) {
   try {
@@ -5742,7 +6201,7 @@ async function handleCronParse(expression) {
   }
 }
 function createCronCommand() {
-  const cmd = new Command26("cron").description("Parse and explain cron expression").argument("<expression>", 'Cron expression (e.g., "0 5 * * *")').addHelpText("after", `
+  const cmd = new Command27("cron").description("Parse and explain cron expression").argument("<expression>", 'Cron expression (e.g., "0 5 * * *")').addHelpText("after", `
 Examples:
   $ jai1 utils cron "0 5 * * *"
   $ jai1 utils cron "*/15 * * * *"
@@ -5756,7 +6215,7 @@ Examples:
 }
 
 // src/commands/utils/markdown-preview.ts
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 import { readFile as readFile5 } from "fs/promises";
 import { marked } from "marked";
 import TerminalRenderer from "marked-terminal";
@@ -5795,7 +6254,7 @@ ${code.trim()}
   }
 }
 function createMarkdownPreviewCommand() {
-  const cmd = new Command27("markdown-preview").description("Preview markdown file in terminal").argument("<file>", "Markdown file path").option("--raw", "Show raw markdown instead of rendered").addHelpText("after", `
+  const cmd = new Command28("markdown-preview").description("Preview markdown file in terminal").argument("<file>", "Markdown file path").option("--raw", "Show raw markdown instead of rendered").addHelpText("after", `
 Examples:
   $ jai1 utils markdown-preview README.md
   $ jai1 utils markdown-preview ./docs/guide.md
@@ -5829,14 +6288,14 @@ var PasswordView = () => {
   React27.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput12((input2, key) => {
+  useInput12((input4, key) => {
     if (key.tab) {
       if (focusedField === "length") setFocusedField("count");
       else if (focusedField === "count") setFocusedField("generate");
       else setFocusedField("length");
     } else if (key.return) {
       handleGenerate();
-    } else if (input2 === "c" && passwords.length > 0) {
+    } else if (input4 === "c" && passwords.length > 0) {
       handleCopy(0);
     }
   });
@@ -5919,7 +6378,7 @@ var UuidView = () => {
   React28.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput13((input2, key) => {
+  useInput13((input4, key) => {
     if (key.tab) {
       const fields = ["count", "uppercase", "hyphens", "generate"];
       const currentIndex = fields.indexOf(focusedField);
@@ -5932,7 +6391,7 @@ var UuidView = () => {
       } else {
         handleGenerate();
       }
-    } else if (input2 === "c" && uuids.length > 0) {
+    } else if (input4 === "c" && uuids.length > 0) {
       handleCopy(0);
     }
   });
@@ -6007,7 +6466,7 @@ var HashView = () => {
   React29.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput14((input2, key) => {
+  useInput14((input4, key) => {
     if (key.tab) {
       const fields = ["text", "algorithm", "generate"];
       const currentIndex = fields.indexOf(focusedField);
@@ -6020,7 +6479,7 @@ var HashView = () => {
     } else if (key.rightArrow && focusedField === "algorithm") {
       const currentIndex = ALGORITHMS.indexOf(algorithm);
       setAlgorithm(ALGORITHMS[(currentIndex + 1) % ALGORITHMS.length]);
-    } else if (input2 === "c" && hash) {
+    } else if (input4 === "c" && hash) {
       handleCopy();
     }
   });
@@ -6086,7 +6545,7 @@ import React30, { useState as useState17 } from "react";
 import { Box as Box20, Text as Text21, useInput as useInput15 } from "ink";
 import TextInput7 from "ink-text-input";
 var Base64View = () => {
-  const [input2, setInput] = useState17("");
+  const [input4, setInput] = useState17("");
   const [mode, setMode] = useState17("encode");
   const [urlSafe, setUrlSafe] = useState17(false);
   const [result, setResult] = useState17("");
@@ -6094,7 +6553,7 @@ var Base64View = () => {
   const [focusedField, setFocusedField] = useState17("input");
   const [copied, setCopied] = useState17(false);
   const service = new UtilsService();
-  useInput15((input3, key) => {
+  useInput15((input5, key) => {
     if (key.tab) {
       const fields = ["input", "mode", "urlsafe", "convert"];
       const currentIndex = fields.indexOf(focusedField);
@@ -6109,22 +6568,22 @@ var Base64View = () => {
       } else {
         handleConvert();
       }
-    } else if (input3 === "c" && result) {
+    } else if (input5 === "c" && result) {
       handleCopy();
     }
   });
   const handleConvert = () => {
-    if (!input2) {
+    if (!input4) {
       setError("Input cannot be empty");
       return;
     }
     try {
       setError("");
       if (mode === "encode") {
-        const encoded = service.base64Encode(input2, urlSafe);
+        const encoded = service.base64Encode(input4, urlSafe);
         setResult(encoded);
       } else {
-        const decoded = service.base64Decode(input2);
+        const decoded = service.base64Decode(input4);
         setResult(decoded.toString("utf-8"));
       }
       setCopied(false);
@@ -6153,7 +6612,7 @@ var Base64View = () => {
       marginBottom: 1
     },
     /* @__PURE__ */ React30.createElement(Text21, { bold: true, color: "yellow", marginBottom: 1 }, "Options:"),
-    /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 0 }, /* @__PURE__ */ React30.createElement(Text21, { color: focusedField === "input" ? "green" : void 0 }, focusedField === "input" ? "\u25B6 " : "  ", "Input text:")), /* @__PURE__ */ React30.createElement(Box20, { marginLeft: 2, width: 60 }, focusedField === "input" ? /* @__PURE__ */ React30.createElement(TextInput7, { value: input2, onChange: setInput, placeholder: "Enter text..." }) : /* @__PURE__ */ React30.createElement(Text21, { dimColor: !input2 }, input2 || "(empty)"))),
+    /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 0 }, /* @__PURE__ */ React30.createElement(Text21, { color: focusedField === "input" ? "green" : void 0 }, focusedField === "input" ? "\u25B6 " : "  ", "Input text:")), /* @__PURE__ */ React30.createElement(Box20, { marginLeft: 2, width: 60 }, focusedField === "input" ? /* @__PURE__ */ React30.createElement(TextInput7, { value: input4, onChange: setInput, placeholder: "Enter text..." }) : /* @__PURE__ */ React30.createElement(Text21, { dimColor: !input4 }, input4 || "(empty)"))),
     /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 1 }, /* @__PURE__ */ React30.createElement(Box20, { width: 20 }, /* @__PURE__ */ React30.createElement(Text21, { color: focusedField === "mode" ? "green" : void 0 }, focusedField === "mode" ? "\u25B6 " : "  ", "Mode:")), /* @__PURE__ */ React30.createElement(Text21, { bold: true, color: focusedField === "mode" ? "yellow" : void 0 }, mode === "encode" ? "ENCODE" : "DECODE"), focusedField === "mode" && /* @__PURE__ */ React30.createElement(Text21, { dimColor: true }, " (Enter to toggle)")),
     mode === "encode" && /* @__PURE__ */ React30.createElement(Box20, { marginBottom: 1 }, /* @__PURE__ */ React30.createElement(Text21, { color: focusedField === "urlsafe" ? "green" : void 0 }, focusedField === "urlsafe" ? "\u25B6 " : "  ", "[", urlSafe ? "\u2713" : " ", "] URL-Safe (+ \u2192 -, / \u2192 _)")),
     /* @__PURE__ */ React30.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React30.createElement(
@@ -6198,14 +6657,14 @@ import React31, { useState as useState18 } from "react";
 import { Box as Box21, Text as Text22, useInput as useInput16 } from "ink";
 import TextInput8 from "ink-text-input";
 var UrlView = () => {
-  const [input2, setInput] = useState18("");
+  const [input4, setInput] = useState18("");
   const [mode, setMode] = useState18("encode");
   const [fullUrl, setFullUrl] = useState18(false);
   const [result, setResult] = useState18("");
   const [focusedField, setFocusedField] = useState18("input");
   const [copied, setCopied] = useState18(false);
   const service = new UtilsService();
-  useInput16((input3, key) => {
+  useInput16((input5, key) => {
     if (key.tab) {
       const fields = ["input", "mode", "full", "convert"];
       const currentIndex = fields.indexOf(focusedField);
@@ -6219,17 +6678,17 @@ var UrlView = () => {
       } else {
         handleConvert();
       }
-    } else if (input3 === "c" && result) {
+    } else if (input5 === "c" && result) {
       handleCopy();
     }
   });
   const handleConvert = () => {
-    if (!input2) return;
+    if (!input4) return;
     if (mode === "encode") {
-      const encoded = fullUrl ? service.urlEncode(input2, true) : service.urlEncode(input2, false);
+      const encoded = fullUrl ? service.urlEncode(input4, true) : service.urlEncode(input4, false);
       setResult(encoded);
     } else {
-      const decoded = fullUrl ? service.urlDecode(input2, true) : service.urlDecode(input2, false);
+      const decoded = fullUrl ? service.urlDecode(input4, true) : service.urlDecode(input4, false);
       setResult(decoded);
     }
     setCopied(false);
@@ -6254,7 +6713,7 @@ var UrlView = () => {
       marginBottom: 1
     },
     /* @__PURE__ */ React31.createElement(Text22, { bold: true, color: "yellow", marginBottom: 1 }, "Options:"),
-    /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 0 }, /* @__PURE__ */ React31.createElement(Text22, { color: focusedField === "input" ? "green" : void 0 }, focusedField === "input" ? "\u25B6 " : "  ", "Input text:")), /* @__PURE__ */ React31.createElement(Box21, { marginLeft: 2, width: 60 }, focusedField === "input" ? /* @__PURE__ */ React31.createElement(TextInput8, { value: input2, onChange: setInput, placeholder: "Enter text or URL..." }) : /* @__PURE__ */ React31.createElement(Text22, { dimColor: !input2 }, input2 || "(empty)"))),
+    /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 0 }, /* @__PURE__ */ React31.createElement(Text22, { color: focusedField === "input" ? "green" : void 0 }, focusedField === "input" ? "\u25B6 " : "  ", "Input text:")), /* @__PURE__ */ React31.createElement(Box21, { marginLeft: 2, width: 60 }, focusedField === "input" ? /* @__PURE__ */ React31.createElement(TextInput8, { value: input4, onChange: setInput, placeholder: "Enter text or URL..." }) : /* @__PURE__ */ React31.createElement(Text22, { dimColor: !input4 }, input4 || "(empty)"))),
     /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 1 }, /* @__PURE__ */ React31.createElement(Box21, { width: 20 }, /* @__PURE__ */ React31.createElement(Text22, { color: focusedField === "mode" ? "green" : void 0 }, focusedField === "mode" ? "\u25B6 " : "  ", "Mode:")), /* @__PURE__ */ React31.createElement(Text22, { bold: true, color: focusedField === "mode" ? "yellow" : void 0 }, mode === "encode" ? "ENCODE" : "DECODE"), focusedField === "mode" && /* @__PURE__ */ React31.createElement(Text22, { dimColor: true }, " (Enter to toggle)")),
     /* @__PURE__ */ React31.createElement(Box21, { marginBottom: 1 }, /* @__PURE__ */ React31.createElement(Text22, { color: focusedField === "full" ? "green" : void 0 }, focusedField === "full" ? "\u25B6 " : "  ", "[", fullUrl ? "\u2713" : " ", "] Full URL (encode/decode entire URL)")),
     /* @__PURE__ */ React31.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React31.createElement(
@@ -6288,7 +6747,7 @@ import React32, { useState as useState19 } from "react";
 import { Box as Box22, Text as Text23, useInput as useInput17 } from "ink";
 import TextInput9 from "ink-text-input";
 var UnixTimeView = () => {
-  const [input2, setInput] = useState19("");
+  const [input4, setInput] = useState19("");
   const [mode, setMode] = useState19("now");
   const [format, setFormat] = useState19("iso");
   const [useMs, setUseMs] = useState19(false);
@@ -6297,7 +6756,7 @@ var UnixTimeView = () => {
   const [focusedField, setFocusedField] = useState19("mode");
   const [copied, setCopied] = useState19(false);
   const service = new UtilsService();
-  useInput17((input3, key) => {
+  useInput17((input5, key) => {
     if (key.tab) {
       const fields = mode === "now" ? ["mode", "ms", "convert"] : mode === "to-human" ? ["mode", "input", "format", "convert"] : ["mode", "input", "convert"];
       const currentIndex = fields.indexOf(focusedField);
@@ -6318,7 +6777,7 @@ var UnixTimeView = () => {
       } else {
         handleConvert();
       }
-    } else if (input3 === "c" && result) {
+    } else if (input5 === "c" && result) {
       handleCopy();
     }
   });
@@ -6329,18 +6788,18 @@ var UnixTimeView = () => {
         const timestamp = service.unixTimeCurrent(useMs);
         setResult(timestamp.toString());
       } else if (mode === "to-human") {
-        if (!input2) {
+        if (!input4) {
           setError("Please enter a timestamp");
           return;
         }
-        const human = service.unixTimeToHuman(parseInt(input2, 10), format);
+        const human = service.unixTimeToHuman(parseInt(input4, 10), format);
         setResult(human);
       } else {
-        if (!input2) {
+        if (!input4) {
           setError("Please enter a date string");
           return;
         }
-        const timestamp = service.unixTimeFromString(input2);
+        const timestamp = service.unixTimeFromString(input4);
         setResult(timestamp.toString());
       }
       setCopied(false);
@@ -6373,11 +6832,11 @@ var UnixTimeView = () => {
     mode !== "now" && /* @__PURE__ */ React32.createElement(Box22, { marginBottom: 1, flexDirection: "column" }, /* @__PURE__ */ React32.createElement(Box22, { marginBottom: 0 }, /* @__PURE__ */ React32.createElement(Text23, { color: focusedField === "input" ? "green" : void 0 }, focusedField === "input" ? "\u25B6 " : "  ", mode === "to-human" ? "Timestamp:" : "Date string:")), /* @__PURE__ */ React32.createElement(Box22, { marginLeft: 2, width: 50 }, focusedField === "input" ? /* @__PURE__ */ React32.createElement(
       TextInput9,
       {
-        value: input2,
+        value: input4,
         onChange: setInput,
         placeholder: mode === "to-human" ? "1702550400" : "2024-01-15 10:30:00"
       }
-    ) : /* @__PURE__ */ React32.createElement(Text23, { dimColor: !input2 }, input2 || "(empty)"))),
+    ) : /* @__PURE__ */ React32.createElement(Text23, { dimColor: !input4 }, input4 || "(empty)"))),
     mode === "to-human" && /* @__PURE__ */ React32.createElement(Box22, { marginBottom: 1 }, /* @__PURE__ */ React32.createElement(Box22, { width: 20 }, /* @__PURE__ */ React32.createElement(Text23, { color: focusedField === "format" ? "green" : void 0 }, focusedField === "format" ? "\u25B6 " : "  ", "Format:")), /* @__PURE__ */ React32.createElement(Text23, { bold: true, color: focusedField === "format" ? "yellow" : void 0 }, format.toUpperCase()), focusedField === "format" && /* @__PURE__ */ React32.createElement(Text23, { dimColor: true }, " (Enter to cycle)")),
     mode === "now" && /* @__PURE__ */ React32.createElement(Box22, { marginBottom: 1 }, /* @__PURE__ */ React32.createElement(Text23, { color: focusedField === "ms" ? "green" : void 0 }, focusedField === "ms" ? "\u25B6 " : "  ", "[", useMs ? "\u2713" : " ", "] Milliseconds")),
     /* @__PURE__ */ React32.createElement(Box22, { marginTop: 1 }, /* @__PURE__ */ React32.createElement(
@@ -6431,7 +6890,7 @@ var JwtView = () => {
   const [focusedField, setFocusedField] = useState20("mode");
   const [copied, setCopied] = useState20(false);
   const service = new UtilsService();
-  useInput18((input2, key) => {
+  useInput18((input4, key) => {
     if (key.tab) {
       const fields = mode === "decode" ? ["mode", "token", "process"] : ["mode", "payload", "secret", "process"];
       const currentIndex = fields.indexOf(focusedField);
@@ -6444,7 +6903,7 @@ var JwtView = () => {
       } else {
         handleProcess();
       }
-    } else if (input2 === "c" && result.token) {
+    } else if (input4 === "c" && result.token) {
       handleCopy();
     }
   });
@@ -6569,12 +7028,12 @@ var CronView = () => {
   const [focusedField, setFocusedField] = useState21("expression");
   const [copied, setCopied] = useState21(false);
   const service = new UtilsService();
-  useInput19((input2, key) => {
+  useInput19((input4, key) => {
     if (key.tab) {
       setFocusedField(focusedField === "expression" ? "parse" : "expression");
     } else if (key.return) {
       handleParse();
-    } else if (input2 === "c" && result) {
+    } else if (input4 === "c" && result) {
       handleCopy();
     }
   });
@@ -6675,14 +7134,14 @@ var TimezoneView = () => {
   const [focusedField, setFocusedField] = useState22("time");
   const [copied, setCopied] = useState22(false);
   const service = new UtilsService();
-  useInput20((input2, key) => {
+  useInput20((input4, key) => {
     if (key.tab) {
       const fields = ["time", "from", "to", "convert"];
       const currentIndex = fields.indexOf(focusedField);
       setFocusedField(fields[(currentIndex + 1) % fields.length]);
     } else if (key.return) {
       handleConvert();
-    } else if (input2 === "c" && result) {
+    } else if (input4 === "c" && result) {
       handleCopy();
     }
   });
@@ -6801,7 +7260,7 @@ var HttpView = () => {
   const [focusedField, setFocusedField] = useState23("url");
   const [copied, setCopied] = useState23(false);
   const service = new UtilsService();
-  useInput21((input2, key) => {
+  useInput21((input4, key) => {
     if (loading) return;
     if (key.tab) {
       const fields = ["url", "method", "headers", "body", "send"];
@@ -6815,7 +7274,7 @@ var HttpView = () => {
       setMethod(METHODS[(currentIndex + 1) % METHODS.length]);
     } else if (key.return && focusedField === "send") {
       handleSend();
-    } else if (input2 === "c" && response) {
+    } else if (input4 === "c" && response) {
       handleCopy();
     }
   });
@@ -6939,14 +7398,14 @@ var HttpView = () => {
 import React37, { useState as useState24 } from "react";
 import { Box as Box27, Text as Text28, useInput as useInput22 } from "ink";
 import TextInput14 from "ink-text-input";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path5 from "path";
 var MarkdownView = () => {
   const [filePath, setFilePath] = useState24("");
   const [content, setContent] = useState24("");
   const [error, setError] = useState24("");
   const [focusedField, setFocusedField] = useState24("file");
-  useInput22((input2, key) => {
+  useInput22((input4, key) => {
     if (key.tab) {
       setFocusedField(focusedField === "file" ? "preview" : "file");
     } else if (key.return) {
@@ -6961,11 +7420,11 @@ var MarkdownView = () => {
     try {
       setError("");
       const resolvedPath = path5.resolve(filePath);
-      if (!fs8.existsSync(resolvedPath)) {
+      if (!fs9.existsSync(resolvedPath)) {
         setError(`File not found: ${resolvedPath}`);
         return;
       }
-      let fileContent = fs8.readFileSync(resolvedPath, "utf-8");
+      let fileContent = fs9.readFileSync(resolvedPath, "utf-8");
       fileContent = fileContent.replace(/```mermaid\n([\s\S]*?)```/g, (match, code) => {
         return `
 \u{1F3A8} **Mermaid Diagram**
@@ -7061,20 +7520,20 @@ var UtilsApp = ({ onExit }) => {
   const [selectedIndex, setSelectedIndex] = useState25(0);
   const [activeView, setActiveView] = useState25(null);
   const { exit } = useApp5();
-  useInput23((input2, key) => {
+  useInput23((input4, key) => {
     if (activeView) {
       if (key.escape) {
         setActiveView(null);
       }
       return;
     }
-    if (key.upArrow || input2 === "k") {
+    if (key.upArrow || input4 === "k") {
       setSelectedIndex((prev) => prev > 0 ? prev - 1 : MENU_ITEMS2.length - 1);
-    } else if (key.downArrow || input2 === "j") {
+    } else if (key.downArrow || input4 === "j") {
       setSelectedIndex((prev) => prev < MENU_ITEMS2.length - 1 ? prev + 1 : 0);
     } else if (key.return) {
       setActiveView(MENU_ITEMS2[selectedIndex].id);
-    } else if (input2 === "q" || key.escape) {
+    } else if (input4 === "q" || key.escape) {
       onExit();
       exit();
     }
@@ -7204,7 +7663,7 @@ async function runInteractiveMode() {
 
 // src/commands/utils/index.ts
 function createUtilsCommand() {
-  const utilsCommand = new Command28("utils").description("Developer utilities for common tasks").option("-i, --interactive", "Run in interactive mode").addHelpText("after", `
+  const utilsCommand = new Command29("utils").description("Developer utilities for common tasks").option("-i, --interactive", "Run in interactive mode").addHelpText("after", `
 Interactive Mode:
   $ jai1 utils --interactive
   $ jai1 utils -i
@@ -7239,14 +7698,14 @@ Quick Usage:
 }
 
 // src/commands/deps/index.ts
-import { Command as Command30 } from "commander";
+import { Command as Command31 } from "commander";
 
 // src/commands/deps/upgrade.ts
-import { Command as Command29 } from "commander";
+import { Command as Command30 } from "commander";
 import { checkbox as checkbox3, confirm as confirm4 } from "@inquirer/prompts";
 
 // src/services/deps.service.ts
-import { promises as fs9 } from "fs";
+import { promises as fs10 } from "fs";
 import path6 from "path";
 import { execSync } from "child_process";
 import pLimit2 from "p-limit";
@@ -7258,7 +7717,7 @@ var DepsService = class {
   async readPackageJson(cwd) {
     const pkgPath = path6.join(cwd, "package.json");
     try {
-      const content = await fs9.readFile(pkgPath, "utf-8");
+      const content = await fs10.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -7364,7 +7823,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs9.access(path6.join(cwd, file));
+        await fs10.access(path6.join(cwd, file));
         return pm;
       } catch {
       }
@@ -7456,7 +7915,7 @@ var colors2 = {
   dim: "\x1B[2m"
 };
 function createDepsUpgradeCommand() {
-  return new Command29("upgrade").description("Upgrade npm packages l\xEAn version m\u1EDBi nh\u1EA5t").option("--check", "Ch\u1EC9 ki\u1EC3m tra, kh\xF4ng upgrade").option("--all", "Upgrade t\u1EA5t c\u1EA3 kh\xF4ng c\u1EA7n ch\u1ECDn").option("--deps-only", "Ch\u1EC9 upgrade dependencies").option("--dev-only", "Ch\u1EC9 upgrade devDependencies").action(async (options) => {
+  return new Command30("upgrade").description("Upgrade npm packages l\xEAn version m\u1EDBi nh\u1EA5t").option("--check", "Ch\u1EC9 ki\u1EC3m tra, kh\xF4ng upgrade").option("--all", "Upgrade t\u1EA5t c\u1EA3 kh\xF4ng c\u1EA7n ch\u1ECDn").option("--deps-only", "Ch\u1EC9 upgrade dependencies").option("--dev-only", "Ch\u1EC9 upgrade devDependencies").action(async (options) => {
     await handleDepsUpgrade(options);
   });
 }
@@ -7636,20 +8095,20 @@ function displayUpgradeTable(packages) {
 
 // src/commands/deps/index.ts
 function createDepsCommand() {
-  const depsCommand = new Command30("deps").description("Qu\u1EA3n l\xFD dependencies trong project");
+  const depsCommand = new Command31("deps").description("Qu\u1EA3n l\xFD dependencies trong project");
   depsCommand.addCommand(createDepsUpgradeCommand());
   return depsCommand;
 }
 
 // src/commands/kit/index.ts
-import { Command as Command34 } from "commander";
+import { Command as Command35 } from "commander";
 
 // src/commands/kit/list.ts
-import { Command as Command31 } from "commander";
+import { Command as Command32 } from "commander";
 
 // src/services/starter-kit.service.ts
-import { promises as fs10 } from "fs";
-import { join as join4 } from "path";
+import { promises as fs11 } from "fs";
+import { join as join5 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
   /**
@@ -7696,23 +8155,23 @@ var StarterKitService = class {
       throw new NetworkError(`Failed to download kit: HTTP ${response.status}`);
     }
     if (onProgress) onProgress(30);
-    const tmpDir = join4(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs10.mkdir(tmpDir, { recursive: true });
-    const tmpFile = join4(tmpDir, `${slug}.zip`);
+    const tmpDir = join5(process.env.TMPDIR || "/tmp", "jai1-kits");
+    await fs11.mkdir(tmpDir, { recursive: true });
+    const tmpFile = join5(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs10.writeFile(tmpFile, Buffer.from(buffer));
+    await fs11.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs10.mkdir(targetDir, { recursive: true });
+    await fs11.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs10.unlink(tmpFile);
+    await fs11.unlink(tmpFile);
   }
 };
 
 // src/commands/kit/list.ts
 function createKitListCommand() {
-  return new Command31("list").description("List available starter kits").option("-c, --category <category>", "Filter by category (backend, frontend, fullstack)").option("-s, --search <term>", "Search kits by name or description").action(async (options) => {
+  return new Command32("list").description("List available starter kits").option("-c, --category <category>", "Filter by category (backend, frontend, fullstack)").option("-s, --search <term>", "Search kits by name or description").action(async (options) => {
     const configService = new ConfigService();
     const config = await configService.load();
     if (!config) {
@@ -7749,9 +8208,9 @@ function createKitListCommand() {
 }
 
 // src/commands/kit/info.ts
-import { Command as Command32 } from "commander";
+import { Command as Command33 } from "commander";
 function createKitInfoCommand() {
-  return new Command32("info").description("Show detailed information about a starter kit").argument("<slug>", "Starter kit slug").action(async (slug) => {
+  return new Command33("info").description("Show detailed information about a starter kit").argument("<slug>", "Starter kit slug").action(async (slug) => {
     const configService = new ConfigService();
     const config = await configService.load();
     if (!config) {
@@ -7800,9 +8259,9 @@ Post-Init Commands:`);
 }
 
 // src/commands/kit/create.ts
-import { Command as Command33 } from "commander";
-import { promises as fs11 } from "fs";
-import { join as join5 } from "path";
+import { Command as Command34 } from "commander";
+import { promises as fs12 } from "fs";
+import { join as join6 } from "path";
 import { select as select2, input, checkbox as checkbox4 } from "@inquirer/prompts";
 import { execa as execa2 } from "execa";
 
@@ -7845,7 +8304,7 @@ var HookExecutor = class {
 
 // src/commands/kit/create.ts
 function createKitCreateCommand() {
-  return new Command33("create").description("Create a new project from a starter kit").argument("<slug>", "Starter kit slug").argument("[directory]", "Project directory (default: ./<slug>)").option("-y, --yes", "Auto mode - use defaults, no prompts").option("--name <name>", "Project name").option("--skip-install", "Skip dependency installation").option("--skip-git", "Skip git initialization").option("--skip-framework", "Skip framework apply").option("--skip-ide", "Skip IDE sync").action(async (slug, directory, options) => {
+  return new Command34("create").description("Create a new project from a starter kit").argument("<slug>", "Starter kit slug").argument("[directory]", "Project directory (default: ./<slug>)").option("-y, --yes", "Auto mode - use defaults, no prompts").option("--name <name>", "Project name").option("--skip-install", "Skip dependency installation").option("--skip-git", "Skip git initialization").option("--skip-framework", "Skip framework apply").option("--skip-ide", "Skip IDE sync").action(async (slug, directory, options) => {
     const configService = new ConfigService();
     const config = await configService.load();
     if (!config) {
@@ -7865,9 +8324,9 @@ function createKitCreateCommand() {
         }
       }
     }
-    const targetDir = directory || join5(process.cwd(), options.name || slug);
+    const targetDir = directory || join6(process.cwd(), options.name || slug);
     try {
-      await fs11.access(targetDir);
+      await fs12.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -7985,7 +8444,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs11.readFile(file, "utf-8");
+    let content = await fs12.readFile(file, "utf-8");
     let modified = false;
     for (const [key, value] of Object.entries(variables)) {
       const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
@@ -7995,15 +8454,15 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs11.writeFile(file, content, "utf-8");
+      await fs12.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs11.readdir(dir, { withFileTypes: true });
+  const entries = await fs12.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join5(dir, entry.name);
+    const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
         files.push(...await getAllFiles(fullPath));
@@ -8017,7 +8476,7 @@ async function getAllFiles(dir) {
 
 // src/commands/kit/index.ts
 function createKitCommand() {
-  const cmd = new Command34("kit").description("Manage starter kits for new projects").action(() => {
+  const cmd = new Command35("kit").description("Manage starter kits for new projects").action(() => {
     cmd.help();
   });
   cmd.addCommand(createKitListCommand());
@@ -8026,25 +8485,1335 @@ function createKitCommand() {
   return cmd;
 }
 
-// src/commands/upgrade.ts
-import { Command as Command35 } from "commander";
-import { confirm as confirm5 } from "@inquirer/prompts";
-import { execSync as execSync2 } from "child_process";
-var colors3 = {
-  yellow: "\x1B[33m",
-  green: "\x1B[32m",
-  cyan: "\x1B[36m",
-  red: "\x1B[31m",
-  reset: "\x1B[0m",
-  bold: "\x1B[1m"
-};
-function createUpgradeCommand() {
-  return new Command35("upgrade").description("Upgrade jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force upgrade without confirmation").action(async (options) => {
-    await handleUpgrade(options);
+// src/commands/rules/index.ts
+import { Command as Command42 } from "commander";
+
+// src/commands/rules/list.ts
+import { Command as Command36 } from "commander";
+function createRulesListCommand() {
+  return new Command36("list").description("List available rule presets").option("--json", "Output as JSON").action(async (options) => {
+    const configService = new ConfigService();
+    const config = await configService.load();
+    if (!config) {
+      throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+    }
+    console.log("\u{1F4CB} Fetching available rule presets...\n");
+    try {
+      const response = await fetch(`${config.apiUrl}/api/rules/presets`, {
+        headers: {
+          "JAI1-Access-Key": config.accessKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch presets: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (options.json) {
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+      if (data.total === 0) {
+        console.log("No presets available.");
+        return;
+      }
+      console.log(`Found ${data.total} preset${data.total > 1 ? "s" : ""}:
+`);
+      for (const preset of data.presets) {
+        console.log(`\u{1F4E6} ${preset.slug}`);
+        console.log(`   Name: ${preset.name}`);
+        console.log(`   Description: ${preset.description}`);
+        console.log(`   Version: ${preset.version}`);
+        const stackParts = [];
+        if (preset.stack.frontend) stackParts.push(preset.stack.frontend);
+        if (preset.stack.backend) stackParts.push(preset.stack.backend);
+        if (preset.stack.css) stackParts.push(preset.stack.css);
+        if (preset.stack.database) stackParts.push(preset.stack.database);
+        if (stackParts.length > 0) {
+          console.log(`   Stack: ${stackParts.join(" + ")}`);
+        }
+        console.log(`   Tags: ${preset.tags.join(", ")}`);
+        console.log(`   Downloads: ${preset.downloads}`);
+        console.log("");
+      }
+      console.log(`
+\u2139\uFE0F  Use 'jai1 rules init --preset=<slug>' to apply a preset`);
+    } catch (error) {
+      throw new Error(
+        `Failed to list presets: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
   });
 }
-async function handleUpgrade(options) {
-  const configService = new ConfigService();
+
+// src/commands/rules/init.ts
+import { Command as Command37 } from "commander";
+import { promises as fs13 } from "fs";
+import { join as join7 } from "path";
+import { select as select3, confirm as confirm5 } from "@inquirer/prompts";
+function createRulesInitCommand() {
+  return new Command37("init").description("Apply rule preset to project").option("--preset <slug>", "Preset slug to apply").option("--output <format>", "Output format: cursor, agents-md, both (default: cursor)", "cursor").option("-y, --yes", "Skip confirmations").action(async (options) => {
+    const configService = new ConfigService();
+    const config = await configService.load();
+    if (!config) {
+      throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+    }
+    let presetSlug = options.preset;
+    if (!presetSlug) {
+      console.log("\u{1F4CB} Fetching available presets...\n");
+      const response = await fetch(`${config.apiUrl}/api/rules/presets`, {
+        headers: {
+          "JAI1-Access-Key": config.accessKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch presets: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.total === 0) {
+        console.log("No presets available.");
+        return;
+      }
+      presetSlug = await select3({
+        message: "Select a preset:",
+        choices: data.presets.map((p) => ({
+          name: `${p.name} - ${p.description}`,
+          value: p.slug,
+          description: `v${p.version} | ${p.tags.join(", ")}`
+        }))
+      });
+    }
+    console.log(`
+\u{1F4E6} Fetching preset: ${presetSlug}...
+`);
+    const presetResponse = await fetch(`${config.apiUrl}/api/rules/presets/${presetSlug}`, {
+      headers: {
+        "JAI1-Access-Key": config.accessKey
+      }
+    });
+    if (!presetResponse.ok) {
+      if (presetResponse.status === 404) {
+        throw new Error(`Preset '${presetSlug}' not found`);
+      }
+      throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
+    }
+    const bundle = await presetResponse.json();
+    console.log(`\u2713 Preset: ${bundle.preset.name} v${bundle.preset.version}`);
+    console.log(`  Files: ${Object.keys(bundle.files).length}`);
+    let outputFormat = options.output;
+    if (!["cursor", "agents-md", "both"].includes(outputFormat)) {
+      outputFormat = await select3({
+        message: "Select output format:",
+        choices: [
+          { name: "Cursor (.cursor/rules/)", value: "cursor" },
+          { name: "AGENTS.md (single file)", value: "agents-md" },
+          { name: "Both", value: "both" }
+        ]
+      });
+    }
+    if (!options.yes) {
+      const proceed = await confirm5({
+        message: `Apply preset '${bundle.preset.name}' to current directory?`,
+        default: true
+      });
+      if (!proceed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    console.log("\n\u{1F4DD} Applying preset...\n");
+    if (outputFormat === "cursor" || outputFormat === "both") {
+      await applyCursorFormat(bundle);
+    }
+    if (outputFormat === "agents-md" || outputFormat === "both") {
+      await applyAgentsMdFormat(bundle);
+    }
+    const projectConfig = {
+      preset: bundle.preset.slug,
+      version: bundle.preset.version,
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      customContext: "09-custom.mdc"
+    };
+    await fs13.writeFile("jai1-rules.json", JSON.stringify(projectConfig, null, 2));
+    console.log("\u2713 Created jai1-rules.json");
+    console.log("\n\u2705 Preset applied successfully!\n");
+    console.log("Next steps:");
+    console.log("  1. Edit 09-custom.mdc to add project-specific rules");
+    console.log("  2. Commit the rules to git");
+    console.log('  3. Use "jai1 rules sync" to regenerate outputs after editing\n');
+  });
+}
+async function applyCursorFormat(bundle) {
+  const rulesDir = join7(process.cwd(), ".cursor", "rules");
+  await fs13.mkdir(rulesDir, { recursive: true });
+  for (const [filename, content] of Object.entries(bundle.files)) {
+    const filePath = join7(rulesDir, filename);
+    await fs13.writeFile(filePath, content, "utf-8");
+    console.log(`\u2713 Created .cursor/rules/${filename}`);
+  }
+}
+async function applyAgentsMdFormat(bundle) {
+  const sections = [];
+  sections.push("# AGENTS.md\n");
+  sections.push(`<!-- Generated by jai1 rules - Preset: ${bundle.preset.slug} v${bundle.preset.version} -->
+`);
+  const fileOrder = [
+    "01-project.mdc",
+    "02-standards.mdc",
+    "03-frontend.mdc",
+    "04-backend.mdc",
+    "05-testing.mdc",
+    "06-workflow.mdc",
+    "09-custom.mdc"
+  ];
+  for (const filename of fileOrder) {
+    if (bundle.files[filename]) {
+      const content = bundle.files[filename];
+      const withoutFrontmatter = content.replace(/^---\n[\s\S]*?\n---\n/, "");
+      sections.push(withoutFrontmatter.trim());
+      sections.push("\n");
+    }
+  }
+  const agentsMd = sections.join("\n");
+  await fs13.writeFile("AGENTS.md", agentsMd, "utf-8");
+  console.log("\u2713 Created AGENTS.md");
+}
+
+// src/commands/rules/apply.ts
+import { Command as Command38 } from "commander";
+import { promises as fs15 } from "fs";
+import { join as join9 } from "path";
+import { select as select4, confirm as confirm6, checkbox as checkbox5 } from "@inquirer/prompts";
+
+// src/services/rules-generator.service.ts
+var RulesGeneratorService = class {
+  /**
+   * Generate files for a specific IDE format
+   */
+  generateForIde(bundle, ideId) {
+    const format = IDE_FORMATS[ideId];
+    if (!format) {
+      throw new Error(`Unknown IDE format: ${ideId}`);
+    }
+    switch (ideId) {
+      case "cursor":
+        return this.generateCursorFiles(bundle, format);
+      case "windsurf":
+        return this.generateWindsurfFiles(bundle, format);
+      case "antigravity":
+        return this.generateAntigravityFiles(bundle, format);
+      case "claude":
+        return this.generateClaudeFiles(bundle, format);
+      case "agentsmd":
+        return this.generateAgentsMd(bundle, format);
+      case "gemini":
+        return this.generateGeminiMd(bundle, format);
+      default:
+        throw new Error(`Unsupported IDE format: ${ideId}`);
+    }
+  }
+  /**
+   * Generate Cursor format (.mdc files)
+   */
+  generateCursorFiles(bundle, format) {
+    const files = [];
+    files.push({
+      path: `${format.rulesPath}/00-jai1${format.fileExtension}`,
+      content: this.generateCursorJai1Rule(),
+      description: "Jai1 Framework base rule"
+    });
+    for (const [filename, content] of Object.entries(bundle.files)) {
+      files.push({
+        path: `${format.rulesPath}/${filename}`,
+        content,
+        // Already in .mdc format
+        description: `Preset rule: ${filename}`
+      });
+    }
+    return files;
+  }
+  /**
+   * Generate Cursor jai1 base rule
+   */
+  generateCursorJai1Rule() {
+    return `---
+description: Jai1 Framework integration and skill loading
+globs: ["**/*"]
+alwaysApply: true
+---
+
+${JAI1_BASE_RULE}`;
+  }
+  /**
+   * Generate Windsurf format (.md files with trigger metadata)
+   */
+  generateWindsurfFiles(bundle, format) {
+    const files = [];
+    files.push({
+      path: `${format.rulesPath}/00-jai1${format.fileExtension}`,
+      content: this.generateWindsurfJai1Rule(),
+      description: "Jai1 Framework base rule"
+    });
+    for (const [filename, content] of Object.entries(bundle.files)) {
+      const converted = this.convertToWindsurf(content, filename);
+      const newFilename = filename.replace(/\.mdc$/, ".md");
+      files.push({
+        path: `${format.rulesPath}/${newFilename}`,
+        content: converted,
+        description: `Preset rule: ${newFilename}`
+      });
+    }
+    return files;
+  }
+  /**
+   * Convert Cursor format to Windsurf format
+   */
+  convertToWindsurf(content, filename) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+      return content;
+    }
+    const [, frontmatter, body] = frontmatterMatch;
+    const parsed = this.parseFrontmatter(frontmatter);
+    let trigger = "always";
+    if (parsed.alwaysApply === "true" || parsed.alwaysApply === true) {
+      trigger = "always";
+    } else if (parsed.globs && parsed.globs.length > 0) {
+      trigger = parsed.globs.join(", ");
+    }
+    const windsurfFrontmatter = `---
+trigger: ${trigger}
+---`;
+    return `${windsurfFrontmatter}
+
+${body.trim()}
+`;
+  }
+  /**
+   * Generate Windsurf jai1 base rule
+   */
+  generateWindsurfJai1Rule() {
+    return `---
+trigger: always
+---
+
+${JAI1_BASE_RULE}`;
+  }
+  /**
+   * Generate Antigravity format (.md files with trigger metadata + @AGENTS.md reference)
+   */
+  generateAntigravityFiles(bundle, format) {
+    const files = [];
+    files.push({
+      path: `${format.rulesPath}/00-jai1${format.fileExtension}`,
+      content: this.generateAntigravityJai1Rule(),
+      description: "Jai1 Framework base rule"
+    });
+    for (const [filename, content] of Object.entries(bundle.files)) {
+      const converted = this.convertToAntigravity(content, filename);
+      const newFilename = filename.replace(/\.mdc$/, ".md");
+      files.push({
+        path: `${format.rulesPath}/${newFilename}`,
+        content: converted,
+        description: `Preset rule: ${newFilename}`
+      });
+    }
+    return files;
+  }
+  /**
+   * Convert Cursor format to Antigravity format
+   */
+  convertToAntigravity(content, filename) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+      return content;
+    }
+    const [, frontmatter, body] = frontmatterMatch;
+    const parsed = this.parseFrontmatter(frontmatter);
+    let trigger = "always_on";
+    if (parsed.alwaysApply === "true" || parsed.alwaysApply === true) {
+      trigger = "always_on";
+    }
+    const antigravityFrontmatter = `---
+trigger: ${trigger}
+---
+
+@AGENTS.md`;
+    return `${antigravityFrontmatter}
+
+${body.trim()}
+`;
+  }
+  /**
+   * Generate Antigravity jai1 base rule
+   */
+  generateAntigravityJai1Rule() {
+    return `---
+trigger: always_on
+---
+
+@AGENTS.md
+
+${JAI1_BASE_RULE}`;
+  }
+  /**
+   * Generate Claude Code format (.md files with paths metadata)
+   */
+  generateClaudeFiles(bundle, format) {
+    const files = [];
+    files.push({
+      path: `${format.rulesPath}/00-jai1${format.fileExtension}`,
+      content: this.generateClaudeJai1Rule(),
+      description: "Jai1 Framework base rule"
+    });
+    for (const [filename, content] of Object.entries(bundle.files)) {
+      const converted = this.convertToClaude(content, filename);
+      const newFilename = filename.replace(/\.mdc$/, ".md");
+      files.push({
+        path: `${format.rulesPath}/${newFilename}`,
+        content: converted,
+        description: `Preset rule: ${newFilename}`
+      });
+    }
+    return files;
+  }
+  /**
+   * Convert Cursor format to Claude format
+   */
+  convertToClaude(content, filename) {
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!frontmatterMatch) {
+      return content;
+    }
+    const [, frontmatter, body] = frontmatterMatch;
+    const parsed = this.parseFrontmatter(frontmatter);
+    let metadata = `---
+description: ${parsed.description || "Rule"}`;
+    if (parsed.globs && parsed.globs.length > 0) {
+      const paths = parsed.globs.map((g) => g.replace(/[\[\]"]/g, "")).join(", ");
+      metadata += `
+paths: ${paths}`;
+    }
+    metadata += "\n---";
+    return `${metadata}
+
+${body.trim()}
+`;
+  }
+  /**
+   * Generate Claude jai1 base rule
+   */
+  generateClaudeJai1Rule() {
+    return `---
+description: Jai1 Framework integration and skill loading
+paths: **/*
+---
+
+${JAI1_BASE_RULE}`;
+  }
+  /**
+   * Generate AGENTS.md file (single merged file)
+   */
+  generateAgentsMd(bundle, format) {
+    const sections = [];
+    sections.push("# AGENTS.md\n");
+    sections.push(`<!-- Generated by jai1 rules - Preset: ${bundle.preset.slug} v${bundle.preset.version} -->
+`);
+    sections.push("## Jai1 Framework Integration\n");
+    sections.push(JAI1_BASE_RULE.trim());
+    sections.push("\n---\n");
+    const fileOrder = [
+      "01-project.mdc",
+      "02-standards.mdc",
+      "03-frontend.mdc",
+      "04-backend.mdc",
+      "05-testing.mdc",
+      "06-workflow.mdc",
+      "07-deployment.mdc",
+      "08-database.mdc",
+      "09-custom.mdc"
+    ];
+    for (const filename of fileOrder) {
+      if (bundle.files[filename]) {
+        const content = bundle.files[filename];
+        const withoutFrontmatter = this.removeFrontmatter(content);
+        if (withoutFrontmatter.trim()) {
+          sections.push(withoutFrontmatter.trim());
+          sections.push("\n");
+        }
+      }
+    }
+    const agentsMd = sections.join("\n");
+    return [
+      {
+        path: "AGENTS.md",
+        content: agentsMd,
+        description: "Single AGENTS.md file with all rules"
+      }
+    ];
+  }
+  /**
+   * Generate Gemini CLI format (GEMINI.md that references AGENTS.md)
+   */
+  generateGeminiMd(bundle, format) {
+    const content = `# Gemini Instructions
+
+@AGENTS.md
+
+You are an AI coding assistant integrated with the Jai1 Framework.
+Follow all instructions and patterns defined in AGENTS.md above.
+
+## Additional Gemini-Specific Guidelines
+
+- Use the context from AGENTS.md for all coding decisions
+- Apply the Jai1 Framework patterns consistently
+- Reference skills using the @jai1-[skill-name] syntax
+- Maintain consistency with project standards
+
+<!-- Generated by jai1 rules - Preset: ${bundle.preset.slug} v${bundle.preset.version} -->
+`;
+    return [
+      {
+        path: "GEMINI.md",
+        content,
+        description: "Gemini CLI instructions file"
+      }
+    ];
+  }
+  /**
+   * Remove frontmatter from content
+   */
+  removeFrontmatter(content) {
+    return content.replace(/^---\n[\s\S]*?\n---\n/, "");
+  }
+  /**
+   * Parse YAML frontmatter into object
+   */
+  parseFrontmatter(frontmatter) {
+    const result = {};
+    const lines = frontmatter.split("\n");
+    for (const line of lines) {
+      const match = line.match(/^(\w+):\s*(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        if (value.startsWith("[") && value.endsWith("]")) {
+          result[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, ""));
+        } else if (value === "true" || value === "false") {
+          result[key] = value === "true";
+        } else {
+          result[key] = value.replace(/^["']|["']$/g, "");
+        }
+      }
+    }
+    return result;
+  }
+  /**
+   * Get all IDE IDs that can be generated
+   */
+  getAvailableIdes() {
+    return Object.keys(IDE_FORMATS);
+  }
+  /**
+   * Check if IDE format exists
+   */
+  isValidIde(ideId) {
+    return ideId in IDE_FORMATS;
+  }
+  /**
+   * Get IDE format details
+   */
+  getIdeFormat(ideId) {
+    return IDE_FORMATS[ideId];
+  }
+  /**
+   * Resolve IDE dependencies
+   * For example, Gemini requires AGENTS.md
+   */
+  resolveIdeDependencies(ides) {
+    const resolved = new Set(ides);
+    for (const ide of ides) {
+      const format = IDE_FORMATS[ide];
+      if (format?.dependencies) {
+        format.dependencies.forEach((dep) => resolved.add(dep));
+      }
+    }
+    return Array.from(resolved);
+  }
+};
+
+// src/services/backup.service.ts
+import { promises as fs14 } from "fs";
+import { join as join8, dirname } from "path";
+var BackupService = class {
+  backupDir = ".jai1/backups";
+  /**
+   * Create backup of existing rules for specified IDEs
+   */
+  async createBackup(ides, presetSlug) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = join8(this.backupDir, timestamp);
+    const backedUpFiles = [];
+    let hasContent = false;
+    for (const ideId of ides) {
+      const format = IDE_FORMATS[ideId];
+      if (!format) {
+        console.warn(`Unknown IDE format: ${ideId}, skipping backup`);
+        continue;
+      }
+      const rulesPath = format.rulesPath === "." ? process.cwd() : join8(process.cwd(), format.rulesPath);
+      try {
+        const exists = await this.pathExists(rulesPath);
+        if (!exists) {
+          continue;
+        }
+        if (ideId === "agentsmd") {
+          await this.backupSingleFile("AGENTS.md", backupPath, ideId, backedUpFiles);
+          hasContent = true;
+        } else if (ideId === "gemini") {
+          await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
+          hasContent = true;
+        } else {
+          const stats = await fs14.stat(rulesPath);
+          if (stats.isDirectory()) {
+            const files = await fs14.readdir(rulesPath);
+            for (const file of files) {
+              if (file.endsWith(format.fileExtension)) {
+                const originalPath = join8(rulesPath, file);
+                const relativePath = join8(format.rulesPath, file);
+                const destPath = join8(backupPath, ideId, file);
+                await fs14.mkdir(dirname(destPath), { recursive: true });
+                await fs14.copyFile(originalPath, destPath);
+                backedUpFiles.push({
+                  originalPath: relativePath,
+                  backupPath: join8(ideId, file),
+                  ide: ideId
+                });
+                hasContent = true;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    if (!hasContent) {
+      return null;
+    }
+    const metadata = {
+      timestamp,
+      preset: presetSlug,
+      ides,
+      files: backedUpFiles
+    };
+    await fs14.mkdir(backupPath, { recursive: true });
+    await fs14.writeFile(
+      join8(backupPath, "metadata.json"),
+      JSON.stringify(metadata, null, 2),
+      "utf-8"
+    );
+    return backupPath;
+  }
+  /**
+   * Backup a single file (for AGENTS.md, GEMINI.md)
+   */
+  async backupSingleFile(filename, backupPath, ideId, backedUpFiles) {
+    const originalPath = join8(process.cwd(), filename);
+    try {
+      const exists = await this.pathExists(originalPath);
+      if (!exists) {
+        return;
+      }
+      const destPath = join8(backupPath, ideId, filename);
+      await fs14.mkdir(dirname(destPath), { recursive: true });
+      await fs14.copyFile(originalPath, destPath);
+      backedUpFiles.push({
+        originalPath: filename,
+        backupPath: join8(ideId, filename),
+        ide: ideId
+      });
+    } catch (error) {
+    }
+  }
+  /**
+   * Restore files from a backup
+   */
+  async restoreBackup(backupPath) {
+    const metadataPath = join8(backupPath, "metadata.json");
+    const metadataContent = await fs14.readFile(metadataPath, "utf-8");
+    const metadata = JSON.parse(metadataContent);
+    console.log(`
+Restoring backup from ${metadata.timestamp}...`);
+    for (const file of metadata.files) {
+      const sourcePath = join8(backupPath, file.backupPath);
+      const destPath = join8(process.cwd(), file.originalPath);
+      await fs14.mkdir(dirname(destPath), { recursive: true });
+      await fs14.copyFile(sourcePath, destPath);
+      console.log(`\u2713 Restored ${file.originalPath}`);
+    }
+    console.log("\n\u2705 Backup restored successfully!");
+  }
+  /**
+   * List all available backups
+   */
+  async listBackups() {
+    try {
+      const backupDirPath = join8(process.cwd(), this.backupDir);
+      const exists = await this.pathExists(backupDirPath);
+      if (!exists) {
+        return [];
+      }
+      const entries = await fs14.readdir(backupDirPath, { withFileTypes: true });
+      const backups = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const metadataPath = join8(backupDirPath, entry.name, "metadata.json");
+          try {
+            const metadataContent = await fs14.readFile(metadataPath, "utf-8");
+            const metadata = JSON.parse(metadataContent);
+            backups.push(metadata);
+          } catch {
+            continue;
+          }
+        }
+      }
+      return backups.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Delete a specific backup
+   */
+  async deleteBackup(timestamp) {
+    const backupPath = join8(process.cwd(), this.backupDir, timestamp);
+    await this.deleteDirectory(backupPath);
+  }
+  /**
+   * Delete all backups older than specified days
+   */
+  async cleanupOldBackups(daysToKeep = 30) {
+    const backups = await this.listBackups();
+    const cutoffDate = /* @__PURE__ */ new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+    let deletedCount = 0;
+    for (const backup of backups) {
+      const backupDate = new Date(backup.timestamp);
+      if (backupDate < cutoffDate) {
+        await this.deleteBackup(backup.timestamp);
+        deletedCount++;
+      }
+    }
+    return deletedCount;
+  }
+  /**
+   * Get the most recent backup
+   */
+  async getLatestBackup() {
+    const backups = await this.listBackups();
+    return backups.length > 0 ? backups[0] : null;
+  }
+  /**
+   * Check if a path exists
+   */
+  async pathExists(path8) {
+    try {
+      await fs14.access(path8);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Recursively delete a directory
+   */
+  async deleteDirectory(path8) {
+    try {
+      const exists = await this.pathExists(path8);
+      if (!exists) {
+        return;
+      }
+      const entries = await fs14.readdir(path8, { withFileTypes: true });
+      for (const entry of entries) {
+        const fullPath = join8(path8, entry.name);
+        if (entry.isDirectory()) {
+          await this.deleteDirectory(fullPath);
+        } else {
+          await fs14.unlink(fullPath);
+        }
+      }
+      await fs14.rmdir(path8);
+    } catch (error) {
+    }
+  }
+  /**
+   * Get backup directory path
+   */
+  getBackupDir() {
+    return join8(process.cwd(), this.backupDir);
+  }
+  /**
+   * Ensure backup directory exists
+   */
+  async ensureBackupDir() {
+    const backupDirPath = join8(process.cwd(), this.backupDir);
+    await fs14.mkdir(backupDirPath, { recursive: true });
+  }
+};
+
+// src/commands/rules/apply.ts
+function createRulesApplyCommand() {
+  return new Command38("apply").description("Apply rule preset to project with multi-IDE support").argument("[preset]", "Preset slug to apply (optional)").option("--ides <ides>", "Comma-separated list of IDE formats (cursor,windsurf,antigravity,claude,agentsmd,gemini)").option("--skip-backup", "Skip backup creation").option("-y, --yes", "Skip all confirmations (auto mode)").action(async (presetSlug, options) => {
+    const configService = new ConfigService();
+    const config = await configService.load();
+    if (!config) {
+      throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+    }
+    const generatorService = new RulesGeneratorService();
+    const backupService = new BackupService();
+    const autoMode = options.yes === true;
+    const skipBackup = options.skipBackup === true;
+    let selectedIdes = [];
+    if (options.ides) {
+      selectedIdes = options.ides.split(",").map((ide) => ide.trim()).filter((ide) => generatorService.isValidIde(ide));
+      if (selectedIdes.length === 0) {
+        throw new ValidationError("No valid IDE formats specified");
+      }
+    }
+    if (!presetSlug) {
+      console.log("\u{1F4CB} Fetching available presets...\n");
+      const response = await fetch(`${config.apiUrl}/api/rules/presets`, {
+        headers: {
+          "JAI1-Access-Key": config.accessKey
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch presets: ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.total === 0) {
+        console.log("No presets available.");
+        return;
+      }
+      presetSlug = await select4({
+        message: "Select a preset:",
+        choices: data.presets.map((p) => ({
+          name: `${p.name} - ${p.description}`,
+          value: p.slug,
+          description: `v${p.version} | ${p.tags.join(", ")}`
+        }))
+      });
+    }
+    console.log(`
+\u{1F4E6} Fetching preset: ${presetSlug}...
+`);
+    const presetResponse = await fetch(`${config.apiUrl}/api/rules/presets/${presetSlug}`, {
+      headers: {
+        "JAI1-Access-Key": config.accessKey
+      }
+    });
+    if (!presetResponse.ok) {
+      if (presetResponse.status === 404) {
+        throw new Error(`Preset '${presetSlug}' not found`);
+      }
+      throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
+    }
+    const bundle = await presetResponse.json();
+    console.log(`\u2713 Preset: ${bundle.preset.name} v${bundle.preset.version}`);
+    console.log(`  Files: ${Object.keys(bundle.files).length}`);
+    if (selectedIdes.length === 0) {
+      if (autoMode) {
+        selectedIdes = ["cursor"];
+      } else {
+        const detectionService = new IdeDetectionService();
+        const suggestions = await detectionService.suggestIdes();
+        const detected = await detectionService.detectActiveIdes();
+        if (suggestions.length > 0) {
+          console.log("\n\u{1F4A1} Smart suggestions based on your project:\n");
+          suggestions.slice(0, 3).forEach((s) => {
+            const priority = s.priority === "high" ? "\u2B50" : s.priority === "medium" ? "\u{1F538}" : "\u25AB\uFE0F";
+            console.log(`${priority} ${s.name} - ${s.reason}`);
+          });
+          console.log("");
+        }
+        const choices = [
+          {
+            name: "Cursor (.cursor/rules/)",
+            value: "cursor",
+            checked: suggestions.some((s) => s.ideId === "cursor") || detected.some((d) => d.id === "cursor")
+          },
+          {
+            name: "Windsurf (.windsurf/rules/)",
+            value: "windsurf",
+            checked: detected.some((d) => d.id === "windsurf")
+          },
+          {
+            name: "Antigravity (.agent/rules/)",
+            value: "antigravity",
+            checked: detected.some((d) => d.id === "antigravity")
+          },
+          {
+            name: "Claude Code (.claude/rules/)",
+            value: "claude",
+            checked: suggestions.some((s) => s.ideId === "claude") || detected.some((d) => d.id === "claude")
+          },
+          {
+            name: "AGENTS.md (single file)",
+            value: "agentsmd",
+            checked: suggestions.some((s) => s.ideId === "agentsmd")
+          },
+          {
+            name: "Gemini CLI (GEMINI.md)",
+            value: "gemini",
+            checked: detected.some((d) => d.id === "gemini")
+          }
+        ];
+        selectedIdes = await checkbox5({
+          message: "Select IDE formats to generate (pre-selected are recommended):",
+          choices,
+          required: true
+        });
+      }
+    }
+    const resolvedIdes = generatorService.resolveIdeDependencies(selectedIdes);
+    if (resolvedIdes.length > selectedIdes.length) {
+      const addedIdes = resolvedIdes.filter((ide) => !selectedIdes.includes(ide));
+      console.log(`
+\u{1F4CC} Auto-added dependencies: ${addedIdes.join(", ")}`);
+    }
+    let backupPath = null;
+    if (!skipBackup) {
+      console.log("\n\u{1F4BE} Creating backup of existing rules...");
+      try {
+        backupPath = await backupService.createBackup(resolvedIdes, presetSlug);
+        if (backupPath) {
+          console.log(`\u2713 Backup created: ${backupPath}`);
+        } else {
+          console.log("\u2713 No existing files to backup");
+        }
+      } catch (error) {
+        console.warn("\u26A0\uFE0F  Backup failed, but continuing...");
+      }
+    }
+    if (!autoMode) {
+      console.log("\n\u{1F4CB} Summary:");
+      console.log(`  Preset: ${bundle.preset.name} v${bundle.preset.version}`);
+      console.log(`  IDEs: ${resolvedIdes.join(", ")}`);
+      console.log(`  Files: ${Object.keys(bundle.files).length} rule files`);
+      if (backupPath) {
+        console.log(`  Backup: ${backupPath}`);
+      }
+      const proceed = await confirm6({
+        message: "Apply these rules to the current directory?",
+        default: true
+      });
+      if (!proceed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    console.log("\n\u{1F4DD} Applying preset...\n");
+    const allGeneratedFiles = [];
+    for (const ideId of resolvedIdes) {
+      try {
+        const files = generatorService.generateForIde(bundle, ideId);
+        for (const file of files) {
+          const fullPath = join9(process.cwd(), file.path);
+          await fs15.mkdir(join9(fullPath, ".."), { recursive: true });
+          await fs15.writeFile(fullPath, file.content, "utf-8");
+          console.log(`\u2713 [${ideId}] ${file.path}`);
+          allGeneratedFiles.push({
+            ide: ideId,
+            path: file.path,
+            description: file.description
+          });
+        }
+      } catch (error) {
+        console.error(`\u2717 Failed to generate ${ideId} files:`, error);
+      }
+    }
+    const projectConfig = {
+      preset: bundle.preset.slug,
+      version: bundle.preset.version,
+      appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      ides: resolvedIdes,
+      customContext: "09-custom.mdc",
+      backups: backupPath ? [
+        {
+          path: backupPath,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          ides: resolvedIdes
+        }
+      ] : []
+    };
+    try {
+      const existingConfigPath = join9(process.cwd(), "jai1-rules.json");
+      const existingConfigContent = await fs15.readFile(existingConfigPath, "utf-8");
+      const existingConfig = JSON.parse(existingConfigContent);
+      if (existingConfig.backups && existingConfig.backups.length > 0) {
+        projectConfig.backups = [
+          ...projectConfig.backups,
+          ...existingConfig.backups.slice(0, 5)
+          // Keep last 5 backups
+        ];
+      }
+    } catch {
+    }
+    await fs15.writeFile(
+      join9(process.cwd(), "jai1-rules.json"),
+      JSON.stringify(projectConfig, null, 2),
+      "utf-8"
+    );
+    console.log("\n\u2713 Updated jai1-rules.json");
+    console.log("\n\u2705 Preset applied successfully!\n");
+    console.log("\u{1F4CA} Summary:");
+    console.log(`  Generated ${allGeneratedFiles.length} files across ${resolvedIdes.length} IDE(s)`);
+    const filesByIde = resolvedIdes.reduce((acc, ide) => {
+      acc[ide] = allGeneratedFiles.filter((f) => f.ide === ide).length;
+      return acc;
+    }, {});
+    for (const [ide, count] of Object.entries(filesByIde)) {
+      const format = IDE_FORMATS[ide];
+      console.log(`  - ${format?.name}: ${count} files`);
+    }
+    if (backupPath) {
+      console.log(`
+\u{1F4BE} Backup saved to: ${backupPath}`);
+      console.log('   Use "jai1 rules restore" to restore if needed');
+    }
+    console.log("\n\u{1F4DD} Next steps:");
+    console.log("  1. Review generated files in your IDE");
+    console.log("  2. Edit custom rules if needed (look for 09-custom.*)");
+    console.log("  3. Commit the rules to git");
+    console.log('  4. Use "jai1 rules sync" to regenerate after editing');
+    console.log('  5. Use "jai1 ide status" to check IDE configuration\n');
+  });
+}
+
+// src/commands/rules/restore.ts
+import { Command as Command39 } from "commander";
+import { join as join10 } from "path";
+import { select as select5, confirm as confirm7 } from "@inquirer/prompts";
+function createRulesRestoreCommand() {
+  return new Command39("restore").description("Restore rules from a backup").option("--latest", "Restore the most recent backup").option("-y, --yes", "Skip confirmation").action(async (options) => {
+    const backupService = new BackupService();
+    const backups = await backupService.listBackups();
+    if (backups.length === 0) {
+      console.log("No backups available.");
+      return;
+    }
+    let selectedBackup;
+    if (options.latest) {
+      selectedBackup = backups[0];
+      console.log(`\u{1F4E6} Selected latest backup: ${selectedBackup.timestamp}`);
+    } else {
+      console.log("\u{1F4CB} Available backups:\n");
+      const backupTimestamp = await select5({
+        message: "Select a backup to restore:",
+        choices: backups.map((backup) => ({
+          name: formatBackupInfo(backup),
+          value: backup.timestamp,
+          description: `${backup.files.length} files | IDEs: ${backup.ides.join(", ")}`
+        }))
+      });
+      selectedBackup = backups.find((b) => b.timestamp === backupTimestamp);
+      if (!selectedBackup) {
+        throw new ValidationError("Backup not found");
+      }
+    }
+    console.log("\n\u{1F4CA} Backup Details:");
+    console.log(`  Timestamp: ${formatTimestamp(selectedBackup.timestamp)}`);
+    console.log(`  Preset: ${selectedBackup.preset || "N/A"}`);
+    console.log(`  IDEs: ${selectedBackup.ides.join(", ")}`);
+    console.log(`  Files: ${selectedBackup.files.length}`);
+    if (!options.yes) {
+      const proceed = await confirm7({
+        message: "This will overwrite current rules. Continue?",
+        default: false
+      });
+      if (!proceed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    console.log("\n\u{1F504} Restoring backup...\n");
+    try {
+      const backupPath = join10(backupService.getBackupDir(), selectedBackup.timestamp);
+      await backupService.restoreBackup(backupPath);
+      console.log("\n\u2705 Backup restored successfully!\n");
+      console.log("\u{1F4A1} Tip: Your IDE may need to be restarted to pick up the changes.");
+    } catch (error) {
+      console.error("\n\u274C Failed to restore backup:", error);
+      throw error;
+    }
+  });
+}
+function formatBackupInfo(backup) {
+  const timestamp = formatTimestamp(backup.timestamp);
+  const preset = backup.preset ? ` [${backup.preset}]` : "";
+  return `${timestamp}${preset}`;
+}
+function formatTimestamp(timestamp) {
+  try {
+    const date = new Date(timestamp);
+    return date.toLocaleString();
+  } catch {
+    return timestamp;
+  }
+}
+
+// src/commands/rules/sync.ts
+import { Command as Command40 } from "commander";
+import { promises as fs16 } from "fs";
+import { join as join11 } from "path";
+import { confirm as confirm8 } from "@inquirer/prompts";
+function createRulesSyncCommand() {
+  return new Command40("sync").description("Regenerate rule outputs for all configured IDEs").option("--ides <ides>", "Comma-separated list of IDEs to sync (default: all configured)").option("--detect", "Auto-detect active IDEs instead of using config").option("-y, --yes", "Skip confirmations").action(async (options) => {
+    const configPath = join11(process.cwd(), "jai1-rules.json");
+    let projectConfig;
+    try {
+      const configContent = await fs16.readFile(configPath, "utf-8");
+      projectConfig = JSON.parse(configContent);
+    } catch {
+      throw new ValidationError(
+        'No jai1-rules.json found. Run "jai1 rules apply" first.'
+      );
+    }
+    console.log("\u{1F504} Syncing rules...\n");
+    console.log(`Preset: ${projectConfig.preset} v${projectConfig.version}`);
+    let idesToSync = [];
+    if (options.detect) {
+      console.log("\n\u{1F50D} Auto-detecting active IDEs...");
+      const detectionService = new IdeDetectionService();
+      const detected = await detectionService.detectActiveIdes();
+      if (detected.length === 0) {
+        throw new ValidationError(
+          'No active IDEs detected. Run "jai1 rules apply" first or use "jai1 ide status" to check.'
+        );
+      }
+      console.log(`
+Detected ${detected.length} active IDE(s):
+`);
+      detected.forEach((d) => {
+        const confidence = d.confidence === "high" ? "\u{1F7E2}" : d.confidence === "medium" ? "\u{1F7E1}" : "\u{1F534}";
+        console.log(`  ${confidence} ${d.name} - ${d.ruleCount} rules`);
+      });
+      if (!options.yes) {
+        const proceed = await confirm8({
+          message: "\nSync these detected IDEs?",
+          default: true
+        });
+        if (!proceed) {
+          console.log("Cancelled.");
+          return;
+        }
+      }
+      idesToSync = detected.map((d) => d.id);
+    } else if (options.ides) {
+      const requested = options.ides.split(",").map((ide) => ide.trim());
+      const configured = projectConfig.ides || [];
+      idesToSync = requested;
+      const notConfigured = requested.filter((ide) => !configured.includes(ide));
+      if (notConfigured.length > 0) {
+        console.log(`
+\u26A0\uFE0F  IDEs not in config: ${notConfigured.join(", ")}`);
+        console.log("   They will still be synced, but may not be in jai1-rules.json");
+      }
+    } else {
+      idesToSync = projectConfig.ides || [];
+      if (idesToSync.length === 0) {
+        console.log("\n\u26A0\uFE0F  No IDEs configured in jai1-rules.json");
+        console.log("   Detecting from existing files...\n");
+        const detectionService = new IdeDetectionService();
+        idesToSync = await detectionService.detectExistingIdes();
+        if (idesToSync.length === 0) {
+          throw new ValidationError(
+            'No rule outputs found. Run "jai1 rules apply" first.'
+          );
+        }
+        console.log(`   Found: ${idesToSync.join(", ")}
+`);
+      }
+    }
+    console.log(`
+\u{1F4DD} Syncing ${idesToSync.length} IDE(s): ${idesToSync.join(", ")}
+`);
+    const configService = new ConfigService();
+    const config = await configService.load();
+    if (!config) {
+      throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+    }
+    const presetResponse = await fetch(`${config.apiUrl}/api/rules/presets/${projectConfig.preset}`, {
+      headers: {
+        "JAI1-Access-Key": config.accessKey
+      }
+    });
+    if (!presetResponse.ok) {
+      throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
+    }
+    const bundle = await presetResponse.json();
+    const sourceDir = join11(process.cwd(), ".cursor", "rules");
+    const sourceExists = await checkPathExists(sourceDir);
+    if (sourceExists) {
+      const files = await fs16.readdir(sourceDir);
+      for (const file of files) {
+        if (file.endsWith(".mdc")) {
+          const filePath = join11(sourceDir, file);
+          const content = await fs16.readFile(filePath, "utf-8");
+          bundle.files[file] = content;
+        }
+      }
+    }
+    const generatorService = new RulesGeneratorService();
+    for (const ideId of idesToSync) {
+      try {
+        const format = IDE_FORMATS[ideId];
+        if (!format) {
+          console.log(`\u26A0\uFE0F  Unknown IDE format: ${ideId}, skipping`);
+          continue;
+        }
+        const files = generatorService.generateForIde(bundle, ideId);
+        for (const file of files) {
+          const fullPath = join11(process.cwd(), file.path);
+          await fs16.mkdir(join11(fullPath, ".."), { recursive: true });
+          await fs16.writeFile(fullPath, file.content, "utf-8");
+        }
+        console.log(`\u2713 ${format.name} - ${files.length} files regenerated`);
+      } catch (error) {
+        console.error(`\u2717 Failed to sync ${ideId}:`, error);
+      }
+    }
+    if (JSON.stringify(projectConfig.ides) !== JSON.stringify(idesToSync)) {
+      projectConfig.ides = idesToSync;
+      await fs16.writeFile(
+        join11(process.cwd(), "jai1-rules.json"),
+        JSON.stringify(projectConfig, null, 2),
+        "utf-8"
+      );
+      console.log("\n\u2713 Updated jai1-rules.json with synced IDEs");
+    }
+    console.log("\n\u2705 Rules synced successfully!\n");
+    console.log("\u{1F4A1} Next steps:");
+    console.log("   \u2022 Your IDE may need to be restarted to pick up changes");
+    console.log('   \u2022 Use "jai1 ide status" to verify IDE configuration');
+    console.log("   \u2022 Edit source files in .cursor/rules/ and sync again\n");
+  });
+}
+async function checkPathExists(path8) {
+  try {
+    await fs16.access(join11(process.cwd(), path8));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/rules/info.ts
+import { Command as Command41 } from "commander";
+import { promises as fs17 } from "fs";
+import { join as join12 } from "path";
+function createRulesInfoCommand() {
+  return new Command41("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
+    const configPath = join12(process.cwd(), "jai1-rules.json");
+    let projectConfig;
+    try {
+      const configContent = await fs17.readFile(configPath, "utf-8");
+      projectConfig = JSON.parse(configContent);
+    } catch {
+      throw new ValidationError(
+        'No jai1-rules.json found. Run "jai1 rules init" first.'
+      );
+    }
+    if (options.json) {
+      console.log(JSON.stringify(projectConfig, null, 2));
+      return;
+    }
+    console.log("\u{1F4CB} Current Preset Information\n");
+    console.log(`Preset:       ${projectConfig.preset}`);
+    console.log(`Version:      ${projectConfig.version}`);
+    console.log(`Applied at:   ${new Date(projectConfig.appliedAt).toLocaleString()}`);
+    console.log(`Custom rules: ${projectConfig.customContext}`);
+    if (projectConfig.ides && projectConfig.ides.length > 0) {
+      console.log(`
+Configured IDEs (${projectConfig.ides.length}):`);
+      for (const ideId of projectConfig.ides) {
+        const format = IDE_FORMATS[ideId];
+        if (format) {
+          const exists = await checkIdeFilesExist(ideId, format);
+          const status = exists ? "\u2713" : "\u2717";
+          console.log(`  ${status} ${format.name} (${format.description})`);
+        }
+      }
+    }
+    if (projectConfig.backups && projectConfig.backups.length > 0) {
+      console.log(`
+Available Backups (${projectConfig.backups.length}):`);
+      for (const backup of projectConfig.backups.slice(0, 3)) {
+        const timestamp = new Date(backup.timestamp).toLocaleString();
+        console.log(`  \u2022 ${timestamp} - IDEs: ${backup.ides.join(", ")}`);
+      }
+      if (projectConfig.backups.length > 3) {
+        console.log(`  ... and ${projectConfig.backups.length - 3} more`);
+      }
+    }
+    console.log("\n\u2139\uFE0F  Commands:");
+    console.log('  \u2022 "jai1 rules sync" - Regenerate outputs after editing');
+    console.log('  \u2022 "jai1 rules restore" - Restore from backup');
+    console.log('  \u2022 "jai1 rules apply" - Apply a different preset');
+  });
+}
+async function checkPathExists2(path8) {
+  try {
+    await fs17.access(join12(process.cwd(), path8));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function checkIdeFilesExist(ideId, format) {
+  try {
+    if (ideId === "agentsmd") {
+      return await checkPathExists2("AGENTS.md");
+    } else if (ideId === "gemini") {
+      return await checkPathExists2("GEMINI.md");
+    } else {
+      return await checkPathExists2(format.rulesPath);
+    }
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/rules/index.ts
+function createRulesCommand() {
+  const rulesCommand = new Command42("rules").description("Manage rule presets for AI agents");
+  rulesCommand.addCommand(createRulesListCommand());
+  rulesCommand.addCommand(createRulesInitCommand());
+  rulesCommand.addCommand(createRulesApplyCommand());
+  rulesCommand.addCommand(createRulesRestoreCommand());
+  rulesCommand.addCommand(createRulesSyncCommand());
+  rulesCommand.addCommand(createRulesInfoCommand());
+  return rulesCommand;
+}
+
+// src/commands/upgrade.ts
+import { Command as Command43 } from "commander";
+import { confirm as confirm9 } from "@inquirer/prompts";
+import { execSync as execSync2 } from "child_process";
+var colors3 = {
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  cyan: "\x1B[36m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  bold: "\x1B[1m"
+};
+function createUpgradeCommand() {
+  return new Command43("upgrade").description("Upgrade jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force upgrade without confirmation").action(async (options) => {
+    await handleUpgrade(options);
+  });
+}
+async function handleUpgrade(options) {
+  const configService = new ConfigService();
   const config = await configService.load();
   if (!config) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
@@ -8083,7 +9852,7 @@ ${colors3.bold}Current version:${colors3.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm5({
+      const shouldUpdate = await confirm9({
         message: "Update to the latest version now?",
         default: true
       });
@@ -8187,11 +9956,11 @@ function getInstallCommand(packageManager2) {
 }
 
 // src/commands/clean.ts
-import { Command as Command36 } from "commander";
-import { confirm as confirm6, select as select3 } from "@inquirer/prompts";
-import { join as join6 } from "path";
+import { Command as Command44 } from "commander";
+import { confirm as confirm10, select as select6 } from "@inquirer/prompts";
+import { join as join13 } from "path";
 function createCleanCommand() {
-  return new Command36("clean").description("Clean up backups, cache, and temporary files").option("-y, --yes", "Skip confirmation").option("--backups", "Clean only backup files").option("--all", "Clean all (backups + cache)").action(async (options) => {
+  return new Command44("clean").description("Clean up backups, cache, and temporary files").option("-y, --yes", "Skip confirmation").option("--backups", "Clean only backup files").option("--all", "Clean all (backups + cache)").action(async (options) => {
     await handleClean(options);
   });
 }
@@ -8202,7 +9971,7 @@ async function handleClean(options) {
     {
       name: "Backups",
       description: "Component backup files (.jai1_backup/)",
-      path: join6(cwd, ".jai1_backup"),
+      path: join13(cwd, ".jai1_backup"),
       check: async () => {
         const backups = await service.listBackups(cwd);
         return { exists: backups.length > 0, count: backups.length };
@@ -8252,7 +10021,7 @@ async function handleClean(options) {
     console.log(`     Path: ${target.path}
 `);
   }
-  const action = await select3({
+  const action = await select6({
     message: "What do you want to clean?",
     choices: [
       ...availableTargets.map(({ target, info }) => ({
@@ -8286,7 +10055,7 @@ async function cleanTarget(target, skipConfirm) {
   }
   const countStr = info.count ? ` (${info.count} items)` : "";
   if (!skipConfirm) {
-    const confirmed = await confirm6({
+    const confirmed = await confirm10({
       message: `Delete ${target.name}${countStr}?`,
       default: false
     });
@@ -8304,7 +10073,7 @@ async function cleanTarget(target, skipConfirm) {
 }
 
 // src/commands/redmine/check.ts
-import { Command as Command37 } from "commander";
+import { Command as Command45 } from "commander";
 
 // src/services/redmine-config.service.ts
 import { readFile as readFile6 } from "fs/promises";
@@ -8611,7 +10380,7 @@ async function checkConnectivity(config) {
 
 // src/commands/redmine/check.ts
 function createRedmineCheckCommand() {
-  const cmd = new Command37("check").description("Check Redmine connectivity").option("-c, --config <path>", "Config file path", "redmine.config.yaml").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command45("check").description("Check Redmine connectivity").option("-c, --config <path>", "Config file path", "redmine.config.yaml").option("--json", "Output as JSON").action(async (options) => {
     await handleRedmineCheck(options);
   });
   return cmd;
@@ -8639,7 +10408,7 @@ async function handleRedmineCheck(options) {
 }
 
 // src/commands/redmine/sync-issue.ts
-import { Command as Command38 } from "commander";
+import { Command as Command46 } from "commander";
 
 // src/sync-issue.ts
 import { resolve as resolve3, relative } from "path";
@@ -8782,10 +10551,10 @@ function generateFilename(issueId, title, config, existingSlugs = /* @__PURE__ *
 
 // src/file.util.ts
 import { readFile as readFile7, writeFile as writeFile2, mkdir } from "fs/promises";
-import { dirname } from "path";
+import { dirname as dirname2 } from "path";
 import matter3 from "gray-matter";
 async function ensureDir(filePath) {
-  const dir = dirname(filePath);
+  const dir = dirname2(filePath);
   await mkdir(dir, { recursive: true });
 }
 async function readMarkdownFile(filePath) {
@@ -9015,7 +10784,7 @@ function extractIssueIdFromUrl(url) {
 
 // src/commands/redmine/sync-issue.ts
 function createSyncIssueCommand() {
-  const cmd = new Command38("issue").description("Sync a single issue").option("-i, --id <number>", "Issue ID").option("-u, --url <url>", "Issue URL").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command46("issue").description("Sync a single issue").option("-i, --id <number>", "Issue ID").option("-u, --url <url>", "Issue URL").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
     await handleSyncIssue(options);
   });
   return cmd;
@@ -9059,7 +10828,7 @@ async function handleSyncIssue(options) {
 }
 
 // src/commands/redmine/sync-project.ts
-import { Command as Command39 } from "commander";
+import { Command as Command47 } from "commander";
 
 // src/sync-project.ts
 async function syncProject(config, options = {}) {
@@ -9129,7 +10898,7 @@ async function syncProject(config, options = {}) {
 
 // src/commands/redmine/sync-project.ts
 function createSyncProjectCommand() {
-  const cmd = new Command39("project").description("Sync all issues in a project").option("-s, --status <status>", "Filter by status (default: *)", "*").option("--updated-since <date>", "Only sync issues updated since YYYY-MM-DD").option("--concurrency <number>", "Number of concurrent requests").option("--page-size <number>", "Page size for API requests").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
+  const cmd = new Command47("project").description("Sync all issues in a project").option("-s, --status <status>", "Filter by status (default: *)", "*").option("--updated-since <date>", "Only sync issues updated since YYYY-MM-DD").option("--concurrency <number>", "Number of concurrent requests").option("--page-size <number>", "Page size for API requests").option("--dry-run", "Preview without making changes").option("-c, --config <path>", "Config file path").option("-o, --output-dir <path>", "Output directory").option("--json", "Output as JSON").action(async (options) => {
     await handleSyncProject(options);
   });
   return cmd;
@@ -9184,12 +10953,12 @@ async function handleSyncProject(options) {
 }
 
 // src/commands/framework/info.ts
-import { Command as Command40 } from "commander";
-import { promises as fs12 } from "fs";
-import { join as join7 } from "path";
+import { Command as Command48 } from "commander";
+import { promises as fs18 } from "fs";
+import { join as join14 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
-  const cmd = new Command40("info").description("Show jai1-client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
+  const cmd = new Command48("info").description("Show jai1-client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
     await handleInfo(options);
   });
   return cmd;
@@ -9200,7 +10969,7 @@ async function handleInfo(options) {
   if (!config) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
   }
-  const frameworkPath = join7(homedir5(), ".jai1", "framework");
+  const frameworkPath = join14(homedir5(), ".jai1", "framework");
   const projectStatus = await getProjectStatus2();
   const info = {
     configPath: configService.getConfigPath(),
@@ -9235,9 +11004,9 @@ function maskKey3(key) {
   return "****" + key.slice(-4);
 }
 async function getProjectStatus2() {
-  const projectJai1 = join7(process.cwd(), ".jai1");
+  const projectJai1 = join14(process.cwd(), ".jai1");
   try {
-    await fs12.access(projectJai1);
+    await fs18.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -9245,8 +11014,8 @@ async function getProjectStatus2() {
 }
 
 // src/commands/self-update.ts
-import { Command as Command41 } from "commander";
-import { confirm as confirm7 } from "@inquirer/prompts";
+import { Command as Command49 } from "commander";
+import { confirm as confirm11 } from "@inquirer/prompts";
 import { execSync as execSync3 } from "child_process";
 var colors4 = {
   yellow: "\x1B[33m",
@@ -9257,7 +11026,7 @@ var colors4 = {
   bold: "\x1B[1m"
 };
 function createSelfUpdateCommand() {
-  return new Command41("self-update").description("Update jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force update without confirmation").action(async (options) => {
+  return new Command49("self-update").description("Update jai1-client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force update without confirmation").action(async (options) => {
     await handleSelfUpdate(options);
   });
 }
@@ -9301,7 +11070,7 @@ ${colors4.bold}Current version:${colors4.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm7({
+      const shouldUpdate = await confirm11({
         message: "Update to the latest version now?",
         default: true
       });
@@ -9397,10 +11166,10 @@ function getInstallCommand2(packageManager2) {
 }
 
 // src/commands/clear-backups.ts
-import { Command as Command42 } from "commander";
-import { confirm as confirm8 } from "@inquirer/prompts";
+import { Command as Command50 } from "commander";
+import { confirm as confirm12 } from "@inquirer/prompts";
 function createClearBackupsCommand() {
-  return new Command42("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command50("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
     const service = new ComponentsService();
     const backups = await service.listBackups(process.cwd());
     if (backups.length === 0) {
@@ -9416,7 +11185,7 @@ function createClearBackupsCommand() {
     }
     console.log();
     if (!options.yes) {
-      const ok = await confirm8({ message: "Delete all backups?", default: false });
+      const ok = await confirm12({ message: "Delete all backups?", default: false });
       if (!ok) return;
     }
     await service.clearBackups(process.cwd());
@@ -9425,9 +11194,9 @@ function createClearBackupsCommand() {
 }
 
 // src/commands/vscode/index.ts
-import { Command as Command43 } from "commander";
-import { checkbox as checkbox5, confirm as confirm9, select as select4 } from "@inquirer/prompts";
-import fs13 from "fs/promises";
+import { Command as Command51 } from "commander";
+import { checkbox as checkbox7, confirm as confirm13, select as select7 } from "@inquirer/prompts";
+import fs19 from "fs/promises";
 import path7 from "path";
 import { existsSync as existsSync3 } from "fs";
 var PERFORMANCE_GROUPS2 = {
@@ -9565,7 +11334,7 @@ var PERFORMANCE_GROUPS2 = {
   }
 };
 function createVSCodeCommand() {
-  const vscodeCommand = new Command43("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
+  const vscodeCommand = new Command51("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
   vscodeCommand.action(async () => {
     await interactiveMode2();
   });
@@ -9609,7 +11378,7 @@ async function interactiveMode2() {
   console.log("\u2502     \u2022 Nh\u1EA5n ENTER \u0111\u1EC3 x\xE1c nh\u1EADn v\xE0 \xE1p d\u1EE5ng             \u2502");
   console.log("\u2502     \u2022 Nh\u1EA5n Ctrl+C \u0111\u1EC3 h\u1EE7y                            \u2502");
   console.log("\u2570\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u256F\n");
-  const action = await select4({
+  const action = await select7({
     message: "B\u1EA1n mu\u1ED1n l\xE0m g\xEC?",
     choices: [
       { name: "\u2705 Enable c\xE1c nh\xF3m t\u1ED1i \u01B0u", value: "enable" },
@@ -9633,7 +11402,7 @@ async function selectGroupsToApply2(action) {
     value: key
   }));
   try {
-    const selectedGroups = await checkbox5({
+    const selectedGroups = await checkbox7({
       message: `Ch\u1ECDn c\xE1c nh\xF3m \u0111\u1EC3 ${action === "enable" ? "enable" : "disable"} (SPACE \u0111\u1EC3 ch\u1ECDn, ENTER \u0111\u1EC3 x\xE1c nh\u1EADn):`,
       choices
     });
@@ -9658,18 +11427,18 @@ async function applyGroups2(groupKeys, action) {
     return;
   }
   if (!existsSync3(vscodeDir)) {
-    await fs13.mkdir(vscodeDir, { recursive: true });
+    await fs19.mkdir(vscodeDir, { recursive: true });
     console.log("\u{1F4C1} \u0110\xE3 t\u1EA1o th\u01B0 m\u1EE5c .vscode/");
   }
   let currentSettings = {};
   if (existsSync3(settingsPath)) {
     try {
-      const content = await fs13.readFile(settingsPath, "utf-8");
+      const content = await fs19.readFile(settingsPath, "utf-8");
       currentSettings = JSON.parse(content);
       console.log("\u{1F4C4} \u0110\xE3 \u0111\u1ECDc c\xE0i \u0111\u1EB7t hi\u1EC7n t\u1EA1i t\u1EEB settings.json");
     } catch {
       console.warn("\u26A0\uFE0F  Kh\xF4ng th\u1EC3 \u0111\u1ECDc settings.json (c\xF3 th\u1EC3 ch\u1EE9a comments).");
-      const confirmOverwrite = await confirm9({
+      const confirmOverwrite = await confirm13({
         message: "Ghi \u0111\xE8 file settings.json hi\u1EC7n t\u1EA1i?",
         default: false
       });
@@ -9704,7 +11473,7 @@ async function applyGroups2(groupKeys, action) {
       }
     }
   }
-  await fs13.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+  await fs19.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
   console.log(`
 \u2705 \u0110\xE3 c\u1EADp nh\u1EADt c\xE0i \u0111\u1EB7t VSCode t\u1EA1i: ${settingsPath}`);
   console.log("\u{1F4A1} M\u1EB9o: Kh\u1EDFi \u0111\u1ED9ng l\u1EA1i VSCode \u0111\u1EC3 \xE1p d\u1EE5ng c\xE1c thay \u0111\u1ED5i.");
@@ -9716,7 +11485,7 @@ async function resetSettings2(groupKeys) {
     console.log("\n\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y file settings.json");
     return;
   }
-  const confirmReset = await confirm9({
+  const confirmReset = await confirm13({
     message: groupKeys.length === 0 ? "Reset T\u1EA4T C\u1EA2 settings v\u1EC1 m\u1EB7c \u0111\u1ECBnh (x\xF3a to\xE0n b\u1ED9 file)?" : `Reset c\xE1c nh\xF3m: ${groupKeys.join(", ")}?`,
     default: false
   });
@@ -9725,7 +11494,7 @@ async function resetSettings2(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs13.unlink(settingsPath);
+    await fs19.unlink(settingsPath);
     console.log("\n\u2705 \u0110\xE3 x\xF3a file settings.json");
   } else {
     await applyGroups2(groupKeys, "disable");
@@ -9736,9 +11505,9 @@ async function resetSettings2(groupKeys) {
 // src/commands/guide.ts
 import React40 from "react";
 import { render as render6 } from "ink";
-import { Command as Command44 } from "commander";
+import { Command as Command52 } from "commander";
 function createGuideCommand() {
-  const cmd = new Command44("guide").description("Interactive guide center for Agentic Coding").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
+  const cmd = new Command52("guide").description("Interactive guide center for Agentic Coding").option("--topic <topic>", "Open specific topic (intro, rules, workflows, prompts, skills)").action(async (options) => {
     const { waitUntilExit } = render6(
       React40.createElement(GuideApp, {
         initialTopic: options.topic,
@@ -9755,9 +11524,9 @@ function createGuideCommand() {
 // src/commands/context.ts
 import React41 from "react";
 import { render as render7 } from "ink";
-import { Command as Command45 } from "commander";
+import { Command as Command53 } from "commander";
 function createContextCommand() {
-  const cmd = new Command45("context").description("Kh\xE1m ph\xE1 v\xE0 qu\u1EA3n l\xFD context d\u1EF1 \xE1n cho c\xE1c IDE").option("--ide <ide>", "M\u1EDF tr\u1EF1c ti\u1EBFp IDE c\u1EE5 th\u1EC3 (cursor, windsurf, antigravity, jai1)").option("--type <type>", "Hi\u1EC3n th\u1ECB lo\u1EA1i context c\u1EE5 th\u1EC3 (rules, workflows, skills, agents, prompts)").option("--stats", "Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA context (non-interactive)").action(async (options) => {
+  const cmd = new Command53("context").description("Kh\xE1m ph\xE1 v\xE0 qu\u1EA3n l\xFD context d\u1EF1 \xE1n cho c\xE1c IDE").option("--ide <ide>", "M\u1EDF tr\u1EF1c ti\u1EBFp IDE c\u1EE5 th\u1EC3 (cursor, windsurf, antigravity, jai1)").option("--type <type>", "Hi\u1EC3n th\u1ECB lo\u1EA1i context c\u1EE5 th\u1EC3 (rules, workflows, skills, agents, prompts)").option("--stats", "Hi\u1EC3n th\u1ECB th\u1ED1ng k\xEA context (non-interactive)").action(async (options) => {
     let initialIDE;
     if (options.ide) {
       const validIDEs = ["cursor", "windsurf", "antigravity", "jai1"];
@@ -9834,10 +11603,10 @@ async function printStats2() {
 }
 
 // src/commands/migrate-ide.ts
-import { Command as Command46 } from "commander";
-import { checkbox as checkbox6, confirm as confirm10 } from "@inquirer/prompts";
+import { Command as Command54 } from "commander";
+import { checkbox as checkbox8, confirm as confirm14 } from "@inquirer/prompts";
 function createMigrateIdeCommand() {
-  const cmd = new Command46("migrate-ide").description("Migrate .jai1 rules v\xE0 workflows sang IDEs (Cursor, Windsurf, Claude Code, etc.)").option("--ide <ides...>", "Target IDEs (cursor, windsurf, antigravity, claudecode, opencode)").option("--type <types...>", "Content types (rules, workflows, commands)").option("--dry-run", "Preview changes without writing files").action(async (options) => {
+  const cmd = new Command54("migrate-ide").description("Migrate .jai1 rules v\xE0 workflows sang IDEs (Cursor, Windsurf, Claude Code, etc.)").option("--ide <ides...>", "Target IDEs (cursor, windsurf, antigravity, claudecode, opencode)").option("--type <types...>", "Content types (rules, workflows, commands)").option("--dry-run", "Preview changes without writing files").action(async (options) => {
     await runMigrateIde(options);
   });
   return cmd;
@@ -9865,7 +11634,7 @@ async function runMigrateIde(options) {
         value: ide
       };
     });
-    selectedIdes = await checkbox6({
+    selectedIdes = await checkbox8({
       message: "Ch\u1ECDn IDE(s) \u0111\u1EC3 migrate (SPACE \u0111\u1EC3 ch\u1ECDn, ENTER \u0111\u1EC3 x\xE1c nh\u1EADn):",
       choices: ideChoices
     });
@@ -9884,7 +11653,7 @@ async function runMigrateIde(options) {
       { name: `Workflows (${content.workflows.length} files)`, value: "workflows" },
       { name: `Commands (${content.commands.length} files)`, value: "commands" }
     ];
-    selectedTypes = await checkbox6({
+    selectedTypes = await checkbox8({
       message: "Ch\u1ECDn content types \u0111\u1EC3 migrate:",
       choices: typeChoices
     });
@@ -9906,7 +11675,7 @@ async function runMigrateIde(options) {
   if (options.dryRun) {
     console.log("\u{1F50D} DRY RUN - No files will be written\n");
   }
-  const confirmed = await confirm10({
+  const confirmed = await confirm14({
     message: "Proceed with migration?",
     default: true
   });
@@ -9943,7 +11712,7 @@ async function runMigrateIde(options) {
 }
 
 // src/cli.ts
-var program = new Command47();
+var program = new Command55();
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
   console.log(package_default.version);
   if (!process.argv.includes("--skip-update-check")) {
@@ -9967,11 +11736,12 @@ program.addCommand(createTranslateCommand());
 program.addCommand(createUtilsCommand());
 program.addCommand(createDepsCommand());
 program.addCommand(createKitCommand());
+program.addCommand(createRulesCommand());
 program.addCommand(createUpgradeCommand());
 program.addCommand(createCleanCommand());
-var redmineCommand = new Command47("redmine").description("Redmine context sync commands");
+var redmineCommand = new Command55("redmine").description("Redmine context sync commands");
 redmineCommand.addCommand(createRedmineCheckCommand());
-var syncCommand = new Command47("sync").description("Sync Redmine issues to markdown files");
+var syncCommand = new Command55("sync").description("Sync Redmine issues to markdown files");
 syncCommand.addCommand(createSyncIssueCommand());
 syncCommand.addCommand(createSyncProjectCommand());
 redmineCommand.addCommand(syncCommand);
@@ -10014,6 +11784,12 @@ program.on("command:*", (operands) => {
   console.error("     deps          Manage project dependencies");
   console.error("     utils         Developer tools (password, uuid, hash, jwt, etc.)");
   console.error("");
+  console.error("  \u{1F4CB} Rule Presets");
+  console.error("     rules list    List available rule presets");
+  console.error("     rules init    Apply preset to project");
+  console.error("     rules sync    Regenerate outputs after editing");
+  console.error("     rules info    Show current preset information");
+  console.error("");
   console.error("  \u{1F527} Maintenance");
   console.error("     upgrade       Upgrade jai1-client to latest version");
   console.error("     clean         Clean up backups and cache");