@jvittechs/jai1-cli 0.1.99 → 0.1.101

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli.ts
-import { Command as Command60 } from "commander";
+import { Command as Command61 } 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.99",
+  version: "0.1.101",
   description: "A unified CLI tool for JV-IT TECHS developers to manage Jai1 Framework. Please contact TeamAI for usage instructions.",
   type: "module",
   bin: {
@@ -88,6 +88,7 @@ var package_default = {
     cronstrue: "^2.50.0",
     execa: "^9.6.1",
     "gray-matter": "^4.0.3",
+    ignore: "^7.0.5",
     ink: "^5.0.1",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
@@ -1322,9 +1323,9 @@ var UnifiedApplyApp = ({
       (c) => c.filepath.toLowerCase().includes(query) || c.tags?.some((t) => t.toLowerCase().includes(query))
     );
   }, [components, searchQuery]);
-  useInput((input4, key) => {
+  useInput((input5, key) => {
     if (viewState === "done") {
-      if (key.return || input4 === "q" || key.escape) {
+      if (key.return || input5 === "q" || key.escape) {
         onExit();
       }
       return;
@@ -1332,7 +1333,7 @@ var UnifiedApplyApp = ({
     if (viewState === "summary") {
       if (key.return) {
         setViewState("ide-sync");
-      } else if (input4 === "s" || input4 === "q" || key.escape) {
+      } else if (input5 === "s" || input5 === "q" || key.escape) {
         onExit();
       }
       return;
@@ -1342,7 +1343,7 @@ var UnifiedApplyApp = ({
         setIdeCursorIndex((prev) => Math.max(0, prev - 1));
       } else if (key.downArrow) {
         setIdeCursorIndex((prev) => Math.min(availableIdes.length - 1, prev + 1));
-      } else if (input4 === " ") {
+      } else if (input5 === " ") {
         const ide = availableIdes[ideCursorIndex];
         if (ide) {
           setSelectedIdes((prev) => {
@@ -1355,15 +1356,15 @@ var UnifiedApplyApp = ({
             return next;
           });
         }
-      } else if (input4 === "a") {
+      } else if (input5 === "a") {
         setSelectedIdes(new Set(availableIdes));
-      } else if (input4 === "c") {
+      } else if (input5 === "c") {
         setSelectedIdes(/* @__PURE__ */ new Set());
       } else if (key.return) {
         if (selectedIdes.size > 0) {
           handleIdeSync();
         }
-      } else if (input4 === "s" || input4 === "q" || key.escape) {
+      } else if (input5 === "s" || input5 === "q" || key.escape) {
         onExit();
       }
       return;
@@ -1380,7 +1381,7 @@ var UnifiedApplyApp = ({
       else setFocusArea("packages");
       return;
     }
-    if (key.escape || input4 === "q") {
+    if (key.escape || input5 === "q") {
       onExit();
       return;
     }
@@ -1391,14 +1392,14 @@ var UnifiedApplyApp = ({
       return;
     }
     if (focusArea !== "search") {
-      if (input4 === "a") {
+      if (input5 === "a") {
         setSelectedPaths((prev) => {
           const next = new Set(prev);
           filteredComponents.forEach((c) => next.add(c.filepath));
           return next;
         });
         return;
-      } else if (input4 === "c") {
+      } else if (input5 === "c") {
         setSelectedPaths(/* @__PURE__ */ new Set());
         return;
       }
@@ -1408,7 +1409,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 (input4 === " ") {
+      } else if (input5 === " ") {
         const current = filteredComponents[cursorIndex];
         if (current) {
           setSelectedPaths((prev) => {
@@ -1428,7 +1429,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 (input4 === " " || key.return) {
+      } else if (input5 === " " || key.return) {
         const tag = tags[selectedPackageIndex];
         if (tag) {
           const packageComponents = components.filter((c) => c.tags?.includes(tag.tag));
@@ -1860,7 +1861,7 @@ var MainMenuView = ({ ideContexts, onSelect }) => {
       available: ideContexts.some((ctx) => ctx.ide === "jai1")
     }
   ];
-  useInput2((input4, key) => {
+  useInput2((input5, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -1962,13 +1963,13 @@ var IDEOverviewView = ({
       count: ideContext.stats.byType.context
     });
   }
-  useInput3((input4, key) => {
+  useInput3((input5, 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(input4, 10);
+    const num = parseInt(input5, 10);
     if (!isNaN(num) && num >= 1 && num <= tabs.length) {
       setSelectedTabIndex(num - 1);
     }
@@ -2030,7 +2031,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((input4, key) => {
+  useInput4((input5, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -2081,18 +2082,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((input4, key) => {
-    if (key.upArrow || input4 === "k") {
+  useInput5((input5, key) => {
+    if (key.upArrow || input5 === "k") {
       setScrollPosition((prev) => Math.max(0, prev - 1));
-    } else if (key.downArrow || input4 === "j") {
+    } else if (key.downArrow || input5 === "j") {
       setScrollPosition((prev) => Math.min(maxScroll, prev + 1));
-    } else if (key.pageDown || input4 === "d") {
+    } else if (key.pageDown || input5 === "d") {
       setScrollPosition((prev) => Math.min(maxScroll, prev + 5));
-    } else if (key.pageUp || input4 === "u") {
+    } else if (key.pageUp || input5 === "u") {
       setScrollPosition((prev) => Math.max(0, prev - 5));
-    } else if (input4 === "g") {
+    } else if (input5 === "g") {
       setScrollPosition(0);
-    } else if (input4 === "G") {
+    } else if (input5 === "G") {
       setScrollPosition(maxScroll);
     } else if (key.escape || key.backspace) {
       onBack();
@@ -2496,8 +2497,8 @@ var ContextApp = ({ initialIDE, initialType, onExit }) => {
       setLoading(false);
     });
   }, [initialIDE]);
-  useInput6((input4, key) => {
-    if (input4 === "q") {
+  useInput6((input5, key) => {
+    if (input5 === "q") {
       onExit();
       return;
     }
@@ -3389,9 +3390,9 @@ var IdeDetectionService = class {
   /**
    * Check if a path exists
    */
-  async pathExists(path9) {
+  async pathExists(path10) {
     try {
-      await fs7.access(path9);
+      await fs7.access(path10);
       return true;
     } catch {
       return false;
@@ -3616,7 +3617,7 @@ var MENU_ITEMS = [
 ];
 var MenuView = ({ onSelect }) => {
   const [selectedIndex, setSelectedIndex] = useState7(0);
-  useInput7((input4, key) => {
+  useInput7((input5, key) => {
     if (key.upArrow) {
       setSelectedIndex((prev) => Math.max(0, prev - 1));
     } else if (key.downArrow) {
@@ -4229,7 +4230,7 @@ var AgenticGuideView = ({ onBack }) => {
   const [isTyping, setIsTyping] = useState8(false);
   const [selectedSuggestion, setSelectedSuggestion] = useState8(0);
   const [focusArea, setFocusArea] = useState8("input");
-  useInput8((input4, key) => {
+  useInput8((input5, key) => {
     if (key.escape) {
       onBack();
       return;
@@ -4361,7 +4362,7 @@ var GuideApp = ({ initialTopic, onExit }) => {
       setCurrentTopic(TOPIC_MAP[initialTopic]);
     }
   }, [initialTopic]);
-  useInput9((input4, key) => {
+  useInput9((input5, key) => {
     if (key.escape || currentTopic !== "menu" && key.backspace) {
       if (currentTopic === "menu") {
         onExit();
@@ -4371,7 +4372,7 @@ var GuideApp = ({ initialTopic, onExit }) => {
       }
       return;
     }
-    if (input4 === "q") {
+    if (input5 === "q") {
       onExit();
       return;
     }
@@ -4890,7 +4891,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((input4, key) => {
+  useInput10((input5, key) => {
     if (key.escape) {
       onCancel();
       return;
@@ -5016,7 +5017,7 @@ var ChatApp = ({ service, initialModel }) => {
     }
     return false;
   }, [refetch, exit]);
-  useInput11((input4, key) => {
+  useInput11((input5, key) => {
     if (showSlashMenu) {
       if (key.upArrow) {
         setSlashMenuIndex((i) => Math.max(0, i - 1));
@@ -5044,7 +5045,7 @@ var ChatApp = ({ service, initialModel }) => {
       }
       return;
     }
-    if (currentView === "error" && (key.return || input4 === "r")) {
+    if (currentView === "error" && (key.return || input5 === "r")) {
       setCurrentView("loading");
       refetch();
       return;
@@ -5113,8 +5114,8 @@ var ChatApp = ({ service, initialModel }) => {
 
 // src/server/web-chat-server.ts
 import http from "http";
-import fs8 from "fs";
-import path4 from "path";
+import fs9 from "fs";
+import path5 from "path";
 import { fileURLToPath } from "url";
 
 // src/server/session.ts
@@ -5246,9 +5247,363 @@ var SessionManager = class {
   }
 };
 
+// src/server/file-service.ts
+import fs8 from "fs";
+import path4 from "path";
+import ignore from "ignore";
+var ALWAYS_EXCLUDED = [
+  "node_modules",
+  "vendor",
+  ".git",
+  ".env",
+  ".env.*",
+  ".env.local",
+  ".env.*.local",
+  "dist",
+  "build",
+  ".next",
+  ".nuxt",
+  ".output",
+  ".cache",
+  "*.lock",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "composer.lock",
+  ".DS_Store",
+  "Thumbs.db",
+  "*.log",
+  "*.tmp",
+  "*.temp",
+  ".idea",
+  ".vscode",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  "*.pyc",
+  ".pytest_cache",
+  ".mypy_cache"
+];
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  // Web
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".astro",
+  // Data
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".xml",
+  ".csv",
+  // Docs
+  ".md",
+  ".mdx",
+  ".txt",
+  ".rst",
+  ".adoc",
+  // Config
+  ".env.example",
+  ".gitignore",
+  ".dockerignore",
+  ".npmrc",
+  ".nvmrc",
+  ".editorconfig",
+  ".prettierrc",
+  ".eslintrc",
+  ".babelrc",
+  // Server
+  ".php",
+  ".py",
+  ".rb",
+  ".go",
+  ".java",
+  ".kt",
+  ".scala",
+  ".rs",
+  ".swift",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  // Shell
+  ".sh",
+  ".bash",
+  ".zsh",
+  ".fish",
+  ".ps1",
+  ".bat",
+  ".cmd",
+  // Database
+  ".sql",
+  ".prisma",
+  ".graphql",
+  ".gql",
+  // Other
+  ".dockerfile",
+  ".makefile",
+  ".rake",
+  ".gradle"
+]);
+var TEXT_FILES = /* @__PURE__ */ new Set([
+  "Makefile",
+  "Dockerfile",
+  "Vagrantfile",
+  "Gemfile",
+  "Rakefile",
+  "Procfile",
+  "Brewfile",
+  ".gitignore",
+  ".dockerignore",
+  ".npmrc",
+  ".nvmrc",
+  ".env.example",
+  "LICENSE",
+  "README",
+  "CHANGELOG",
+  "CONTRIBUTING",
+  "AUTHORS",
+  "CODEOWNERS"
+]);
+function getLanguage(filePath) {
+  const ext = path4.extname(filePath).toLowerCase();
+  const langMap = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".py": "python",
+    ".rb": "ruby",
+    ".php": "php",
+    ".java": "java",
+    ".kt": "kotlin",
+    ".go": "go",
+    ".rs": "rust",
+    ".swift": "swift",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".css": "css",
+    ".scss": "scss",
+    ".sass": "sass",
+    ".less": "less",
+    ".html": "html",
+    ".htm": "html",
+    ".vue": "vue",
+    ".svelte": "svelte",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".xml": "xml",
+    ".md": "markdown",
+    ".mdx": "markdown",
+    ".sql": "sql",
+    ".graphql": "graphql",
+    ".gql": "graphql",
+    ".sh": "bash",
+    ".bash": "bash",
+    ".zsh": "bash",
+    ".dockerfile": "dockerfile",
+    ".prisma": "prisma"
+  };
+  return langMap[ext] || "text";
+}
+function isTextFile(filePath) {
+  const ext = path4.extname(filePath).toLowerCase();
+  const name = path4.basename(filePath);
+  if (TEXT_FILES.has(name)) return true;
+  if (ext && TEXT_EXTENSIONS.has(ext)) return true;
+  if (name.endsWith("rc") || name.endsWith("config")) return true;
+  return false;
+}
+var FileService = class {
+  workingDir;
+  maxFileSize;
+  maxFilesPerRequest;
+  maxSearchResults;
+  ignoreFilter;
+  constructor(options) {
+    this.workingDir = path4.resolve(options.workingDir);
+    this.maxFileSize = options.maxFileSize ?? 1024 * 1024;
+    this.maxFilesPerRequest = options.maxFilesPerRequest ?? 5;
+    this.maxSearchResults = options.maxSearchResults ?? 20;
+    this.ignoreFilter = ignore();
+    this.loadIgnorePatterns();
+  }
+  /**
+   * Load ignore patterns from .gitignore and add always-excluded patterns
+   */
+  loadIgnorePatterns() {
+    this.ignoreFilter.add(ALWAYS_EXCLUDED);
+    const gitignorePath = path4.join(this.workingDir, ".gitignore");
+    try {
+      if (fs8.existsSync(gitignorePath)) {
+        const content = fs8.readFileSync(gitignorePath, "utf-8");
+        this.ignoreFilter.add(content);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Check if a path should be ignored
+   */
+  isIgnored(relativePath) {
+    const normalizedPath = relativePath.replace(/\\/g, "/");
+    return this.ignoreFilter.ignores(normalizedPath);
+  }
+  /**
+   * Validate path is within working directory (prevent path traversal)
+   */
+  validatePath(relativePath) {
+    const cleanPath = relativePath.replace(/^\/+/, "");
+    const absolutePath = path4.resolve(this.workingDir, cleanPath);
+    if (!absolutePath.startsWith(this.workingDir + path4.sep) && absolutePath !== this.workingDir) {
+      throw new Error("Path traversal detected");
+    }
+    return absolutePath;
+  }
+  /**
+   * Get relative path from working directory
+   */
+  getRelativePath(absolutePath) {
+    return path4.relative(this.workingDir, absolutePath);
+  }
+  /**
+   * Search files matching a query (for autocomplete)
+   * Returns files where path contains the query string
+   */
+  async searchFiles(query, limit) {
+    const maxResults = Math.min(limit ?? this.maxSearchResults, 50);
+    const results = [];
+    const normalizedQuery = query.toLowerCase().replace(/\\/g, "/");
+    const searchDir = async (dirPath, depth = 0) => {
+      if (depth > 10 || results.length >= maxResults) return;
+      try {
+        const entries = await fs8.promises.readdir(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+          if (results.length >= maxResults) break;
+          const entryPath = path4.join(dirPath, entry.name);
+          const relativePath = this.getRelativePath(entryPath);
+          if (this.isIgnored(relativePath)) continue;
+          const normalizedRelPath = relativePath.toLowerCase().replace(/\\/g, "/");
+          if (normalizedRelPath.includes(normalizedQuery)) {
+            if (entry.isFile() && isTextFile(entry.name)) {
+              try {
+                const stat = await fs8.promises.stat(entryPath);
+                results.push({
+                  path: relativePath,
+                  name: entry.name,
+                  size: stat.size,
+                  type: "file",
+                  extension: path4.extname(entry.name).slice(1) || void 0
+                });
+              } catch {
+              }
+            }
+          }
+          if (entry.isDirectory()) {
+            await searchDir(entryPath, depth + 1);
+          }
+        }
+      } catch {
+      }
+    };
+    await searchDir(this.workingDir);
+    results.sort((a, b) => {
+      if (a.path.length !== b.path.length) {
+        return a.path.length - b.path.length;
+      }
+      return a.path.localeCompare(b.path);
+    });
+    return results;
+  }
+  /**
+   * Read a single file
+   */
+  async readFile(relativePath) {
+    const absolutePath = this.validatePath(relativePath);
+    const normalizedRelPath = this.getRelativePath(absolutePath);
+    if (this.isIgnored(normalizedRelPath)) {
+      throw new Error("File is excluded by ignore rules");
+    }
+    if (!isTextFile(absolutePath)) {
+      throw new Error("Only text files can be read");
+    }
+    const stat = await fs8.promises.stat(absolutePath);
+    if (!stat.isFile()) {
+      throw new Error("Path is not a file");
+    }
+    if (stat.size > this.maxFileSize) {
+      throw new Error(`File exceeds maximum size of ${Math.round(this.maxFileSize / 1024)}KB`);
+    }
+    const content = await fs8.promises.readFile(absolutePath, "utf-8");
+    return {
+      path: normalizedRelPath,
+      content,
+      size: stat.size,
+      language: getLanguage(absolutePath)
+    };
+  }
+  /**
+   * Read multiple files (batch)
+   */
+  async readFiles(relativePaths) {
+    const paths = relativePaths.slice(0, this.maxFilesPerRequest);
+    const results = await Promise.all(
+      paths.map(async (filePath) => {
+        try {
+          const content = await this.readFile(filePath);
+          return content;
+        } catch (error) {
+          return {
+            path: filePath,
+            content: "",
+            size: 0,
+            language: "text",
+            error: error instanceof Error ? error.message : "Unknown error"
+          };
+        }
+      })
+    );
+    return results;
+  }
+  /**
+   * Get working directory info
+   */
+  getWorkingDir() {
+    return this.workingDir;
+  }
+  /**
+   * Get max files per request limit
+   */
+  getMaxFilesLimit() {
+    return this.maxFilesPerRequest;
+  }
+};
+
 // src/server/web-chat-server.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path4.dirname(__filename);
+var __dirname = path5.dirname(__filename);
 var MIME_TYPES = {
   ".html": "text/html",
   ".css": "text/css",
@@ -5322,22 +5677,23 @@ function createWebChatServer(options) {
   const sessionManager = new SessionManager();
   let server = null;
   let session = null;
-  const staticDir = path4.join(__dirname, "web-chat");
+  const fileService = new FileService({ workingDir: process.cwd() });
+  const staticDir = path5.join(__dirname, "web-chat");
   async function serveStaticFile(res, filePath) {
-    const fullPath = path4.join(staticDir, filePath);
+    const fullPath = path5.join(staticDir, filePath);
     if (!fullPath.startsWith(staticDir)) {
       sendError(res, 403, "ERR-WC-006", "Forbidden");
       return;
     }
     try {
-      const stat = await fs8.promises.stat(fullPath);
+      const stat = await fs9.promises.stat(fullPath);
       if (!stat.isFile()) {
         sendError(res, 404, "ERR-WC-007", "Not found");
         return;
       }
-      const ext = path4.extname(fullPath);
+      const ext = path5.extname(fullPath);
       const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      const content = await fs8.promises.readFile(fullPath);
+      const content = await fs9.promises.readFile(fullPath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch (error) {
@@ -5440,6 +5796,83 @@ function createWebChatServer(options) {
       }
       return;
     }
+    if (pathname === "/api/files/search" && req.method === "GET") {
+      try {
+        const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        const query = url.searchParams.get("q") || "";
+        const limit = parseInt(url.searchParams.get("limit") || "10", 10);
+        if (!query || query.length < 1) {
+          sendJson(res, 200, { success: true, data: { files: [] } });
+          return;
+        }
+        const files = await fileService.searchFiles(query, Math.min(limit, 20));
+        sendJson(res, 200, {
+          success: true,
+          data: { files }
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        sendError(res, 500, "ERR-WC-011", `File search failed: ${errorMessage}`);
+      }
+      return;
+    }
+    if (pathname === "/api/files/read" && req.method === "GET") {
+      try {
+        const url = new URL(req.url || "/", `http://${req.headers.host}`);
+        const filePath = url.searchParams.get("path");
+        if (!filePath) {
+          sendError(res, 400, "ERR-WC-012", "Missing file path");
+          return;
+        }
+        const fileContent = await fileService.readFile(filePath);
+        sendJson(res, 200, {
+          success: true,
+          data: fileContent
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        if (errorMessage.includes("Path traversal")) {
+          sendError(res, 403, "ERR-WC-013", "Access denied");
+        } else if (errorMessage.includes("ENOENT")) {
+          sendError(res, 404, "ERR-WC-014", "File not found");
+        } else {
+          sendError(res, 400, "ERR-WC-015", errorMessage);
+        }
+      }
+      return;
+    }
+    if (pathname === "/api/files/batch" && req.method === "POST") {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.paths || !Array.isArray(body.paths) || body.paths.length === 0) {
+          sendError(res, 400, "ERR-WC-016", "Missing or invalid paths array");
+          return;
+        }
+        if (body.paths.length > fileService.getMaxFilesLimit()) {
+          sendError(res, 400, "ERR-WC-017", `Maximum ${fileService.getMaxFilesLimit()} files allowed per request`);
+          return;
+        }
+        const files = await fileService.readFiles(body.paths);
+        sendJson(res, 200, {
+          success: true,
+          data: { files }
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Unknown error";
+        sendError(res, 500, "ERR-WC-018", `Batch read failed: ${errorMessage}`);
+      }
+      return;
+    }
+    if (pathname === "/api/files/info" && req.method === "GET") {
+      sendJson(res, 200, {
+        success: true,
+        data: {
+          workingDir: fileService.getWorkingDir(),
+          maxFiles: fileService.getMaxFilesLimit()
+        }
+      });
+      return;
+    }
     if (pathname === "/api/chat" && req.method === "POST") {
       try {
         const body = await parseJsonBody(req);
@@ -5793,8 +6226,8 @@ function createStatsCommand() {
 import { Command as Command15 } from "commander";
 
 // src/services/translation.service.ts
-import { promises as fs9 } from "fs";
-import path5 from "path";
+import { promises as fs10 } from "fs";
+import path6 from "path";
 import pLimit from "p-limit";
 import pRetry from "p-retry";
 var TRANSLATABLE_EXTS = [".md", ".txt", ".json", ".yaml", ".yml"];
@@ -5810,9 +6243,9 @@ var TranslationService = class {
   /**
    * Detect input type
    */
-  async detectInputType(input4) {
+  async detectInputType(input5) {
     try {
-      const stat = await fs9.stat(input4);
+      const stat = await fs10.stat(input5);
       if (stat.isDirectory()) return "folder";
       if (stat.isFile()) return "file";
     } catch {
@@ -5849,13 +6282,13 @@ var TranslationService = class {
    */
   async translateFile(filePath) {
     try {
-      const content = await fs9.readFile(filePath, "utf-8");
-      const ext = path5.extname(filePath).toLowerCase();
+      const content = await fs10.readFile(filePath, "utf-8");
+      const ext = path6.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 fs9.writeFile(outputPath, translatedContent, "utf-8");
+        await fs10.writeFile(outputPath, translatedContent, "utf-8");
       }
       return {
         inputPath: filePath,
@@ -5910,27 +6343,27 @@ var TranslationService = class {
     if (this.options.output) {
       return this.options.output;
     }
-    const ext = path5.extname(inputPath);
-    const base = path5.basename(inputPath, ext);
-    const dir = path5.dirname(inputPath);
+    const ext = path6.extname(inputPath);
+    const base = path6.basename(inputPath, ext);
+    const dir = path6.dirname(inputPath);
     const lang = this.options.to;
-    return path5.join(dir, `${base}.${lang}${ext}`);
+    return path6.join(dir, `${base}.${lang}${ext}`);
   }
   /**
    * Discover translatable files in folder recursively
    */
   async discoverFiles(folderPath) {
-    const entries = await fs9.readdir(folderPath, { withFileTypes: true });
+    const entries = await fs10.readdir(folderPath, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-      const fullPath = path5.join(folderPath, entry.name);
+      const fullPath = path6.join(folderPath, entry.name);
       if (entry.isDirectory()) {
         if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
           const subFiles = await this.discoverFiles(fullPath);
           files.push(...subFiles);
         }
       } else if (entry.isFile()) {
-        const ext = path5.extname(entry.name).toLowerCase();
+        const ext = path6.extname(entry.name).toLowerCase();
         if (TRANSLATABLE_EXTS.includes(ext)) {
           if (!this.isTranslatedFile(entry.name)) {
             files.push(fullPath);
@@ -6044,7 +6477,7 @@ Return ONLY the translated content, no explanations.`;
 };
 
 // src/commands/translate.ts
-async function handleTranslate(input4, options) {
+async function handleTranslate(input5, options) {
   const configService = new ConfigService();
   const config = await configService.load();
   if (!config) {
@@ -6052,16 +6485,16 @@ async function handleTranslate(input4, options) {
   }
   const llmService = new LlmProxyService(config);
   const translationService = new TranslationService(llmService, options, options.model);
-  const inputType = await translationService.detectInputType(input4);
+  const inputType = await translationService.detectInputType(input5);
   switch (inputType) {
     case "text":
-      await handleTextTranslation(translationService, input4, options);
+      await handleTextTranslation(translationService, input5, options);
       break;
     case "file":
-      await handleFileTranslation(translationService, input4, options);
+      await handleFileTranslation(translationService, input5, options);
       break;
     case "folder":
-      await handleFolderTranslation(translationService, input4, options);
+      await handleFolderTranslation(translationService, input5, options);
       break;
   }
 }
@@ -6138,8 +6571,8 @@ async function handleFolderTranslation(service, folderPath, options) {
   }
 }
 function createTranslateCommand() {
-  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);
+  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 (input5, options) => {
+    await handleTranslate(input5, options);
   });
   return cmd;
 }
@@ -6428,11 +6861,226 @@ function createImageCommand() {
   return cmd;
 }
 
+// src/commands/feedback.ts
+import { Command as Command21 } from "commander";
+import { select as select2, input, confirm as confirm5 } from "@inquirer/prompts";
+import os from "os";
+import { promises as fs11 } from "fs";
+import { join as join5 } from "path";
+async function collectContext() {
+  const context = {
+    os: `${os.platform()} ${os.release()}`
+  };
+  try {
+    const packageJsonPath = new URL("../../package.json", import.meta.url);
+    const packageJson = JSON.parse(await fs11.readFile(packageJsonPath, "utf-8"));
+    context.cli_version = packageJson.version;
+  } catch {
+  }
+  try {
+    const projectPackageJson = await fs11.readFile(join5(process.cwd(), "package.json"), "utf-8");
+    const projectData = JSON.parse(projectPackageJson);
+    context.project_name = projectData.name;
+  } catch {
+  }
+  return context;
+}
+async function submitFeedback(apiUrl, accessKey, data) {
+  const response = await fetch(`${apiUrl}/api/feedback`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "JAI1-Access-Key": accessKey
+    },
+    body: JSON.stringify({
+      type: data.type,
+      title: data.title,
+      message: data.message,
+      context: data.context,
+      source: "cli"
+    })
+  });
+  const result = await response.json();
+  if (!response.ok) {
+    return { success: false, error: result.error || "Failed to submit feedback" };
+  }
+  return { success: true, feedback_id: result.data.feedback_id };
+}
+async function handleInteractiveFeedback(config) {
+  console.log("\u{1F4DD} Submit Feedback to Jai1\n");
+  const type = await select2({
+    message: "What type of feedback?",
+    choices: [
+      {
+        name: "\u{1F41B} Bug Report - Report an error or issue",
+        value: "bug"
+      },
+      {
+        name: "\u{1F4A1} Feature Request - Suggest a new feature",
+        value: "feature"
+      },
+      {
+        name: "\u{1F4DD} Suggestion - Share ideas or improvements",
+        value: "suggestion"
+      }
+    ]
+  });
+  const title = await input({
+    message: "Title (max 200 characters):",
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Title is required";
+      }
+      if (value.length > 200) {
+        return "Title must be 200 characters or less";
+      }
+      return true;
+    }
+  });
+  const message = await input({
+    message: "Description (max 4000 characters):",
+    validate: (value) => {
+      if (!value || value.trim().length === 0) {
+        return "Description is required";
+      }
+      if (value.length > 4e3) {
+        return "Description must be 4000 characters or less";
+      }
+      return true;
+    }
+  });
+  const context = await collectContext();
+  console.log("\n\u{1F4CB} Summary:\n");
+  console.log(`Type:        ${type}`);
+  console.log(`Title:       ${title}`);
+  console.log(`Description: ${message.substring(0, 100)}${message.length > 100 ? "..." : ""}`);
+  if (context) {
+    console.log(`Context:     OS: ${context.os}, CLI: ${context.cli_version || "unknown"}`);
+  }
+  const confirmed = await confirm5({
+    message: "\nSubmit feedback?",
+    default: true
+  });
+  if (!confirmed) {
+    console.log("\n\u274C Cancelled.");
+    return;
+  }
+  console.log("\n\u23F3 Submitting feedback...");
+  try {
+    const result = await submitFeedback(config.apiUrl, config.accessKey, {
+      type,
+      title: title.trim(),
+      message: message.trim(),
+      context
+    });
+    if (result.success) {
+      console.log(`
+\u2705 Feedback submitted successfully!`);
+      console.log(`   Feedback ID: ${result.feedback_id}
+`);
+      console.log("   Thank you for your feedback! We will review it soon.");
+    } else {
+      console.error(`
+\u274C Failed to submit feedback: ${result.error}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("\n\u274C Network error:", error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function handleNonInteractiveFeedback(config, options) {
+  if (!options.type || !options.title || !options.message) {
+    throw new ValidationError("Missing required fields: --type, --title, --message");
+  }
+  const validTypes = ["bug", "feature", "suggestion"];
+  if (!validTypes.includes(options.type)) {
+    throw new ValidationError(`Invalid type. Must be one of: ${validTypes.join(", ")}`);
+  }
+  if (options.title.length > 200) {
+    throw new ValidationError("Title must be 200 characters or less");
+  }
+  if (options.message.length > 4e3) {
+    throw new ValidationError("Message must be 4000 characters or less");
+  }
+  let context;
+  if (!options.noContext) {
+    context = await collectContext();
+    if (options.context) {
+      try {
+        const customContext = JSON.parse(options.context);
+        context = { ...context, ...customContext };
+      } catch {
+        throw new ValidationError("Invalid JSON in --context");
+      }
+    }
+  }
+  try {
+    const result = await submitFeedback(config.apiUrl, config.accessKey, {
+      type: options.type,
+      title: options.title.trim(),
+      message: options.message.trim(),
+      context
+    });
+    if (result.success) {
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, feedback_id: result.feedback_id }));
+      } else {
+        console.log(`\u2705 Feedback submitted: ${result.feedback_id}`);
+      }
+    } else {
+      if (options.json) {
+        console.log(JSON.stringify({ success: false, error: result.error }));
+      } else {
+        console.error(`\u274C Error: ${result.error}`);
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: error instanceof Error ? error.message : "Unknown error" }));
+    } else {
+      console.error("\u274C Error:", error instanceof Error ? error.message : String(error));
+    }
+    process.exit(1);
+  }
+}
+async function handleFeedbackCommand(options) {
+  const configService = new ConfigService();
+  const config = await configService.load();
+  if (!config) {
+    throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+  }
+  let stdinMessage = "";
+  if (!process.stdin.isTTY && !options.message) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    stdinMessage = Buffer.concat(chunks).toString("utf-8").trim();
+  }
+  if (stdinMessage) {
+    options.message = stdinMessage;
+  }
+  const isInteractive = !options.type && !options.title && !options.message;
+  if (isInteractive) {
+    await handleInteractiveFeedback(config);
+  } else {
+    await handleNonInteractiveFeedback(config, options);
+  }
+}
+function createFeedbackCommand() {
+  const cmd = new Command21("feedback").alias("report").description("Submit bug reports, feature requests, or suggestions").option("--type <type>", "Feedback type: bug, feature, suggestion").option("--title <title>", "Feedback title (max 200 chars)").option("--message <message>", "Feedback message (max 4000 chars)").option("--context <json>", "Additional context as JSON").option("--no-context", "Do not include automatic context").option("--json", "Output JSON format").action(async (options) => {
+    await handleFeedbackCommand(options);
+  });
+  return cmd;
+}
+
 // src/commands/utils/index.ts
-import { Command as Command34 } from "commander";
+import { Command as Command35 } from "commander";
 
 // src/commands/utils/password.ts
-import { Command as Command21 } from "commander";
+import { Command as Command22 } from "commander";
 
 // src/services/utils.service.ts
 import crypto2 from "crypto";
@@ -6483,12 +7131,12 @@ var UtilsService = class {
   /**
    * Hash text or file using specified algorithm
    */
-  async hash(input4, algorithm) {
+  async hash(input5, algorithm) {
     if (algorithm === "bcrypt") {
       throw new Error("Use hashBcrypt for bcrypt algorithm");
     }
     const hash = crypto2.createHash(algorithm);
-    hash.update(input4);
+    hash.update(input5);
     return hash.digest("hex");
   }
   /**
@@ -6501,14 +7149,14 @@ var UtilsService = class {
   /**
    * Hash using bcrypt
    */
-  async hashBcrypt(input4, rounds = 10) {
-    return bcrypt.hash(input4, rounds);
+  async hashBcrypt(input5, rounds = 10) {
+    return bcrypt.hash(input5, rounds);
   }
   /**
    * Base64 encode
    */
-  base64Encode(input4, urlSafe = false) {
-    const buffer = typeof input4 === "string" ? Buffer.from(input4, "utf-8") : input4;
+  base64Encode(input5, urlSafe = false) {
+    const buffer = typeof input5 === "string" ? Buffer.from(input5, "utf-8") : input5;
     let encoded = buffer.toString("base64");
     if (urlSafe) {
       encoded = encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
@@ -6518,8 +7166,8 @@ var UtilsService = class {
   /**
    * Base64 decode
    */
-  base64Decode(input4) {
-    let normalized = input4.replace(/-/g, "+").replace(/_/g, "/");
+  base64Decode(input5) {
+    let normalized = input5.replace(/-/g, "+").replace(/_/g, "/");
     while (normalized.length % 4) {
       normalized += "=";
     }
@@ -6648,14 +7296,14 @@ var UtilsService = class {
   /**
    * URL encode
    */
-  urlEncode(input4, full = false) {
-    return full ? encodeURI(input4) : encodeURIComponent(input4);
+  urlEncode(input5, full = false) {
+    return full ? encodeURI(input5) : encodeURIComponent(input5);
   }
   /**
    * URL decode
    */
-  urlDecode(input4, full = false) {
-    return full ? decodeURI(input4) : decodeURIComponent(input4);
+  urlDecode(input5, full = false) {
+    return full ? decodeURI(input5) : decodeURIComponent(input5);
   }
   /**
    * Format bytes to human-readable size
@@ -6701,7 +7349,7 @@ async function handlePasswordGeneration(options) {
   }
 }
 function createPasswordCommand() {
-  const cmd = new Command21("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 Command22("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
@@ -6719,7 +7367,7 @@ Examples:
 }
 
 // src/commands/utils/uuid.ts
-import { Command as Command22 } from "commander";
+import { Command as Command23 } from "commander";
 async function handleUuidGeneration(options) {
   const service = new UtilsService();
   try {
@@ -6747,7 +7395,7 @@ async function handleUuidGeneration(options) {
   }
 }
 function createUuidCommand() {
-  const cmd = new Command22("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 Command23("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
@@ -6764,8 +7412,8 @@ Examples:
 }
 
 // src/commands/utils/hash.ts
-import { Command as Command23 } from "commander";
-async function handleHashGeneration(input4, options) {
+import { Command as Command24 } from "commander";
+async function handleHashGeneration(input5, options) {
   const service = new UtilsService();
   try {
     let hash;
@@ -6776,14 +7424,14 @@ async function handleHashGeneration(input4, options) {
       }
       hash = await service.hashFile(options.file, options.algorithm);
     } else {
-      if (!input4) {
+      if (!input5) {
         console.error("\u274C Please provide input text or use --file option");
         process.exit(1);
       }
       if (options.algorithm === "bcrypt") {
-        hash = await service.hashBcrypt(input4, options.rounds);
+        hash = await service.hashBcrypt(input5, options.rounds);
       } else {
-        hash = await service.hash(input4, options.algorithm);
+        hash = await service.hash(input5, options.algorithm);
       }
     }
     console.log("\u{1F512} Hash Result:");
@@ -6804,7 +7452,7 @@ async function handleHashGeneration(input4, options) {
   }
 }
 function createHashCommand() {
-  const cmd = new Command23("hash").description("Generate hash (MD5, SHA, bcrypt)").argument("[input]", "Text to hash").option(
+  const cmd = new Command24("hash").description("Generate hash (MD5, SHA, bcrypt)").argument("[input]", "Text to hash").option(
     "-a, --algorithm <algorithm>",
     "Hash algorithm (md5, sha1, sha256, sha512, bcrypt)",
     "sha256"
@@ -6816,8 +7464,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 (input4, options) => {
-    await handleHashGeneration(input4, {
+`).action(async (input5, options) => {
+    await handleHashGeneration(input5, {
       ...options,
       rounds: parseInt(options.rounds, 10)
     });
@@ -6826,9 +7474,9 @@ Examples:
 }
 
 // src/commands/utils/base64-encode.ts
-import { Command as Command24 } from "commander";
+import { Command as Command25 } from "commander";
 import { readFile as readFile2 } from "fs/promises";
-async function handleBase64Encode(input4, options) {
+async function handleBase64Encode(input5, options) {
   const service = new UtilsService();
   try {
     let encoded;
@@ -6836,11 +7484,11 @@ async function handleBase64Encode(input4, options) {
       const content = await readFile2(options.file);
       encoded = service.base64Encode(content, options.urlSafe);
     } else {
-      if (!input4) {
+      if (!input5) {
         console.error("\u274C Please provide input text or use --file option");
         process.exit(1);
       }
-      encoded = service.base64Encode(input4, options.urlSafe);
+      encoded = service.base64Encode(input5, 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");
@@ -6859,33 +7507,33 @@ async function handleBase64Encode(input4, options) {
   }
 }
 function createBase64EncodeCommand() {
-  const cmd = new Command24("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 Command25("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 (input4, options) => {
-    await handleBase64Encode(input4, options);
+`).action(async (input5, options) => {
+    await handleBase64Encode(input5, options);
   });
   return cmd;
 }
 
 // src/commands/utils/base64-decode.ts
-import { Command as Command25 } from "commander";
+import { Command as Command26 } from "commander";
 import { readFile as readFile3, writeFile } from "fs/promises";
-async function handleBase64Decode(input4, options) {
+async function handleBase64Decode(input5, options) {
   const service = new UtilsService();
   try {
     let encodedInput;
     if (options.file) {
       encodedInput = await readFile3(options.file, "utf-8");
     } else {
-      if (!input4) {
+      if (!input5) {
         console.error("\u274C Please provide Base64 input or use --file option");
         process.exit(1);
       }
-      encodedInput = input4;
+      encodedInput = input5;
     }
     const decoded = service.base64Decode(encodedInput.trim());
     if (options.output) {
@@ -6904,20 +7552,20 @@ async function handleBase64Decode(input4, options) {
   }
 }
 function createBase64DecodeCommand() {
-  const cmd = new Command25("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 Command26("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 (input4, options) => {
-    await handleBase64Decode(input4, options);
+`).action(async (input5, options) => {
+    await handleBase64Decode(input5, options);
   });
   return cmd;
 }
 
 // src/commands/utils/http.ts
-import { Command as Command26 } from "commander";
+import { Command as Command27 } from "commander";
 import { readFile as readFile4 } from "fs/promises";
 async function handleHttpRequest(url, options) {
   const service = new UtilsService();
@@ -6983,7 +7631,7 @@ async function handleHttpRequest(url, options) {
   }
 }
 function createHttpCommand() {
-  const cmd = new Command26("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 Command27("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"}'
@@ -7001,7 +7649,7 @@ Examples:
 }
 
 // src/commands/utils/jwt.ts
-import { Command as Command27 } from "commander";
+import { Command as Command28 } from "commander";
 async function handleJwtDecode(token) {
   const service = new UtilsService();
   try {
@@ -7040,7 +7688,7 @@ async function handleJwtEncode(options) {
   }
 }
 function createJwtCommand() {
-  const jwtCommand = new Command27("jwt").description("Decode and encode JWT tokens");
+  const jwtCommand = new Command28("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"
@@ -7061,11 +7709,11 @@ Examples:
 }
 
 // src/commands/utils/unix-time.ts
-import { Command as Command28 } from "commander";
-async function handleUnixTime(input4, options) {
+import { Command as Command29 } from "commander";
+async function handleUnixTime(input5, options) {
   const service = new UtilsService();
   try {
-    if (!input4) {
+    if (!input5) {
       const now = /* @__PURE__ */ new Date();
       const timestamp = service.dateToUnix(now, options.ms);
       console.log("\u{1F552} Current Unix Timestamp:");
@@ -7075,8 +7723,8 @@ async function handleUnixTime(input4, options) {
       console.log(`   ISO: ${now.toISOString()}`);
       console.log(`   Local: ${now.toLocaleString()}`);
       console.log();
-    } else if (/^\d+$/.test(input4)) {
-      const timestamp = parseInt(input4, 10);
+    } else if (/^\d+$/.test(input5)) {
+      const timestamp = parseInt(input5, 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");
@@ -7089,7 +7737,7 @@ async function handleUnixTime(input4, options) {
       }
       console.log();
     } else {
-      const date = new Date(input4);
+      const date = new Date(input5);
       if (isNaN(date.getTime())) {
         console.error("\u274C Invalid date format");
         process.exit(1);
@@ -7097,7 +7745,7 @@ async function handleUnixTime(input4, 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: ${input4}`);
+      console.log(`   Input: ${input5}`);
       console.log(`   Parsed: ${date.toISOString()}`);
       console.log();
       console.log(`   ${timestamp}${options.ms ? " (ms)" : ""}`);
@@ -7109,7 +7757,7 @@ async function handleUnixTime(input4, options) {
   }
 }
 function createUnixTimeCommand() {
-  const cmd = new Command28("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 Command29("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
@@ -7117,14 +7765,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 (input4, options) => {
-    await handleUnixTime(input4, options);
+`).action(async (input5, options) => {
+    await handleUnixTime(input5, options);
   });
   return cmd;
 }
 
 // src/commands/utils/timezone.ts
-import { Command as Command29 } from "commander";
+import { Command as Command30 } from "commander";
 async function handleTimezoneConversion(time, options) {
   const service = new UtilsService();
   try {
@@ -7161,7 +7809,7 @@ async function handleTimezoneConversion(time, options) {
   }
 }
 function createTimezoneCommand() {
-  const cmd = new Command29("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 Command30("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"
@@ -7174,11 +7822,11 @@ Examples:
 }
 
 // src/commands/utils/url-encode.ts
-import { Command as Command30 } from "commander";
-async function handleUrlEncode(input4, options) {
+import { Command as Command31 } from "commander";
+async function handleUrlEncode(input5, options) {
   const service = new UtilsService();
   try {
-    const encoded = service.urlEncode(input4, options.full);
+    const encoded = service.urlEncode(input5, 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) {
@@ -7195,24 +7843,24 @@ async function handleUrlEncode(input4, options) {
   }
 }
 function createUrlEncodeCommand() {
-  const cmd = new Command30("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 Command31("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 (input4, options) => {
-    await handleUrlEncode(input4, options);
+`).showHelpAfterError("(add --help for additional examples)").action(async (input5, options) => {
+    await handleUrlEncode(input5, options);
   });
   return cmd;
 }
 
 // src/commands/utils/url-decode.ts
-import { Command as Command31 } from "commander";
-async function handleUrlDecode(input4, options) {
+import { Command as Command32 } from "commander";
+async function handleUrlDecode(input5, options) {
   const service = new UtilsService();
   try {
-    const decoded = service.urlDecode(input4, options.full);
+    const decoded = service.urlDecode(input5, 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) {
@@ -7229,20 +7877,20 @@ async function handleUrlDecode(input4, options) {
   }
 }
 function createUrlDecodeCommand() {
-  const cmd = new Command31("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 Command32("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 (input4, options) => {
-    await handleUrlDecode(input4, options);
+`).showHelpAfterError("(add --help for additional examples)").action(async (input5, options) => {
+    await handleUrlDecode(input5, options);
   });
   return cmd;
 }
 
 // src/commands/utils/cron.ts
-import { Command as Command32 } from "commander";
+import { Command as Command33 } from "commander";
 import cronstrue from "cronstrue";
 async function handleCronParse(expression) {
   try {
@@ -7285,7 +7933,7 @@ async function handleCronParse(expression) {
   }
 }
 function createCronCommand() {
-  const cmd = new Command32("cron").description("Parse and explain cron expression").argument("<expression>", 'Cron expression (e.g., "0 5 * * *")').addHelpText("after", `
+  const cmd = new Command33("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 * * * *"
@@ -7299,7 +7947,7 @@ Examples:
 }
 
 // src/commands/utils/markdown-preview.ts
-import { Command as Command33 } from "commander";
+import { Command as Command34 } from "commander";
 import { readFile as readFile5 } from "fs/promises";
 import { marked } from "marked";
 import TerminalRenderer from "marked-terminal";
@@ -7338,7 +7986,7 @@ ${code.trim()}
   }
 }
 function createMarkdownPreviewCommand() {
-  const cmd = new Command33("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 Command34("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
@@ -7372,14 +8020,14 @@ var PasswordView = () => {
   React27.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput12((input4, key) => {
+  useInput12((input5, 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 (input4 === "c" && passwords.length > 0) {
+    } else if (input5 === "c" && passwords.length > 0) {
       handleCopy(0);
     }
   });
@@ -7462,7 +8110,7 @@ var UuidView = () => {
   React28.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput13((input4, key) => {
+  useInput13((input5, key) => {
     if (key.tab) {
       const fields = ["count", "uppercase", "hyphens", "generate"];
       const currentIndex = fields.indexOf(focusedField);
@@ -7475,7 +8123,7 @@ var UuidView = () => {
       } else {
         handleGenerate();
       }
-    } else if (input4 === "c" && uuids.length > 0) {
+    } else if (input5 === "c" && uuids.length > 0) {
       handleCopy(0);
     }
   });
@@ -7550,7 +8198,7 @@ var HashView = () => {
   React29.useEffect(() => {
     handleGenerate();
   }, []);
-  useInput14((input4, key) => {
+  useInput14((input5, key) => {
     if (key.tab) {
       const fields = ["text", "algorithm", "generate"];
       const currentIndex = fields.indexOf(focusedField);
@@ -7563,7 +8211,7 @@ var HashView = () => {
     } else if (key.rightArrow && focusedField === "algorithm") {
       const currentIndex = ALGORITHMS.indexOf(algorithm);
       setAlgorithm(ALGORITHMS[(currentIndex + 1) % ALGORITHMS.length]);
-    } else if (input4 === "c" && hash) {
+    } else if (input5 === "c" && hash) {
       handleCopy();
     }
   });
@@ -7629,7 +8277,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 [input4, setInput] = useState17("");
+  const [input5, setInput] = useState17("");
   const [mode, setMode] = useState17("encode");
   const [urlSafe, setUrlSafe] = useState17(false);
   const [result, setResult] = useState17("");
@@ -7637,7 +8285,7 @@ var Base64View = () => {
   const [focusedField, setFocusedField] = useState17("input");
   const [copied, setCopied] = useState17(false);
   const service = new UtilsService();
-  useInput15((input5, key) => {
+  useInput15((input6, key) => {
     if (key.tab) {
       const fields = ["input", "mode", "urlsafe", "convert"];
       const currentIndex = fields.indexOf(focusedField);
@@ -7652,22 +8300,22 @@ var Base64View = () => {
       } else {
         handleConvert();
       }
-    } else if (input5 === "c" && result) {
+    } else if (input6 === "c" && result) {
       handleCopy();
     }
   });
   const handleConvert = () => {
-    if (!input4) {
+    if (!input5) {
       setError("Input cannot be empty");
       return;
     }
     try {
       setError("");
       if (mode === "encode") {
-        const encoded = service.base64Encode(input4, urlSafe);
+        const encoded = service.base64Encode(input5, urlSafe);
         setResult(encoded);
       } else {
-        const decoded = service.base64Decode(input4);
+        const decoded = service.base64Decode(input5);
         setResult(decoded.toString("utf-8"));
       }
       setCopied(false);
@@ -7696,7 +8344,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: input4, onChange: setInput, placeholder: "Enter text..." }) : /* @__PURE__ */ React30.createElement(Text21, { dimColor: !input4 }, input4 || "(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: input5, onChange: setInput, placeholder: "Enter text..." }) : /* @__PURE__ */ React30.createElement(Text21, { dimColor: !input5 }, input5 || "(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(
@@ -7741,14 +8389,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 [input4, setInput] = useState18("");
+  const [input5, 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((input5, key) => {
+  useInput16((input6, key) => {
     if (key.tab) {
       const fields = ["input", "mode", "full", "convert"];
       const currentIndex = fields.indexOf(focusedField);
@@ -7762,17 +8410,17 @@ var UrlView = () => {
       } else {
         handleConvert();
       }
-    } else if (input5 === "c" && result) {
+    } else if (input6 === "c" && result) {
       handleCopy();
     }
   });
   const handleConvert = () => {
-    if (!input4) return;
+    if (!input5) return;
     if (mode === "encode") {
-      const encoded = fullUrl ? service.urlEncode(input4, true) : service.urlEncode(input4, false);
+      const encoded = fullUrl ? service.urlEncode(input5, true) : service.urlEncode(input5, false);
       setResult(encoded);
     } else {
-      const decoded = fullUrl ? service.urlDecode(input4, true) : service.urlDecode(input4, false);
+      const decoded = fullUrl ? service.urlDecode(input5, true) : service.urlDecode(input5, false);
       setResult(decoded);
     }
     setCopied(false);
@@ -7797,7 +8445,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: input4, onChange: setInput, placeholder: "Enter text or URL..." }) : /* @__PURE__ */ React31.createElement(Text22, { dimColor: !input4 }, input4 || "(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: input5, onChange: setInput, placeholder: "Enter text or URL..." }) : /* @__PURE__ */ React31.createElement(Text22, { dimColor: !input5 }, input5 || "(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(
@@ -7831,7 +8479,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 [input4, setInput] = useState19("");
+  const [input5, setInput] = useState19("");
   const [mode, setMode] = useState19("now");
   const [format, setFormat] = useState19("iso");
   const [useMs, setUseMs] = useState19(false);
@@ -7840,7 +8488,7 @@ var UnixTimeView = () => {
   const [focusedField, setFocusedField] = useState19("mode");
   const [copied, setCopied] = useState19(false);
   const service = new UtilsService();
-  useInput17((input5, key) => {
+  useInput17((input6, 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);
@@ -7861,7 +8509,7 @@ var UnixTimeView = () => {
       } else {
         handleConvert();
       }
-    } else if (input5 === "c" && result) {
+    } else if (input6 === "c" && result) {
       handleCopy();
     }
   });
@@ -7872,18 +8520,18 @@ var UnixTimeView = () => {
         const timestamp = service.unixTimeCurrent(useMs);
         setResult(timestamp.toString());
       } else if (mode === "to-human") {
-        if (!input4) {
+        if (!input5) {
           setError("Please enter a timestamp");
           return;
         }
-        const human = service.unixTimeToHuman(parseInt(input4, 10), format);
+        const human = service.unixTimeToHuman(parseInt(input5, 10), format);
         setResult(human);
       } else {
-        if (!input4) {
+        if (!input5) {
           setError("Please enter a date string");
           return;
         }
-        const timestamp = service.unixTimeFromString(input4);
+        const timestamp = service.unixTimeFromString(input5);
         setResult(timestamp.toString());
       }
       setCopied(false);
@@ -7916,11 +8564,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: input4,
+        value: input5,
         onChange: setInput,
         placeholder: mode === "to-human" ? "1702550400" : "2024-01-15 10:30:00"
       }
-    ) : /* @__PURE__ */ React32.createElement(Text23, { dimColor: !input4 }, input4 || "(empty)"))),
+    ) : /* @__PURE__ */ React32.createElement(Text23, { dimColor: !input5 }, input5 || "(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(
@@ -7974,7 +8622,7 @@ var JwtView = () => {
   const [focusedField, setFocusedField] = useState20("mode");
   const [copied, setCopied] = useState20(false);
   const service = new UtilsService();
-  useInput18((input4, key) => {
+  useInput18((input5, key) => {
     if (key.tab) {
       const fields = mode === "decode" ? ["mode", "token", "process"] : ["mode", "payload", "secret", "process"];
       const currentIndex = fields.indexOf(focusedField);
@@ -7987,7 +8635,7 @@ var JwtView = () => {
       } else {
         handleProcess();
       }
-    } else if (input4 === "c" && result.token) {
+    } else if (input5 === "c" && result.token) {
       handleCopy();
     }
   });
@@ -8112,12 +8760,12 @@ var CronView = () => {
   const [focusedField, setFocusedField] = useState21("expression");
   const [copied, setCopied] = useState21(false);
   const service = new UtilsService();
-  useInput19((input4, key) => {
+  useInput19((input5, key) => {
     if (key.tab) {
       setFocusedField(focusedField === "expression" ? "parse" : "expression");
     } else if (key.return) {
       handleParse();
-    } else if (input4 === "c" && result) {
+    } else if (input5 === "c" && result) {
       handleCopy();
     }
   });
@@ -8218,14 +8866,14 @@ var TimezoneView = () => {
   const [focusedField, setFocusedField] = useState22("time");
   const [copied, setCopied] = useState22(false);
   const service = new UtilsService();
-  useInput20((input4, key) => {
+  useInput20((input5, 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 (input4 === "c" && result) {
+    } else if (input5 === "c" && result) {
       handleCopy();
     }
   });
@@ -8344,7 +8992,7 @@ var HttpView = () => {
   const [focusedField, setFocusedField] = useState23("url");
   const [copied, setCopied] = useState23(false);
   const service = new UtilsService();
-  useInput21((input4, key) => {
+  useInput21((input5, key) => {
     if (loading) return;
     if (key.tab) {
       const fields = ["url", "method", "headers", "body", "send"];
@@ -8358,7 +9006,7 @@ var HttpView = () => {
       setMethod(METHODS[(currentIndex + 1) % METHODS.length]);
     } else if (key.return && focusedField === "send") {
       handleSend();
-    } else if (input4 === "c" && response) {
+    } else if (input5 === "c" && response) {
       handleCopy();
     }
   });
@@ -8482,14 +9130,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 fs10 from "fs";
-import * as path6 from "path";
+import * as fs12 from "fs";
+import * as path7 from "path";
 var MarkdownView = () => {
   const [filePath, setFilePath] = useState24("");
   const [content, setContent] = useState24("");
   const [error, setError] = useState24("");
   const [focusedField, setFocusedField] = useState24("file");
-  useInput22((input4, key) => {
+  useInput22((input5, key) => {
     if (key.tab) {
       setFocusedField(focusedField === "file" ? "preview" : "file");
     } else if (key.return) {
@@ -8503,12 +9151,12 @@ var MarkdownView = () => {
     }
     try {
       setError("");
-      const resolvedPath = path6.resolve(filePath);
-      if (!fs10.existsSync(resolvedPath)) {
+      const resolvedPath = path7.resolve(filePath);
+      if (!fs12.existsSync(resolvedPath)) {
         setError(`File not found: ${resolvedPath}`);
         return;
       }
-      let fileContent = fs10.readFileSync(resolvedPath, "utf-8");
+      let fileContent = fs12.readFileSync(resolvedPath, "utf-8");
       fileContent = fileContent.replace(/```mermaid\n([\s\S]*?)```/g, (match, code) => {
         return `
 \u{1F3A8} **Mermaid Diagram**
@@ -8604,20 +9252,20 @@ var UtilsApp = ({ onExit }) => {
   const [selectedIndex, setSelectedIndex] = useState25(0);
   const [activeView, setActiveView] = useState25(null);
   const { exit } = useApp5();
-  useInput23((input4, key) => {
+  useInput23((input5, key) => {
     if (activeView) {
       if (key.escape) {
         setActiveView(null);
       }
       return;
     }
-    if (key.upArrow || input4 === "k") {
+    if (key.upArrow || input5 === "k") {
       setSelectedIndex((prev) => prev > 0 ? prev - 1 : MENU_ITEMS2.length - 1);
-    } else if (key.downArrow || input4 === "j") {
+    } else if (key.downArrow || input5 === "j") {
       setSelectedIndex((prev) => prev < MENU_ITEMS2.length - 1 ? prev + 1 : 0);
     } else if (key.return) {
       setActiveView(MENU_ITEMS2[selectedIndex].id);
-    } else if (input4 === "q" || key.escape) {
+    } else if (input5 === "q" || key.escape) {
       onExit();
       exit();
     }
@@ -8747,7 +9395,7 @@ async function runInteractiveMode() {
 
 // src/commands/utils/index.ts
 function createUtilsCommand() {
-  const utilsCommand = new Command34("utils").description("Developer utilities for common tasks").option("-i, --interactive", "Run in interactive mode").addHelpText("after", `
+  const utilsCommand = new Command35("utils").description("Developer utilities for common tasks").option("-i, --interactive", "Run in interactive mode").addHelpText("after", `
 Interactive Mode:
   $ jai1 utils --interactive
   $ jai1 utils -i
@@ -8782,15 +9430,15 @@ Quick Usage:
 }
 
 // src/commands/deps/index.ts
-import { Command as Command36 } from "commander";
+import { Command as Command37 } from "commander";
 
 // src/commands/deps/upgrade.ts
-import { Command as Command35 } from "commander";
-import { checkbox as checkbox3, confirm as confirm5 } from "@inquirer/prompts";
+import { Command as Command36 } from "commander";
+import { checkbox as checkbox3, confirm as confirm6 } from "@inquirer/prompts";
 
 // src/services/deps.service.ts
-import { promises as fs11 } from "fs";
-import path7 from "path";
+import { promises as fs13 } from "fs";
+import path8 from "path";
 import { execSync } from "child_process";
 import pLimit2 from "p-limit";
 var DepsService = class {
@@ -8799,9 +9447,9 @@ var DepsService = class {
    * Đọc package.json từ thư mục
    */
   async readPackageJson(cwd) {
-    const pkgPath = path7.join(cwd, "package.json");
+    const pkgPath = path8.join(cwd, "package.json");
     try {
-      const content = await fs11.readFile(pkgPath, "utf-8");
+      const content = await fs13.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -8907,7 +9555,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs11.access(path7.join(cwd, file));
+        await fs13.access(path8.join(cwd, file));
         return pm;
       } catch {
       }
@@ -8999,7 +9647,7 @@ var colors2 = {
   dim: "\x1B[2m"
 };
 function createDepsUpgradeCommand() {
-  return new Command35("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 Command36("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);
   });
 }
@@ -9091,7 +9739,7 @@ ${colors2.yellow}\u23F8\uFE0F  \u0110\xE3 h\u1EE7y${colors2.reset}
     }
     let shouldProceed;
     try {
-      shouldProceed = await confirm5({
+      shouldProceed = await confirm6({
         message: `Ti\u1EBFn h\xE0nh upgrade ${selectedPackages.length} packages?`,
         default: true
       });
@@ -9179,20 +9827,20 @@ function displayUpgradeTable(packages) {
 
 // src/commands/deps/index.ts
 function createDepsCommand() {
-  const depsCommand = new Command36("deps").description("Qu\u1EA3n l\xFD dependencies trong project");
+  const depsCommand = new Command37("deps").description("Qu\u1EA3n l\xFD dependencies trong project");
   depsCommand.addCommand(createDepsUpgradeCommand());
   return depsCommand;
 }
 
 // src/commands/kit/index.ts
-import { Command as Command40 } from "commander";
+import { Command as Command41 } from "commander";
 
 // src/commands/kit/list.ts
-import { Command as Command37 } from "commander";
+import { Command as Command38 } from "commander";
 
 // src/services/starter-kit.service.ts
-import { promises as fs12 } from "fs";
-import { join as join5 } from "path";
+import { promises as fs14 } from "fs";
+import { join as join6 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
   /**
@@ -9239,23 +9887,23 @@ var StarterKitService = class {
       throw new NetworkError(`Failed to download kit: HTTP ${response.status}`);
     }
     if (onProgress) onProgress(30);
-    const tmpDir = join5(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs12.mkdir(tmpDir, { recursive: true });
-    const tmpFile = join5(tmpDir, `${slug}.zip`);
+    const tmpDir = join6(process.env.TMPDIR || "/tmp", "jai1-kits");
+    await fs14.mkdir(tmpDir, { recursive: true });
+    const tmpFile = join6(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs12.writeFile(tmpFile, Buffer.from(buffer));
+    await fs14.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs12.mkdir(targetDir, { recursive: true });
+    await fs14.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs12.unlink(tmpFile);
+    await fs14.unlink(tmpFile);
   }
 };
 
 // src/commands/kit/list.ts
 function createKitListCommand() {
-  return new Command37("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 Command38("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) {
@@ -9292,9 +9940,9 @@ function createKitListCommand() {
 }
 
 // src/commands/kit/info.ts
-import { Command as Command38 } from "commander";
+import { Command as Command39 } from "commander";
 function createKitInfoCommand() {
-  return new Command38("info").description("Show detailed information about a starter kit").argument("<slug>", "Starter kit slug").action(async (slug) => {
+  return new Command39("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) {
@@ -9343,10 +9991,10 @@ Post-Init Commands:`);
 }
 
 // src/commands/kit/create.ts
-import { Command as Command39 } from "commander";
-import { promises as fs13 } from "fs";
-import { join as join6 } from "path";
-import { select as select2, input, checkbox as checkbox4 } from "@inquirer/prompts";
+import { Command as Command40 } from "commander";
+import { promises as fs15 } from "fs";
+import { join as join7 } from "path";
+import { select as select3, input as input2, checkbox as checkbox4 } from "@inquirer/prompts";
 import { execa as execa2 } from "execa";
 
 // src/services/hook-executor.service.ts
@@ -9388,7 +10036,7 @@ var HookExecutor = class {
 
 // src/commands/kit/create.ts
 function createKitCreateCommand() {
-  return new Command39("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 Command40("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) {
@@ -9408,9 +10056,9 @@ function createKitCreateCommand() {
         }
       }
     }
-    const targetDir = directory || join6(process.cwd(), options.name || slug);
+    const targetDir = directory || join7(process.cwd(), options.name || slug);
     try {
-      await fs13.access(targetDir);
+      await fs15.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -9444,14 +10092,14 @@ function createKitCreateCommand() {
         console.log("\u{1F4DD} Please provide project details:");
         for (const v of kit.config.variables) {
           if (v.type === "select" && v.options) {
-            const answer = await select2({
+            const answer = await select3({
               message: v.prompt,
               choices: v.options.map((opt) => ({ name: opt, value: opt })),
               default: v.default
             });
             variables[v.name] = answer;
           } else {
-            const answer = await input({
+            const answer = await input2({
               message: v.prompt,
               default: v.default
             });
@@ -9528,7 +10176,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs13.readFile(file, "utf-8");
+    let content = await fs15.readFile(file, "utf-8");
     let modified = false;
     for (const [key, value] of Object.entries(variables)) {
       const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
@@ -9538,15 +10186,15 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs13.writeFile(file, content, "utf-8");
+      await fs15.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs13.readdir(dir, { withFileTypes: true });
+  const entries = await fs15.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join6(dir, entry.name);
+    const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
         files.push(...await getAllFiles(fullPath));
@@ -9560,7 +10208,7 @@ async function getAllFiles(dir) {
 
 // src/commands/kit/index.ts
 function createKitCommand() {
-  const cmd = new Command40("kit").description("Manage starter kits for new projects").action(() => {
+  const cmd = new Command41("kit").description("Manage starter kits for new projects").action(() => {
     cmd.help();
   });
   cmd.addCommand(createKitListCommand());
@@ -9570,12 +10218,12 @@ function createKitCommand() {
 }
 
 // src/commands/rules/index.ts
-import { Command as Command47 } from "commander";
+import { Command as Command48 } from "commander";
 
 // src/commands/rules/list.ts
-import { Command as Command41 } from "commander";
+import { Command as Command42 } from "commander";
 function createRulesListCommand() {
-  return new Command41("list").description("List available rule presets").option("--json", "Output as JSON").action(async (options) => {
+  return new Command42("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) {
@@ -9630,12 +10278,12 @@ function createRulesListCommand() {
 }
 
 // src/commands/rules/init.ts
-import { Command as Command42 } from "commander";
-import { promises as fs14 } from "fs";
-import { join as join7 } from "path";
-import { select as select3, confirm as confirm6 } from "@inquirer/prompts";
+import { Command as Command43 } from "commander";
+import { promises as fs16 } from "fs";
+import { join as join8 } from "path";
+import { select as select4, confirm as confirm7 } from "@inquirer/prompts";
 function createRulesInitCommand() {
-  return new Command42("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) => {
+  return new Command43("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) {
@@ -9657,7 +10305,7 @@ function createRulesInitCommand() {
         console.log("No presets available.");
         return;
       }
-      presetSlug = await select3({
+      presetSlug = await select4({
         message: "Select a preset:",
         choices: data.presets.map((p) => ({
           name: `${p.name} - ${p.description}`,
@@ -9685,7 +10333,7 @@ function createRulesInitCommand() {
     console.log(`  Files: ${Object.keys(bundle.files).length}`);
     let outputFormat = options.output;
     if (!["cursor", "agents-md", "both"].includes(outputFormat)) {
-      outputFormat = await select3({
+      outputFormat = await select4({
         message: "Select output format:",
         choices: [
           { name: "Cursor (.cursor/rules/)", value: "cursor" },
@@ -9695,7 +10343,7 @@ function createRulesInitCommand() {
       });
     }
     if (!options.yes) {
-      const proceed = await confirm6({
+      const proceed = await confirm7({
         message: `Apply preset '${bundle.preset.name}' to current directory?`,
         default: true
       });
@@ -9717,7 +10365,7 @@ function createRulesInitCommand() {
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
       customContext: "09-custom.mdc"
     };
-    await fs14.writeFile("jai1-rules.json", JSON.stringify(projectConfig, null, 2));
+    await fs16.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:");
@@ -9727,11 +10375,11 @@ function createRulesInitCommand() {
   });
 }
 async function applyCursorFormat(bundle) {
-  const rulesDir = join7(process.cwd(), ".cursor", "rules");
-  await fs14.mkdir(rulesDir, { recursive: true });
+  const rulesDir = join8(process.cwd(), ".cursor", "rules");
+  await fs16.mkdir(rulesDir, { recursive: true });
   for (const [filename, content] of Object.entries(bundle.files)) {
-    const filePath = join7(rulesDir, filename);
-    await fs14.writeFile(filePath, content, "utf-8");
+    const filePath = join8(rulesDir, filename);
+    await fs16.writeFile(filePath, content, "utf-8");
     console.log(`\u2713 Created .cursor/rules/${filename}`);
   }
 }
@@ -9758,15 +10406,15 @@ async function applyAgentsMdFormat(bundle) {
     }
   }
   const agentsMd = sections.join("\n");
-  await fs14.writeFile("AGENTS.md", agentsMd, "utf-8");
+  await fs16.writeFile("AGENTS.md", agentsMd, "utf-8");
   console.log("\u2713 Created AGENTS.md");
 }
 
 // src/commands/rules/apply.ts
-import { Command as Command43 } from "commander";
-import { promises as fs16 } from "fs";
-import { join as join9 } from "path";
-import { select as select4, confirm as confirm7, checkbox as checkbox5 } from "@inquirer/prompts";
+import { Command as Command44 } from "commander";
+import { promises as fs18 } from "fs";
+import { join as join10 } from "path";
+import { select as select5, confirm as confirm8, checkbox as checkbox5 } from "@inquirer/prompts";
 
 // src/services/rules-generator.service.ts
 var RulesGeneratorService = class {
@@ -10125,8 +10773,8 @@ Follow all instructions and patterns defined in AGENTS.md above.
 };
 
 // src/services/backup.service.ts
-import { promises as fs15 } from "fs";
-import { join as join8, dirname } from "path";
+import { promises as fs17 } from "fs";
+import { join as join9, dirname } from "path";
 var BackupService = class {
   backupDir = ".jai1/backups";
   /**
@@ -10134,7 +10782,7 @@ var BackupService = class {
    */
   async createBackup(ides, presetSlug) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = join8(this.backupDir, timestamp);
+    const backupPath = join9(this.backupDir, timestamp);
     const backedUpFiles = [];
     let hasContent = false;
     for (const ideId of ides) {
@@ -10143,7 +10791,7 @@ var BackupService = class {
         console.warn(`Unknown IDE format: ${ideId}, skipping backup`);
         continue;
       }
-      const rulesPath = format.rulesPath === "." ? process.cwd() : join8(process.cwd(), format.rulesPath);
+      const rulesPath = format.rulesPath === "." ? process.cwd() : join9(process.cwd(), format.rulesPath);
       try {
         const exists = await this.pathExists(rulesPath);
         if (!exists) {
@@ -10156,19 +10804,19 @@ var BackupService = class {
           await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
           hasContent = true;
         } else {
-          const stats = await fs15.stat(rulesPath);
+          const stats = await fs17.stat(rulesPath);
           if (stats.isDirectory()) {
-            const files = await fs15.readdir(rulesPath);
+            const files = await fs17.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 fs15.mkdir(dirname(destPath), { recursive: true });
-                await fs15.copyFile(originalPath, destPath);
+                const originalPath = join9(rulesPath, file);
+                const relativePath = join9(format.rulesPath, file);
+                const destPath = join9(backupPath, ideId, file);
+                await fs17.mkdir(dirname(destPath), { recursive: true });
+                await fs17.copyFile(originalPath, destPath);
                 backedUpFiles.push({
                   originalPath: relativePath,
-                  backupPath: join8(ideId, file),
+                  backupPath: join9(ideId, file),
                   ide: ideId
                 });
                 hasContent = true;
@@ -10189,9 +10837,9 @@ var BackupService = class {
       ides,
       files: backedUpFiles
     };
-    await fs15.mkdir(backupPath, { recursive: true });
-    await fs15.writeFile(
-      join8(backupPath, "metadata.json"),
+    await fs17.mkdir(backupPath, { recursive: true });
+    await fs17.writeFile(
+      join9(backupPath, "metadata.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
     );
@@ -10201,18 +10849,18 @@ var BackupService = class {
    * Backup a single file (for AGENTS.md, GEMINI.md)
    */
   async backupSingleFile(filename, backupPath, ideId, backedUpFiles) {
-    const originalPath = join8(process.cwd(), filename);
+    const originalPath = join9(process.cwd(), filename);
     try {
       const exists = await this.pathExists(originalPath);
       if (!exists) {
         return;
       }
-      const destPath = join8(backupPath, ideId, filename);
-      await fs15.mkdir(dirname(destPath), { recursive: true });
-      await fs15.copyFile(originalPath, destPath);
+      const destPath = join9(backupPath, ideId, filename);
+      await fs17.mkdir(dirname(destPath), { recursive: true });
+      await fs17.copyFile(originalPath, destPath);
       backedUpFiles.push({
         originalPath: filename,
-        backupPath: join8(ideId, filename),
+        backupPath: join9(ideId, filename),
         ide: ideId
       });
     } catch (error) {
@@ -10222,16 +10870,16 @@ var BackupService = class {
    * Restore files from a backup
    */
   async restoreBackup(backupPath) {
-    const metadataPath = join8(backupPath, "metadata.json");
-    const metadataContent = await fs15.readFile(metadataPath, "utf-8");
+    const metadataPath = join9(backupPath, "metadata.json");
+    const metadataContent = await fs17.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 fs15.mkdir(dirname(destPath), { recursive: true });
-      await fs15.copyFile(sourcePath, destPath);
+      const sourcePath = join9(backupPath, file.backupPath);
+      const destPath = join9(process.cwd(), file.originalPath);
+      await fs17.mkdir(dirname(destPath), { recursive: true });
+      await fs17.copyFile(sourcePath, destPath);
       console.log(`\u2713 Restored ${file.originalPath}`);
     }
     console.log("\n\u2705 Backup restored successfully!");
@@ -10241,18 +10889,18 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async listBackups() {
     try {
-      const backupDirPath = join8(process.cwd(), this.backupDir);
+      const backupDirPath = join9(process.cwd(), this.backupDir);
       const exists = await this.pathExists(backupDirPath);
       if (!exists) {
         return [];
       }
-      const entries = await fs15.readdir(backupDirPath, { withFileTypes: true });
+      const entries = await fs17.readdir(backupDirPath, { withFileTypes: true });
       const backups = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const metadataPath = join8(backupDirPath, entry.name, "metadata.json");
+          const metadataPath = join9(backupDirPath, entry.name, "metadata.json");
           try {
-            const metadataContent = await fs15.readFile(metadataPath, "utf-8");
+            const metadataContent = await fs17.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(metadataContent);
             backups.push(metadata);
           } catch {
@@ -10269,7 +10917,7 @@ Restoring backup from ${metadata.timestamp}...`);
    * Delete a specific backup
    */
   async deleteBackup(timestamp) {
-    const backupPath = join8(process.cwd(), this.backupDir, timestamp);
+    const backupPath = join9(process.cwd(), this.backupDir, timestamp);
     await this.deleteDirectory(backupPath);
   }
   /**
@@ -10299,9 +10947,9 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Check if a path exists
    */
-  async pathExists(path9) {
+  async pathExists(path10) {
     try {
-      await fs15.access(path9);
+      await fs17.access(path10);
       return true;
     } catch {
       return false;
@@ -10310,22 +10958,22 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Recursively delete a directory
    */
-  async deleteDirectory(path9) {
+  async deleteDirectory(path10) {
     try {
-      const exists = await this.pathExists(path9);
+      const exists = await this.pathExists(path10);
       if (!exists) {
         return;
       }
-      const entries = await fs15.readdir(path9, { withFileTypes: true });
+      const entries = await fs17.readdir(path10, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join8(path9, entry.name);
+        const fullPath = join9(path10, entry.name);
         if (entry.isDirectory()) {
           await this.deleteDirectory(fullPath);
         } else {
-          await fs15.unlink(fullPath);
+          await fs17.unlink(fullPath);
         }
       }
-      await fs15.rmdir(path9);
+      await fs17.rmdir(path10);
     } catch (error) {
     }
   }
@@ -10333,20 +10981,20 @@ Restoring backup from ${metadata.timestamp}...`);
    * Get backup directory path
    */
   getBackupDir() {
-    return join8(process.cwd(), this.backupDir);
+    return join9(process.cwd(), this.backupDir);
   }
   /**
    * Ensure backup directory exists
    */
   async ensureBackupDir() {
-    const backupDirPath = join8(process.cwd(), this.backupDir);
-    await fs15.mkdir(backupDirPath, { recursive: true });
+    const backupDirPath = join9(process.cwd(), this.backupDir);
+    await fs17.mkdir(backupDirPath, { recursive: true });
   }
 };
 
 // src/commands/rules/apply.ts
 function createRulesApplyCommand() {
-  return new Command43("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) => {
+  return new Command44("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) {
@@ -10378,7 +11026,7 @@ function createRulesApplyCommand() {
         console.log("No presets available.");
         return;
       }
-      presetSlug = await select4({
+      presetSlug = await select5({
         message: "Select a preset:",
         choices: data.presets.map((p) => ({
           name: `${p.name} - ${p.description}`,
@@ -10486,7 +11134,7 @@ function createRulesApplyCommand() {
       if (backupPath) {
         console.log(`  Backup: ${backupPath}`);
       }
-      const proceed = await confirm7({
+      const proceed = await confirm8({
         message: "Apply these rules to the current directory?",
         default: true
       });
@@ -10496,21 +11144,21 @@ function createRulesApplyCommand() {
       }
     }
     console.log("\n\u{1F4DD} Applying preset...\n");
-    const rulePresetDir = join9(process.cwd(), ".jai1", "rule-preset");
+    const rulePresetDir = join10(process.cwd(), ".jai1", "rule-preset");
     try {
-      await fs16.rm(rulePresetDir, { recursive: true, force: true });
+      await fs18.rm(rulePresetDir, { recursive: true, force: true });
     } catch {
     }
-    await fs16.mkdir(rulePresetDir, { recursive: true });
-    await fs16.writeFile(
-      join9(rulePresetDir, "preset.json"),
+    await fs18.mkdir(rulePresetDir, { recursive: true });
+    await fs18.writeFile(
+      join10(rulePresetDir, "preset.json"),
       JSON.stringify(bundle.preset, null, 2),
       "utf-8"
     );
     for (const [filename, content] of Object.entries(bundle.files)) {
-      const filePath = join9(rulePresetDir, filename);
-      await fs16.mkdir(join9(filePath, ".."), { recursive: true });
-      await fs16.writeFile(filePath, content, "utf-8");
+      const filePath = join10(rulePresetDir, filename);
+      await fs18.mkdir(join10(filePath, ".."), { recursive: true });
+      await fs18.writeFile(filePath, content, "utf-8");
     }
     console.log(`\u2713 Saved preset to .jai1/rule-preset/`);
     const allGeneratedFiles = [];
@@ -10518,9 +11166,9 @@ function createRulesApplyCommand() {
       try {
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
-          const fullPath = join9(process.cwd(), file.path);
-          await fs16.mkdir(join9(fullPath, ".."), { recursive: true });
-          await fs16.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join10(process.cwd(), file.path);
+          await fs18.mkdir(join10(fullPath, ".."), { recursive: true });
+          await fs18.writeFile(fullPath, file.content, "utf-8");
           console.log(`\u2713 [${ideId}] ${file.path}`);
           allGeneratedFiles.push({
             ide: ideId,
@@ -10547,8 +11195,8 @@ function createRulesApplyCommand() {
       ] : []
     };
     try {
-      const existingConfigPath = join9(process.cwd(), "jai1-rules.json");
-      const existingConfigContent = await fs16.readFile(existingConfigPath, "utf-8");
+      const existingConfigPath = join10(process.cwd(), "jai1-rules.json");
+      const existingConfigContent = await fs18.readFile(existingConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingConfigContent);
       if (existingConfig.backups && existingConfig.backups.length > 0) {
         projectConfig.backups = [
@@ -10559,8 +11207,8 @@ function createRulesApplyCommand() {
       }
     } catch {
     }
-    await fs16.writeFile(
-      join9(process.cwd(), "jai1-rules.json"),
+    await fs18.writeFile(
+      join10(process.cwd(), "jai1-rules.json"),
       JSON.stringify(projectConfig, null, 2),
       "utf-8"
     );
@@ -10591,11 +11239,11 @@ function createRulesApplyCommand() {
 }
 
 // src/commands/rules/restore.ts
-import { Command as Command44 } from "commander";
-import { join as join10 } from "path";
-import { select as select5, confirm as confirm8 } from "@inquirer/prompts";
+import { Command as Command45 } from "commander";
+import { join as join11 } from "path";
+import { select as select6, confirm as confirm9 } from "@inquirer/prompts";
 function createRulesRestoreCommand() {
-  return new Command44("restore").description("Restore rules from a backup").option("--latest", "Restore the most recent backup").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command45("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) {
@@ -10608,7 +11256,7 @@ function createRulesRestoreCommand() {
       console.log(`\u{1F4E6} Selected latest backup: ${selectedBackup.timestamp}`);
     } else {
       console.log("\u{1F4CB} Available backups:\n");
-      const backupTimestamp = await select5({
+      const backupTimestamp = await select6({
         message: "Select a backup to restore:",
         choices: backups.map((backup) => ({
           name: formatBackupInfo(backup),
@@ -10627,7 +11275,7 @@ function createRulesRestoreCommand() {
     console.log(`  IDEs: ${selectedBackup.ides.join(", ")}`);
     console.log(`  Files: ${selectedBackup.files.length}`);
     if (!options.yes) {
-      const proceed = await confirm8({
+      const proceed = await confirm9({
         message: "This will overwrite current rules. Continue?",
         default: false
       });
@@ -10638,7 +11286,7 @@ function createRulesRestoreCommand() {
     }
     console.log("\n\u{1F504} Restoring backup...\n");
     try {
-      const backupPath = join10(backupService.getBackupDir(), selectedBackup.timestamp);
+      const backupPath = join11(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.");
@@ -10663,16 +11311,16 @@ function formatTimestamp(timestamp) {
 }
 
 // src/commands/rules/sync.ts
-import { Command as Command45 } from "commander";
-import { promises as fs17 } from "fs";
-import { join as join11 } from "path";
-import { confirm as confirm9 } from "@inquirer/prompts";
+import { Command as Command46 } from "commander";
+import { promises as fs19 } from "fs";
+import { join as join12 } from "path";
+import { confirm as confirm10 } from "@inquirer/prompts";
 function createRulesSyncCommand() {
-  return new Command45("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");
+  return new Command46("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 = join12(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs17.readFile(configPath, "utf-8");
+      const configContent = await fs19.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -10699,7 +11347,7 @@ Detected ${detected.length} active IDE(s):
         console.log(`  ${confidence} ${d.name} - ${d.ruleCount} rules`);
       });
       if (!options.yes) {
-        const proceed = await confirm9({
+        const proceed = await confirm10({
           message: "\nSync these detected IDEs?",
           default: true
         });
@@ -10752,14 +11400,14 @@ Detected ${detected.length} active IDE(s):
       throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
     }
     const bundle = await presetResponse.json();
-    const rulePresetDir = join11(process.cwd(), ".jai1", "rule-preset");
+    const rulePresetDir = join12(process.cwd(), ".jai1", "rule-preset");
     const presetExists = await checkPathExists(rulePresetDir);
     if (presetExists) {
-      const files = await fs17.readdir(rulePresetDir);
+      const files = await fs19.readdir(rulePresetDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = join11(rulePresetDir, file);
-          const content = await fs17.readFile(filePath, "utf-8");
+          const filePath = join12(rulePresetDir, file);
+          const content = await fs19.readFile(filePath, "utf-8");
           bundle.files[file] = content;
         }
       }
@@ -10778,9 +11426,9 @@ Detected ${detected.length} active IDE(s):
         }
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
-          const fullPath = join11(process.cwd(), file.path);
-          await fs17.mkdir(join11(fullPath, ".."), { recursive: true });
-          await fs17.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join12(process.cwd(), file.path);
+          await fs19.mkdir(join12(fullPath, ".."), { recursive: true });
+          await fs19.writeFile(fullPath, file.content, "utf-8");
         }
         console.log(`\u2713 ${format.name} - ${files.length} files regenerated`);
       } catch (error) {
@@ -10789,8 +11437,8 @@ Detected ${detected.length} active IDE(s):
     }
     if (JSON.stringify(projectConfig.ides) !== JSON.stringify(idesToSync)) {
       projectConfig.ides = idesToSync;
-      await fs17.writeFile(
-        join11(process.cwd(), "jai1-rules.json"),
+      await fs19.writeFile(
+        join12(process.cwd(), "jai1-rules.json"),
         JSON.stringify(projectConfig, null, 2),
         "utf-8"
       );
@@ -10805,7 +11453,7 @@ Detected ${detected.length} active IDE(s):
 }
 async function checkPathExists(absolutePath) {
   try {
-    await fs17.access(absolutePath);
+    await fs19.access(absolutePath);
     return true;
   } catch {
     return false;
@@ -10813,15 +11461,15 @@ async function checkPathExists(absolutePath) {
 }
 
 // src/commands/rules/info.ts
-import { Command as Command46 } from "commander";
-import { promises as fs18 } from "fs";
-import { join as join12 } from "path";
+import { Command as Command47 } from "commander";
+import { promises as fs20 } from "fs";
+import { join as join13 } from "path";
 function createRulesInfoCommand() {
-  return new Command46("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
-    const configPath = join12(process.cwd(), "jai1-rules.json");
+  return new Command47("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
+    const configPath = join13(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs18.readFile(configPath, "utf-8");
+      const configContent = await fs20.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -10833,14 +11481,14 @@ function createRulesInfoCommand() {
       return;
     }
     console.log("\u{1F4CB} Current Preset Information\n");
-    const rulePresetDir = join12(process.cwd(), ".jai1", "rule-preset");
-    const presetJsonPath = join12(rulePresetDir, "preset.json");
+    const rulePresetDir = join13(process.cwd(), ".jai1", "rule-preset");
+    const presetJsonPath = join13(rulePresetDir, "preset.json");
     let presetMetadata = null;
     let presetFiles = [];
     try {
-      const presetContent = await fs18.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs20.readFile(presetJsonPath, "utf-8");
       presetMetadata = JSON.parse(presetContent);
-      const files = await fs18.readdir(rulePresetDir);
+      const files = await fs20.readdir(rulePresetDir);
       presetFiles = files.filter((f) => f.endsWith(".mdc"));
     } catch {
     }
@@ -10899,9 +11547,9 @@ Available Backups (${projectConfig.backups.length}):`);
     console.log('  \u2022 "jai1 rules apply" - Apply a different preset (replaces current)');
   });
 }
-async function checkPathExists2(path9) {
+async function checkPathExists2(path10) {
   try {
-    await fs18.access(join12(process.cwd(), path9));
+    await fs20.access(join13(process.cwd(), path10));
     return true;
   } catch {
     return false;
@@ -10923,7 +11571,7 @@ async function checkIdeFilesExist(ideId, format) {
 
 // src/commands/rules/index.ts
 function createRulesCommand() {
-  const rulesCommand = new Command47("rules").description("Manage rule presets for AI agents");
+  const rulesCommand = new Command48("rules").description("Manage rule presets for AI agents");
   rulesCommand.addCommand(createRulesListCommand());
   rulesCommand.addCommand(createRulesInitCommand());
   rulesCommand.addCommand(createRulesApplyCommand());
@@ -10934,8 +11582,8 @@ function createRulesCommand() {
 }
 
 // src/commands/upgrade.ts
-import { Command as Command48 } from "commander";
-import { confirm as confirm10 } from "@inquirer/prompts";
+import { Command as Command49 } from "commander";
+import { confirm as confirm11 } from "@inquirer/prompts";
 import { execSync as execSync2 } from "child_process";
 var colors3 = {
   yellow: "\x1B[33m",
@@ -10946,7 +11594,7 @@ var colors3 = {
   bold: "\x1B[1m"
 };
 function createUpgradeCommand() {
-  return new Command48("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) => {
+  return new Command49("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);
   });
 }
@@ -10990,7 +11638,7 @@ ${colors3.bold}Current version:${colors3.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm10({
+      const shouldUpdate = await confirm11({
         message: "Update to the latest version now?",
         default: true
       });
@@ -11094,11 +11742,11 @@ function getInstallCommand(packageManager2) {
 }
 
 // src/commands/clean.ts
-import { Command as Command49 } from "commander";
-import { confirm as confirm11, select as select6 } from "@inquirer/prompts";
-import { join as join13 } from "path";
+import { Command as Command50 } from "commander";
+import { confirm as confirm12, select as select7 } from "@inquirer/prompts";
+import { join as join14 } from "path";
 function createCleanCommand() {
-  return new Command49("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 Command50("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);
   });
 }
@@ -11109,7 +11757,7 @@ async function handleClean(options) {
     {
       name: "Backups",
       description: "Component backup files (.jai1_backup/)",
-      path: join13(cwd, ".jai1_backup"),
+      path: join14(cwd, ".jai1_backup"),
       check: async () => {
         const backups = await service.listBackups(cwd);
         return { exists: backups.length > 0, count: backups.length };
@@ -11159,7 +11807,7 @@ async function handleClean(options) {
     console.log(`     Path: ${target.path}
 `);
   }
-  const action = await select6({
+  const action = await select7({
     message: "What do you want to clean?",
     choices: [
       ...availableTargets.map(({ target, info }) => ({
@@ -11193,7 +11841,7 @@ async function cleanTarget(target, skipConfirm) {
   }
   const countStr = info.count ? ` (${info.count} items)` : "";
   if (!skipConfirm) {
-    const confirmed = await confirm11({
+    const confirmed = await confirm12({
       message: `Delete ${target.name}${countStr}?`,
       default: false
     });
@@ -11211,7 +11859,7 @@ async function cleanTarget(target, skipConfirm) {
 }
 
 // src/commands/redmine/check.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 
 // src/services/redmine-config.service.ts
 import { readFile as readFile6 } from "fs/promises";
@@ -11332,8 +11980,8 @@ var RedmineApiClient = class {
     this.retryConfig = config.defaults.retry;
     this.concurrencyLimit = pLimit3(config.defaults.concurrency);
   }
-  async request(path9, options = {}) {
-    const url = `${this.baseUrl}${path9}`;
+  async request(path10, options = {}) {
+    const url = `${this.baseUrl}${path10}`;
     const headers = {
       "X-Redmine-API-Key": this.apiAccessToken,
       "Content-Type": "application/json",
@@ -11394,8 +12042,8 @@ var RedmineApiClient = class {
     if (include && include.length > 0) {
       params.append("include", include.join(","));
     }
-    const path9 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
-    return this.request(path9);
+    const path10 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
+    return this.request(path10);
   }
   async getIssues(projectId, options = {}) {
     const params = new URLSearchParams();
@@ -11415,8 +12063,8 @@ var RedmineApiClient = class {
     if (options.updatedSince) {
       params.append("updated_on", `>=${options.updatedSince}`);
     }
-    const path9 = `/issues.json?${params.toString()}`;
-    return this.request(path9);
+    const path10 = `/issues.json?${params.toString()}`;
+    return this.request(path10);
   }
   async getAllIssues(projectId, options = {}) {
     const pageSize = options.pageSize || 100;
@@ -11518,7 +12166,7 @@ async function checkConnectivity(config) {
 
 // src/commands/redmine/check.ts
 function createRedmineCheckCommand() {
-  const cmd = new Command50("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 Command51("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;
@@ -11546,7 +12194,7 @@ async function handleRedmineCheck(options) {
 }
 
 // src/commands/redmine/sync-issue.ts
-import { Command as Command51 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/sync-issue.ts
 import { resolve as resolve3, relative } from "path";
@@ -11930,7 +12578,7 @@ function extractIssueIdFromUrl(url) {
 
 // src/commands/redmine/sync-issue.ts
 function createSyncIssueCommand() {
-  const cmd = new Command51("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 Command52("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;
@@ -11974,7 +12622,7 @@ async function handleSyncIssue(options) {
 }
 
 // src/commands/redmine/sync-project.ts
-import { Command as Command52 } from "commander";
+import { Command as Command53 } from "commander";
 
 // src/sync-project.ts
 async function syncProject(config, options = {}) {
@@ -12044,7 +12692,7 @@ async function syncProject(config, options = {}) {
 
 // src/commands/redmine/sync-project.ts
 function createSyncProjectCommand() {
-  const cmd = new Command52("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 Command53("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;
@@ -12099,12 +12747,12 @@ async function handleSyncProject(options) {
 }
 
 // src/commands/framework/info.ts
-import { Command as Command53 } from "commander";
-import { promises as fs19 } from "fs";
-import { join as join14 } from "path";
+import { Command as Command54 } from "commander";
+import { promises as fs21 } from "fs";
+import { join as join15 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
-  const cmd = new Command53("info").description("Show jai1-client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
+  const cmd = new Command54("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;
@@ -12115,7 +12763,7 @@ async function handleInfo(options) {
   if (!config) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
   }
-  const frameworkPath = join14(homedir5(), ".jai1", "framework");
+  const frameworkPath = join15(homedir5(), ".jai1", "framework");
   const projectStatus = await getProjectStatus2();
   const info = {
     configPath: configService.getConfigPath(),
@@ -12150,9 +12798,9 @@ function maskKey3(key) {
   return "****" + key.slice(-4);
 }
 async function getProjectStatus2() {
-  const projectJai1 = join14(process.cwd(), ".jai1");
+  const projectJai1 = join15(process.cwd(), ".jai1");
   try {
-    await fs19.access(projectJai1);
+    await fs21.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -12160,8 +12808,8 @@ async function getProjectStatus2() {
 }
 
 // src/commands/self-update.ts
-import { Command as Command54 } from "commander";
-import { confirm as confirm12 } from "@inquirer/prompts";
+import { Command as Command55 } from "commander";
+import { confirm as confirm13 } from "@inquirer/prompts";
 import { execSync as execSync3 } from "child_process";
 var colors4 = {
   yellow: "\x1B[33m",
@@ -12172,7 +12820,7 @@ var colors4 = {
   bold: "\x1B[1m"
 };
 function createSelfUpdateCommand() {
-  return new Command54("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 Command55("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);
   });
 }
@@ -12216,7 +12864,7 @@ ${colors4.bold}Current version:${colors4.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm12({
+      const shouldUpdate = await confirm13({
         message: "Update to the latest version now?",
         default: true
       });
@@ -12312,10 +12960,10 @@ function getInstallCommand2(packageManager2) {
 }
 
 // src/commands/clear-backups.ts
-import { Command as Command55 } from "commander";
-import { confirm as confirm13 } from "@inquirer/prompts";
+import { Command as Command56 } from "commander";
+import { confirm as confirm14 } from "@inquirer/prompts";
 function createClearBackupsCommand() {
-  return new Command55("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command56("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) {
@@ -12331,7 +12979,7 @@ function createClearBackupsCommand() {
     }
     console.log();
     if (!options.yes) {
-      const ok = await confirm13({ message: "Delete all backups?", default: false });
+      const ok = await confirm14({ message: "Delete all backups?", default: false });
       if (!ok) return;
     }
     await service.clearBackups(process.cwd());
@@ -12340,10 +12988,10 @@ function createClearBackupsCommand() {
 }
 
 // src/commands/vscode/index.ts
-import { Command as Command56 } from "commander";
-import { checkbox as checkbox7, confirm as confirm14, select as select7 } from "@inquirer/prompts";
-import fs20 from "fs/promises";
-import path8 from "path";
+import { Command as Command57 } from "commander";
+import { checkbox as checkbox7, confirm as confirm15, select as select8 } from "@inquirer/prompts";
+import fs22 from "fs/promises";
+import path9 from "path";
 import { existsSync as existsSync3 } from "fs";
 var PERFORMANCE_GROUPS2 = {
   telemetry: {
@@ -12480,7 +13128,7 @@ var PERFORMANCE_GROUPS2 = {
   }
 };
 function createVSCodeCommand() {
-  const vscodeCommand = new Command56("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
+  const vscodeCommand = new Command57("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
   vscodeCommand.action(async () => {
     await interactiveMode2();
   });
@@ -12524,7 +13172,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 select7({
+  const action = await select8({
     message: "B\u1EA1n mu\u1ED1n l\xE0m g\xEC?",
     choices: [
       { name: "\u2705 Enable c\xE1c nh\xF3m t\u1ED1i \u01B0u", value: "enable" },
@@ -12563,8 +13211,8 @@ async function selectGroupsToApply2(action) {
   }
 }
 async function applyGroups2(groupKeys, action) {
-  const vscodeDir = path8.join(process.cwd(), ".vscode");
-  const settingsPath = path8.join(vscodeDir, "settings.json");
+  const vscodeDir = path9.join(process.cwd(), ".vscode");
+  const settingsPath = path9.join(vscodeDir, "settings.json");
   const invalidGroups = groupKeys.filter((key) => !PERFORMANCE_GROUPS2[key]);
   if (invalidGroups.length > 0) {
     console.log(`
@@ -12573,18 +13221,18 @@ async function applyGroups2(groupKeys, action) {
     return;
   }
   if (!existsSync3(vscodeDir)) {
-    await fs20.mkdir(vscodeDir, { recursive: true });
+    await fs22.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 fs20.readFile(settingsPath, "utf-8");
+      const content = await fs22.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 confirm14({
+      const confirmOverwrite = await confirm15({
         message: "Ghi \u0111\xE8 file settings.json hi\u1EC7n t\u1EA1i?",
         default: false
       });
@@ -12619,19 +13267,19 @@ async function applyGroups2(groupKeys, action) {
       }
     }
   }
-  await fs20.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+  await fs22.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.");
 }
 async function resetSettings2(groupKeys) {
-  const vscodeDir = path8.join(process.cwd(), ".vscode");
-  const settingsPath = path8.join(vscodeDir, "settings.json");
+  const vscodeDir = path9.join(process.cwd(), ".vscode");
+  const settingsPath = path9.join(vscodeDir, "settings.json");
   if (!existsSync3(settingsPath)) {
     console.log("\n\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y file settings.json");
     return;
   }
-  const confirmReset = await confirm14({
+  const confirmReset = await confirm15({
     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
   });
@@ -12640,7 +13288,7 @@ async function resetSettings2(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs20.unlink(settingsPath);
+    await fs22.unlink(settingsPath);
     console.log("\n\u2705 \u0110\xE3 x\xF3a file settings.json");
   } else {
     await applyGroups2(groupKeys, "disable");
@@ -12651,9 +13299,9 @@ async function resetSettings2(groupKeys) {
 // src/commands/guide.ts
 import React40 from "react";
 import { render as render6 } from "ink";
-import { Command as Command57 } from "commander";
+import { Command as Command58 } from "commander";
 function createGuideCommand() {
-  const cmd = new Command57("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 Command58("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,
@@ -12670,9 +13318,9 @@ function createGuideCommand() {
 // src/commands/context.ts
 import React41 from "react";
 import { render as render7 } from "ink";
-import { Command as Command58 } from "commander";
+import { Command as Command59 } from "commander";
 function createContextCommand() {
-  const cmd = new Command58("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 Command59("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"];
@@ -12749,10 +13397,10 @@ async function printStats2() {
 }
 
 // src/commands/migrate-ide.ts
-import { Command as Command59 } from "commander";
-import { checkbox as checkbox8, confirm as confirm15 } from "@inquirer/prompts";
+import { Command as Command60 } from "commander";
+import { checkbox as checkbox8, confirm as confirm16 } from "@inquirer/prompts";
 function createMigrateIdeCommand() {
-  const cmd = new Command59("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 Command60("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;
@@ -12821,7 +13469,7 @@ async function runMigrateIde(options) {
   if (options.dryRun) {
     console.log("\u{1F50D} DRY RUN - No files will be written\n");
   }
-  const confirmed = await confirm15({
+  const confirmed = await confirm16({
     message: "Proceed with migration?",
     default: true
   });
@@ -12858,7 +13506,7 @@ async function runMigrateIde(options) {
 }
 
 // src/cli.ts
-var program = new Command60();
+var program = new Command61();
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
   console.log(package_default.version);
   if (!process.argv.includes("--skip-update-check")) {
@@ -12880,15 +13528,16 @@ program.addCommand(createOpenAiKeysCommand());
 program.addCommand(createStatsCommand());
 program.addCommand(createTranslateCommand());
 program.addCommand(createImageCommand());
+program.addCommand(createFeedbackCommand());
 program.addCommand(createUtilsCommand());
 program.addCommand(createDepsCommand());
 program.addCommand(createKitCommand());
 program.addCommand(createRulesCommand());
 program.addCommand(createUpgradeCommand());
 program.addCommand(createCleanCommand());
-var redmineCommand = new Command60("redmine").description("Redmine context sync commands");
+var redmineCommand = new Command61("redmine").description("Redmine context sync commands");
 redmineCommand.addCommand(createRedmineCheckCommand());
-var syncCommand = new Command60("sync").description("Sync Redmine issues to markdown files");
+var syncCommand = new Command61("sync").description("Sync Redmine issues to markdown files");
 syncCommand.addCommand(createSyncIssueCommand());
 syncCommand.addCommand(createSyncProjectCommand());
 redmineCommand.addCommand(syncCommand);