@jvittechs/jai1-cli 0.1.100 → 0.1.102

package/dist/cli.js

@@ -33,7 +33,7 @@ var NetworkError = class extends Jai1Error {
 // package.json
 var package_default = {
   name: "@jvittechs/jai1-cli",
-  version: "0.1.100",
+  version: "0.1.102",
   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",
@@ -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;
@@ -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"];
@@ -5812,7 +6245,7 @@ var TranslationService = class {
    */
   async detectInputType(input5) {
     try {
-      const stat = await fs9.stat(input5);
+      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);
@@ -6432,7 +6865,7 @@ function createImageCommand() {
 import { Command as Command21 } from "commander";
 import { select as select2, input, confirm as confirm5 } from "@inquirer/prompts";
 import os from "os";
-import { promises as fs10 } from "fs";
+import { promises as fs11 } from "fs";
 import { join as join5 } from "path";
 async function collectContext() {
   const context = {
@@ -6440,12 +6873,12 @@ async function collectContext() {
   };
   try {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const packageJson = JSON.parse(await fs10.readFile(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(await fs11.readFile(packageJsonPath, "utf-8"));
     context.cli_version = packageJson.version;
   } catch {
   }
   try {
-    const projectPackageJson = await fs10.readFile(join5(process.cwd(), "package.json"), "utf-8");
+    const projectPackageJson = await fs11.readFile(join5(process.cwd(), "package.json"), "utf-8");
     const projectData = JSON.parse(projectPackageJson);
     context.project_name = projectData.name;
   } catch {
@@ -6516,11 +6949,7 @@ async function handleInteractiveFeedback(config) {
       return true;
     }
   });
-  const includeContext = await confirm5({
-    message: "Include system context (OS, CLI version)?",
-    default: true
-  });
-  const context = includeContext ? await collectContext() : void 0;
+  const context = await collectContext();
   console.log("\n\u{1F4CB} Summary:\n");
   console.log(`Type:        ${type}`);
   console.log(`Title:       ${title}`);
@@ -8701,8 +9130,8 @@ 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 fs11 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("");
@@ -8722,12 +9151,12 @@ var MarkdownView = () => {
     }
     try {
       setError("");
-      const resolvedPath = path6.resolve(filePath);
-      if (!fs11.existsSync(resolvedPath)) {
+      const resolvedPath = path7.resolve(filePath);
+      if (!fs12.existsSync(resolvedPath)) {
         setError(`File not found: ${resolvedPath}`);
         return;
       }
-      let fileContent = fs11.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**
@@ -9008,8 +9437,8 @@ import { Command as Command36 } from "commander";
 import { checkbox as checkbox3, confirm as confirm6 } from "@inquirer/prompts";
 
 // src/services/deps.service.ts
-import { promises as fs12 } 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 {
@@ -9018,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 fs12.readFile(pkgPath, "utf-8");
+      const content = await fs13.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -9126,7 +9555,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs12.access(path7.join(cwd, file));
+        await fs13.access(path8.join(cwd, file));
         return pm;
       } catch {
       }
@@ -9410,7 +9839,7 @@ import { Command as Command41 } from "commander";
 import { Command as Command38 } from "commander";
 
 // src/services/starter-kit.service.ts
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 import { join as join6 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
@@ -9459,16 +9888,16 @@ var StarterKitService = class {
     }
     if (onProgress) onProgress(30);
     const tmpDir = join6(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs13.mkdir(tmpDir, { recursive: true });
+    await fs14.mkdir(tmpDir, { recursive: true });
     const tmpFile = join6(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs13.writeFile(tmpFile, Buffer.from(buffer));
+    await fs14.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs13.mkdir(targetDir, { recursive: true });
+    await fs14.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs13.unlink(tmpFile);
+    await fs14.unlink(tmpFile);
   }
 };
 
@@ -9563,7 +9992,7 @@ Post-Init Commands:`);
 
 // src/commands/kit/create.ts
 import { Command as Command40 } from "commander";
-import { promises as fs14 } from "fs";
+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";
@@ -9629,7 +10058,7 @@ function createKitCreateCommand() {
     }
     const targetDir = directory || join7(process.cwd(), options.name || slug);
     try {
-      await fs14.access(targetDir);
+      await fs15.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -9747,7 +10176,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs14.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");
@@ -9757,13 +10186,13 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs14.writeFile(file, content, "utf-8");
+      await fs15.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs14.readdir(dir, { withFileTypes: true });
+  const entries = await fs15.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join7(dir, entry.name);
     if (entry.isDirectory()) {
@@ -9850,7 +10279,7 @@ function createRulesListCommand() {
 
 // src/commands/rules/init.ts
 import { Command as Command43 } from "commander";
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 import { join as join8 } from "path";
 import { select as select4, confirm as confirm7 } from "@inquirer/prompts";
 function createRulesInitCommand() {
@@ -9936,7 +10365,7 @@ function createRulesInitCommand() {
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
       customContext: "09-custom.mdc"
     };
-    await fs15.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:");
@@ -9947,10 +10376,10 @@ function createRulesInitCommand() {
 }
 async function applyCursorFormat(bundle) {
   const rulesDir = join8(process.cwd(), ".cursor", "rules");
-  await fs15.mkdir(rulesDir, { recursive: true });
+  await fs16.mkdir(rulesDir, { recursive: true });
   for (const [filename, content] of Object.entries(bundle.files)) {
     const filePath = join8(rulesDir, filename);
-    await fs15.writeFile(filePath, content, "utf-8");
+    await fs16.writeFile(filePath, content, "utf-8");
     console.log(`\u2713 Created .cursor/rules/${filename}`);
   }
 }
@@ -9977,13 +10406,13 @@ async function applyAgentsMdFormat(bundle) {
     }
   }
   const agentsMd = sections.join("\n");
-  await fs15.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 Command44 } from "commander";
-import { promises as fs17 } from "fs";
+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";
 
@@ -10344,7 +10773,7 @@ Follow all instructions and patterns defined in AGENTS.md above.
 };
 
 // src/services/backup.service.ts
-import { promises as fs16 } from "fs";
+import { promises as fs17 } from "fs";
 import { join as join9, dirname } from "path";
 var BackupService = class {
   backupDir = ".jai1/backups";
@@ -10375,16 +10804,16 @@ var BackupService = class {
           await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
           hasContent = true;
         } else {
-          const stats = await fs16.stat(rulesPath);
+          const stats = await fs17.stat(rulesPath);
           if (stats.isDirectory()) {
-            const files = await fs16.readdir(rulesPath);
+            const files = await fs17.readdir(rulesPath);
             for (const file of files) {
               if (file.endsWith(format.fileExtension)) {
                 const originalPath = join9(rulesPath, file);
                 const relativePath = join9(format.rulesPath, file);
                 const destPath = join9(backupPath, ideId, file);
-                await fs16.mkdir(dirname(destPath), { recursive: true });
-                await fs16.copyFile(originalPath, destPath);
+                await fs17.mkdir(dirname(destPath), { recursive: true });
+                await fs17.copyFile(originalPath, destPath);
                 backedUpFiles.push({
                   originalPath: relativePath,
                   backupPath: join9(ideId, file),
@@ -10408,8 +10837,8 @@ var BackupService = class {
       ides,
       files: backedUpFiles
     };
-    await fs16.mkdir(backupPath, { recursive: true });
-    await fs16.writeFile(
+    await fs17.mkdir(backupPath, { recursive: true });
+    await fs17.writeFile(
       join9(backupPath, "metadata.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
@@ -10427,8 +10856,8 @@ var BackupService = class {
         return;
       }
       const destPath = join9(backupPath, ideId, filename);
-      await fs16.mkdir(dirname(destPath), { recursive: true });
-      await fs16.copyFile(originalPath, destPath);
+      await fs17.mkdir(dirname(destPath), { recursive: true });
+      await fs17.copyFile(originalPath, destPath);
       backedUpFiles.push({
         originalPath: filename,
         backupPath: join9(ideId, filename),
@@ -10442,15 +10871,15 @@ var BackupService = class {
    */
   async restoreBackup(backupPath) {
     const metadataPath = join9(backupPath, "metadata.json");
-    const metadataContent = await fs16.readFile(metadataPath, "utf-8");
+    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 = join9(backupPath, file.backupPath);
       const destPath = join9(process.cwd(), file.originalPath);
-      await fs16.mkdir(dirname(destPath), { recursive: true });
-      await fs16.copyFile(sourcePath, destPath);
+      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!");
@@ -10465,13 +10894,13 @@ Restoring backup from ${metadata.timestamp}...`);
       if (!exists) {
         return [];
       }
-      const entries = await fs16.readdir(backupDirPath, { withFileTypes: true });
+      const entries = await fs17.readdir(backupDirPath, { withFileTypes: true });
       const backups = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const metadataPath = join9(backupDirPath, entry.name, "metadata.json");
           try {
-            const metadataContent = await fs16.readFile(metadataPath, "utf-8");
+            const metadataContent = await fs17.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(metadataContent);
             backups.push(metadata);
           } catch {
@@ -10518,9 +10947,9 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Check if a path exists
    */
-  async pathExists(path9) {
+  async pathExists(path10) {
     try {
-      await fs16.access(path9);
+      await fs17.access(path10);
       return true;
     } catch {
       return false;
@@ -10529,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 fs16.readdir(path9, { withFileTypes: true });
+      const entries = await fs17.readdir(path10, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join9(path9, entry.name);
+        const fullPath = join9(path10, entry.name);
         if (entry.isDirectory()) {
           await this.deleteDirectory(fullPath);
         } else {
-          await fs16.unlink(fullPath);
+          await fs17.unlink(fullPath);
         }
       }
-      await fs16.rmdir(path9);
+      await fs17.rmdir(path10);
     } catch (error) {
     }
   }
@@ -10559,7 +10988,7 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async ensureBackupDir() {
     const backupDirPath = join9(process.cwd(), this.backupDir);
-    await fs16.mkdir(backupDirPath, { recursive: true });
+    await fs17.mkdir(backupDirPath, { recursive: true });
   }
 };
 
@@ -10717,19 +11146,19 @@ function createRulesApplyCommand() {
     console.log("\n\u{1F4DD} Applying preset...\n");
     const rulePresetDir = join10(process.cwd(), ".jai1", "rule-preset");
     try {
-      await fs17.rm(rulePresetDir, { recursive: true, force: true });
+      await fs18.rm(rulePresetDir, { recursive: true, force: true });
     } catch {
     }
-    await fs17.mkdir(rulePresetDir, { recursive: true });
-    await fs17.writeFile(
+    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 = join10(rulePresetDir, filename);
-      await fs17.mkdir(join10(filePath, ".."), { recursive: true });
-      await fs17.writeFile(filePath, content, "utf-8");
+      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 = [];
@@ -10738,8 +11167,8 @@ function createRulesApplyCommand() {
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
           const fullPath = join10(process.cwd(), file.path);
-          await fs17.mkdir(join10(fullPath, ".."), { recursive: true });
-          await fs17.writeFile(fullPath, file.content, "utf-8");
+          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,
@@ -10767,7 +11196,7 @@ function createRulesApplyCommand() {
     };
     try {
       const existingConfigPath = join10(process.cwd(), "jai1-rules.json");
-      const existingConfigContent = await fs17.readFile(existingConfigPath, "utf-8");
+      const existingConfigContent = await fs18.readFile(existingConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingConfigContent);
       if (existingConfig.backups && existingConfig.backups.length > 0) {
         projectConfig.backups = [
@@ -10778,7 +11207,7 @@ function createRulesApplyCommand() {
       }
     } catch {
     }
-    await fs17.writeFile(
+    await fs18.writeFile(
       join10(process.cwd(), "jai1-rules.json"),
       JSON.stringify(projectConfig, null, 2),
       "utf-8"
@@ -10883,7 +11312,7 @@ function formatTimestamp(timestamp) {
 
 // src/commands/rules/sync.ts
 import { Command as Command46 } from "commander";
-import { promises as fs18 } from "fs";
+import { promises as fs19 } from "fs";
 import { join as join12 } from "path";
 import { confirm as confirm10 } from "@inquirer/prompts";
 function createRulesSyncCommand() {
@@ -10891,7 +11320,7 @@ function createRulesSyncCommand() {
     const configPath = join12(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs18.readFile(configPath, "utf-8");
+      const configContent = await fs19.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -10974,11 +11403,11 @@ Detected ${detected.length} active IDE(s):
     const rulePresetDir = join12(process.cwd(), ".jai1", "rule-preset");
     const presetExists = await checkPathExists(rulePresetDir);
     if (presetExists) {
-      const files = await fs18.readdir(rulePresetDir);
+      const files = await fs19.readdir(rulePresetDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
           const filePath = join12(rulePresetDir, file);
-          const content = await fs18.readFile(filePath, "utf-8");
+          const content = await fs19.readFile(filePath, "utf-8");
           bundle.files[file] = content;
         }
       }
@@ -10998,8 +11427,8 @@ Detected ${detected.length} active IDE(s):
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
           const fullPath = join12(process.cwd(), file.path);
-          await fs18.mkdir(join12(fullPath, ".."), { recursive: true });
-          await fs18.writeFile(fullPath, file.content, "utf-8");
+          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) {
@@ -11008,7 +11437,7 @@ Detected ${detected.length} active IDE(s):
     }
     if (JSON.stringify(projectConfig.ides) !== JSON.stringify(idesToSync)) {
       projectConfig.ides = idesToSync;
-      await fs18.writeFile(
+      await fs19.writeFile(
         join12(process.cwd(), "jai1-rules.json"),
         JSON.stringify(projectConfig, null, 2),
         "utf-8"
@@ -11024,7 +11453,7 @@ Detected ${detected.length} active IDE(s):
 }
 async function checkPathExists(absolutePath) {
   try {
-    await fs18.access(absolutePath);
+    await fs19.access(absolutePath);
     return true;
   } catch {
     return false;
@@ -11033,14 +11462,14 @@ async function checkPathExists(absolutePath) {
 
 // src/commands/rules/info.ts
 import { Command as Command47 } from "commander";
-import { promises as fs19 } from "fs";
+import { promises as fs20 } from "fs";
 import { join as join13 } from "path";
 function createRulesInfoCommand() {
   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 fs19.readFile(configPath, "utf-8");
+      const configContent = await fs20.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -11057,9 +11486,9 @@ function createRulesInfoCommand() {
     let presetMetadata = null;
     let presetFiles = [];
     try {
-      const presetContent = await fs19.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs20.readFile(presetJsonPath, "utf-8");
       presetMetadata = JSON.parse(presetContent);
-      const files = await fs19.readdir(rulePresetDir);
+      const files = await fs20.readdir(rulePresetDir);
       presetFiles = files.filter((f) => f.endsWith(".mdc"));
     } catch {
     }
@@ -11118,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 fs19.access(join13(process.cwd(), path9));
+    await fs20.access(join13(process.cwd(), path10));
     return true;
   } catch {
     return false;
@@ -11551,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",
@@ -11613,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();
@@ -11634,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;
@@ -12319,7 +12748,7 @@ async function handleSyncProject(options) {
 
 // src/commands/framework/info.ts
 import { Command as Command54 } from "commander";
-import { promises as fs20 } from "fs";
+import { promises as fs21 } from "fs";
 import { join as join15 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
@@ -12371,7 +12800,7 @@ function maskKey3(key) {
 async function getProjectStatus2() {
   const projectJai1 = join15(process.cwd(), ".jai1");
   try {
-    await fs20.access(projectJai1);
+    await fs21.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -12561,8 +12990,8 @@ function createClearBackupsCommand() {
 // src/commands/vscode/index.ts
 import { Command as Command57 } from "commander";
 import { checkbox as checkbox7, confirm as confirm15, select as select8 } from "@inquirer/prompts";
-import fs21 from "fs/promises";
-import path8 from "path";
+import fs22 from "fs/promises";
+import path9 from "path";
 import { existsSync as existsSync3 } from "fs";
 var PERFORMANCE_GROUPS2 = {
   telemetry: {
@@ -12782,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(`
@@ -12792,13 +13221,13 @@ async function applyGroups2(groupKeys, action) {
     return;
   }
   if (!existsSync3(vscodeDir)) {
-    await fs21.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 fs21.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 {
@@ -12838,14 +13267,14 @@ async function applyGroups2(groupKeys, action) {
       }
     }
   }
-  await fs21.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;
@@ -12859,7 +13288,7 @@ async function resetSettings2(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs21.unlink(settingsPath);
+    await fs22.unlink(settingsPath);
     console.log("\n\u2705 \u0110\xE3 x\xF3a file settings.json");
   } else {
     await applyGroups2(groupKeys, "disable");