@jvittechs/jai1-cli 0.1.104 → 0.1.106

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.104",
+  version: "0.1.106",
   description: "A unified CLI tool for JV-IT TECHS developers to manage Jai1 Framework. Please contact TeamAI for usage instructions.",
   type: "module",
   bin: {
@@ -101,6 +101,7 @@ var package_default = {
     marked: "^12.0.0",
     "marked-terminal": "^7.0.0",
     open: "^10.1.0",
+    ora: "^9.0.0",
     "p-limit": "^5.0.0",
     "p-queue": "^7.4.1",
     "p-retry": "^6.2.0",
@@ -3507,9 +3508,9 @@ var IdeDetectionService = class {
   /**
    * Check if a path exists
    */
-  async pathExists(path10) {
+  async pathExists(path13) {
     try {
-      await fs7.access(path10);
+      await fs7.access(path13);
       return true;
     } catch {
       return false;
@@ -4401,6 +4402,27 @@ AI: \u0110\u1ECDc rules \u2192 Bi\u1EBFt d\xF9ng HonoJS, c\u1EA5u tr\xFAc th\u01
 
 > \u{1F4A1} **Tip:** Context l\xE0 ch\xECa kh\xF3a \u0111\u1EC3 AI l\xE0m vi\u1EC7c hi\u1EC7u qu\u1EA3!
 
+## Y\xEAu c\u1EA7u m\xF4i tr\u01B0\u1EDDng
+
+### Windows
+
+\u26A0\uFE0F **B\u1EAFt bu\u1ED9c:** C\xE0i \u0111\u1EB7t **Git for Windows** (bao g\u1ED3m Git Bash)
+
+Workflows c\u1EE7a Jai1 s\u1EED d\u1EE5ng c\xE1c Unix commands (\`grep\`, \`wc\`, \`xargs\`...) kh\xF4ng c\xF3 s\u1EB5n tr\xEAn PowerShell/CMD.
+
+1. Download: https://git-scm.com/download/win
+2. Khi c\xE0i \u0111\u1EB7t, ch\u1ECDn **"Git Bash Here"** context menu
+3. Trong VSCode, c\u1EA5u h\xECnh terminal m\u1EB7c \u0111\u1ECBnh:
+   \`\`\`json
+   {
+     "terminal.integrated.defaultProfile.windows": "Git Bash"
+   }
+   \`\`\`
+
+### macOS / Linux
+
+\u2705 S\u1EB5n s\xE0ng - C\xE1c Unix commands \u0111\xE3 c\xF3 s\u1EB5n trong terminal.
+
 ## B\u1EAFt \u0111\u1EA7u nhanh
 
 1. **Kh\u1EDFi t\u1EA1o Jai1** trong d\u1EF1 \xE1n:
@@ -4598,6 +4620,52 @@ V\xED d\u1EE5 minh h\u1ECDa (n\u1EBFu c\u1EA7n)
 - G\u1ECDi khi c\u1EA7n b\u1EB1ng \`@ruleName\`
 - V\xED d\u1EE5: \`@database-migration\`, \`@api-design\`
 
+## Qu\u1EA3n l\xFD Rules v\u1EDBi CLI
+
+### Apply Rules Preset
+
+\`\`\`bash
+# Apply preset c\xF3 s\u1EB5n
+jai1 rules apply nextjs-saas
+
+# Apply cho nhi\u1EC1u IDE c\xF9ng l\xFAc
+jai1 rules apply nextjs-saas --ides cursor,windsurf,agentsmd
+\`\`\`
+
+### Sync Rules (NEW!)
+
+Sau khi apply rules, b\u1EA1n c\xF3 th\u1EC3 sync sang IDE kh\xE1c ho\u1EB7c regenerate:
+
+\`\`\`bash
+# Interactive mode - ch\u1ECDn IDE t\u1EEB menu
+jai1 rules sync
+
+# Auto-detect active IDEs
+jai1 rules sync --detect
+
+# Sync specific IDEs
+jai1 rules sync --ides cursor,windsurf
+
+# Auto mode (no prompts)
+jai1 rules sync -y
+\`\`\`
+
+**Interactive Mode Flow:**
+1. Hi\u1EC3n th\u1ECB current IDE configuration
+2. Smart suggestions d\u1EF1a tr\xEAn project structure
+3. Checkbox \u0111\u1EC3 ch\u1ECDn IDE (pre-selected current + suggested)
+4. Regenerate rules cho c\xE1c IDE \u0111\xE3 ch\u1ECDn
+
+### Restore Rules
+
+\`\`\`bash
+# List available backups
+jai1 rules restore --list
+
+# Restore from backup
+jai1 rules restore
+\`\`\`
+
 ## Best Practices
 
 ### \u2705 N\xCAN l\xE0m:
@@ -4606,6 +4674,8 @@ V\xED d\u1EE5 minh h\u1ECDa (n\u1EBFu c\u1EA7n)
 - Focus v\xE0o "what to do", kh\xF4ng ph\u1EA3i "how to do"
 - C\u1EADp nh\u1EADt rules khi d\u1EF1 \xE1n thay \u0111\u1ED5i
 - Chia nh\u1ECF rules theo domain/feature
+- Edit rules trong \`.jai1/rule-preset/\` (source of truth)
+- Ch\u1EA1y \`jai1 rules sync\` sau khi edit \u0111\u1EC3 regenerate
 
 ### \u274C KH\xD4NG N\xCAN:
 
@@ -4613,8 +4683,9 @@ V\xED d\u1EE5 minh h\u1ECDa (n\u1EBFu c\u1EA7n)
 - Copy-paste to\xE0n b\u1ED9 documentation
 - Include code examples qu\xE1 chi ti\u1EBFt
 - Hardcode paths ho\u1EB7c values
+- Edit tr\u1EF1c ti\u1EBFp trong \`.cursor/rules/\` (s\u1EBD b\u1ECB overwrite khi sync)
 
-> \u{1F4A1} **Tip:** D\xF9ng \`jai1 apply rules/...\` \u0111\u1EC3 c\xE0i \u0111\u1EB7t rules m\u1EABu cho tech stack c\u1EE7a b\u1EA1n!
+> \u{1F4A1} **Tip:** D\xF9ng \`jai1 rules apply\` \u0111\u1EC3 c\xE0i \u0111\u1EB7t rules m\u1EABu cho tech stack c\u1EE7a b\u1EA1n!
 `,
   "skills": `---
 title: Skills
@@ -4743,7 +4814,7 @@ D\xF9ng workflow \`skill-creator\`:
   "workflows": `---
 title: Workflows
 icon: \u{1F504}
-description: Quy tr\xECnh l\xE0m vi\u1EC7c step-by-step (Cursor: Commands)
+description: "Quy tr\xECnh l\xE0m vi\u1EC7c step-by-step (Cursor: Commands)"
 ---
 
 # Workflows - Quy tr\xECnh l\xE0m vi\u1EC7c
@@ -10293,27 +10364,147 @@ function createUtilsCommand() {
 }
 
 // src/commands/deps/index.ts
-import { Command as Command37 } from "commander";
-import chalk11 from "chalk";
+import { Command as Command38 } from "commander";
+import chalk13 from "chalk";
 
-// src/commands/deps/upgrade.ts
+// src/commands/deps/check.ts
 import { Command as Command36 } from "commander";
-import { checkbox as checkbox3, confirm as confirm6 } from "@inquirer/prompts";
+import chalk11 from "chalk";
+import Table3 from "cli-table3";
+import ora from "ora";
+
+// src/services/deps-detector.service.ts
+import * as fs13 from "fs/promises";
+import * as path8 from "path";
+var DepsDetectorService = class {
+  /**
+   * Detect all project types in the given directory
+   */
+  async detectProjects(cwd) {
+    const projects = [];
+    if (await this.fileExists(cwd, "package.json")) {
+      const manager = await this.detectNodePackageManager(cwd);
+      projects.push({
+        ecosystem: "node",
+        manager,
+        configFile: "package.json"
+      });
+    }
+    if (await this.fileExists(cwd, "composer.json") || await this.fileExists(cwd, "composer.lock")) {
+      const isLaravel = await this.detectLaravel(cwd);
+      projects.push({
+        ecosystem: "php",
+        manager: "composer",
+        isLaravel,
+        configFile: "composer.json"
+      });
+    }
+    if (await this.fileExists(cwd, "Pipfile")) {
+      projects.push({
+        ecosystem: "python",
+        manager: "pipenv",
+        configFile: "Pipfile"
+      });
+    } else if (await this.fileExists(cwd, "requirements.txt")) {
+      projects.push({
+        ecosystem: "python",
+        manager: "pip",
+        configFile: "requirements.txt"
+      });
+    }
+    return projects;
+  }
+  /**
+   * Detect Node.js package manager
+   */
+  async detectNodePackageManager(cwd) {
+    if (await this.fileExists(cwd, "pnpm-lock.yaml")) {
+      return "pnpm";
+    }
+    if (await this.fileExists(cwd, "yarn.lock")) {
+      return "yarn";
+    }
+    if (await this.fileExists(cwd, "bun.lockb")) {
+      return "bun";
+    }
+    if (await this.fileExists(cwd, "package-lock.json")) {
+      return "npm";
+    }
+    const userAgent = process.env.npm_config_user_agent || "";
+    if (userAgent.includes("pnpm")) return "pnpm";
+    if (userAgent.includes("yarn")) return "yarn";
+    if (userAgent.includes("bun")) return "bun";
+    return "npm";
+  }
+  /**
+   * Detect if project is Laravel
+   */
+  async detectLaravel(cwd) {
+    try {
+      const composerPath = path8.join(cwd, "composer.json");
+      const content = await fs13.readFile(composerPath, "utf-8");
+      const composerJson = JSON.parse(content);
+      const deps = {
+        ...composerJson.require,
+        ...composerJson["require-dev"]
+      };
+      return "laravel/framework" in deps;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Check if file exists
+   */
+  async fileExists(cwd, filename) {
+    try {
+      await fs13.access(path8.join(cwd, filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
 
 // src/services/deps.service.ts
-import { promises as fs13 } from "fs";
-import path8 from "path";
+import { promises as fs14 } from "fs";
+import path9 from "path";
 import { execSync } from "child_process";
 import pLimit2 from "p-limit";
 var DepsService = class {
+  ecosystem = "node";
   versionCache = /* @__PURE__ */ new Map();
-  /**
-   * Đọc package.json từ thư mục
-   */
+  async check(cwd, onProgress) {
+    const pkgJson = await this.readPackageJson(cwd);
+    const manager = await this.detectPackageManager(cwd);
+    const packages = [];
+    if (pkgJson.dependencies) {
+      for (const [name, version] of Object.entries(pkgJson.dependencies)) {
+        if (this.isValidNpmDependency(version)) {
+          packages.push({ name, current: version, type: "dep" });
+        }
+      }
+    }
+    if (pkgJson.devDependencies) {
+      for (const [name, version] of Object.entries(pkgJson.devDependencies)) {
+        if (this.isValidNpmDependency(version)) {
+          packages.push({ name, current: version, type: "dev" });
+        }
+      }
+    }
+    const upgradablePackages = await this.fetchBulkVersions(packages, onProgress);
+    return { ecosystem: this.ecosystem, manager, packages: upgradablePackages };
+  }
+  async upgrade(cwd, options) {
+    const manager = await this.detectPackageManager(cwd);
+    const commands = this.buildUpgradeCommands(options.packages, manager);
+    if (commands.deps) this.executeUpgrade(commands.deps);
+    if (commands.devDeps) this.executeUpgrade(commands.devDeps);
+  }
   async readPackageJson(cwd) {
-    const pkgPath = path8.join(cwd, "package.json");
+    const pkgPath = path9.join(cwd, "package.json");
     try {
-      const content = await fs13.readFile(pkgPath, "utf-8");
+      const content = await fs14.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -10322,9 +10513,6 @@ var DepsService = class {
       throw new Error(`L\u1ED7i \u0111\u1ECDc package.json: ${error.message}`);
     }
   }
-  /**
-   * Lấy version mới nhất từ npm registry
-   */
   async fetchLatestVersion(packageName) {
     if (this.versionCache.has(packageName)) {
       return this.versionCache.get(packageName);
@@ -10334,9 +10522,7 @@ var DepsService = class {
         `https://registry.npmjs.org/${encodeURIComponent(packageName)}/latest`,
         { signal: AbortSignal.timeout(1e4) }
       );
-      if (!response.ok) {
-        return null;
-      }
+      if (!response.ok) return null;
       const data = await response.json();
       this.versionCache.set(packageName, data.version);
       return data.version;
@@ -10344,54 +10530,51 @@ var DepsService = class {
       return null;
     }
   }
-  /**
-   * Fetch nhiều packages cùng lúc với giới hạn concurrent
-   */
   async fetchBulkVersions(packages, onProgress) {
     const limit = pLimit2(10);
     const total = packages.length;
     let completed = 0;
     const results = await Promise.all(
-      packages.map(
-        (pkg) => limit(async () => {
-          const latest = await this.fetchLatestVersion(pkg.name);
-          completed++;
-          onProgress?.(completed, total);
-          if (!latest) {
-            return null;
-          }
-          const currentClean = this.stripSemverPrefix(pkg.current);
-          const canUpgrade = this.isNewerVersion(latest, currentClean);
-          return {
-            name: pkg.name,
-            current: pkg.current,
-            latest,
-            latestWithPrefix: this.preserveSemverPrefix(pkg.current, latest),
-            type: pkg.type,
-            canUpgrade
-          };
-        })
-      )
+      packages.map((pkg) => limit(async () => {
+        const latest = await this.fetchLatestVersion(pkg.name);
+        completed++;
+        onProgress?.(completed, total);
+        if (!latest) return null;
+        const currentClean = this.stripSemverPrefix(pkg.current);
+        const canUpgrade = this.isNewerVersion(latest, currentClean);
+        const upgradeType = this.getUpgradeType(currentClean, latest);
+        return {
+          name: pkg.name,
+          current: pkg.current,
+          latest,
+          latestWithPrefix: this.preserveSemverPrefix(pkg.current, latest),
+          type: pkg.type,
+          canUpgrade,
+          upgradeType
+        };
+      }))
     );
     return results.filter((r) => r !== null && r.canUpgrade);
   }
-  /**
-   * Loại bỏ semver prefix (^, ~, >=, etc.)
-   */
+  isValidNpmDependency(version) {
+    const invalidPrefixes = ["git+", "git:", "file:", "link:", "workspace:"];
+    return !invalidPrefixes.some((prefix) => version.startsWith(prefix));
+  }
+  getUpgradeType(current, latest) {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] || 0) > (currentParts[0] || 0)) return "major";
+    if ((latestParts[1] || 0) > (currentParts[1] || 0)) return "minor";
+    return "patch";
+  }
   stripSemverPrefix(version) {
     return version.replace(/^[~^>=<]+/, "");
   }
-  /**
-   * Giữ nguyên semver prefix khi upgrade
-   */
   preserveSemverPrefix(current, latest) {
     const match = current.match(/^([~^>=<]*)/);
     const prefix = match?.[1] || "";
     return prefix + latest;
   }
-  /**
-   * So sánh version để xác định có cần upgrade không
-   */
   isNewerVersion(remote, local) {
     const remoteParts = remote.split(".").map(Number);
     const localParts = local.split(".").map(Number);
@@ -10403,13 +10586,6 @@ var DepsService = class {
     }
     return false;
   }
-  /**
-   * Detect package manager từ lock files
-   * Priority:
-   * 1. Lock file trong project
-   * 2. pnpm nếu có cài đặt trong máy
-   * 3. npm (fallback)
-   */
   async detectPackageManager(cwd) {
     const lockFiles = [
       { file: "pnpm-lock.yaml", pm: "pnpm" },
@@ -10419,7 +10595,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs13.access(path8.join(cwd, file));
+        await fs14.access(path9.join(cwd, file));
         return pm;
       } catch {
       }
@@ -10428,27 +10604,22 @@ var DepsService = class {
     if (userAgent.includes("pnpm")) return "pnpm";
     if (userAgent.includes("yarn")) return "yarn";
     if (userAgent.includes("bun")) return "bun";
-    if (userAgent.includes("npm")) return "npm";
     if (this.isCommandAvailable("pnpm")) return "pnpm";
     return "npm";
   }
-  /**
-   * Kiểm tra command có sẵn trong hệ thống không
-   */
   isCommandAvailable(command) {
     try {
-      execSync(`${command} --version`, {
-        stdio: ["pipe", "pipe", "pipe"]
-      });
+      execSync(`${command} --version`, { stdio: ["pipe", "pipe", "pipe"] });
       return true;
     } catch {
       return false;
     }
   }
-  /**
-   * Tạo command để upgrade packages
-   */
-  getUpgradeCommands(packages, pm) {
+  getUpgradeCommands(packages) {
+    const pm = process.env.npm_config_user_agent?.includes("pnpm") ? "pnpm" : "npm";
+    return this.buildUpgradeCommands(packages, pm);
+  }
+  buildUpgradeCommands(packages, pm) {
     const deps = packages.filter((p) => p.type === "dep");
     const devDeps = packages.filter((p) => p.type === "dev");
     const formatPackages = (pkgs) => pkgs.map((p) => `${p.name}@${p.latestWithPrefix}`).join(" ");
@@ -10488,240 +10659,654 @@ var DepsService = class {
     }
     return { deps: depsCmd, devDeps: devDepsCmd };
   }
-  /**
-   * Thực thi upgrade command
-   */
   executeUpgrade(command) {
-    execSync(command, {
-      stdio: "inherit",
-      env: { ...process.env, FORCE_COLOR: "1" }
-    });
+    execSync(command, { stdio: "inherit", env: { ...process.env, FORCE_COLOR: "1" } });
   }
 };
 
-// src/commands/deps/upgrade.ts
-var colors3 = {
-  yellow: "\x1B[33m",
-  green: "\x1B[32m",
-  cyan: "\x1B[36m",
-  red: "\x1B[31m",
-  gray: "\x1B[90m",
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m"
-};
-function createDepsUpgradeCommand() {
-  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);
-  });
-}
-async function handleDepsUpgrade(options) {
-  const depsService = new DepsService();
-  const cwd = process.cwd();
-  try {
-    console.log(`
-${colors3.cyan}\u{1F50D} \u0110ang \u0111\u1ECDc package.json...${colors3.reset}`);
-    const pkg = await depsService.readPackageJson(cwd);
-    const packagesToCheck = [];
-    if (!options.devOnly && pkg.dependencies) {
-      for (const [name, version] of Object.entries(pkg.dependencies)) {
-        if (isNpmVersion(version)) {
-          packagesToCheck.push({ name, current: version, type: "dep" });
-        }
-      }
+// src/services/deps-php.service.ts
+import { execSync as execSync2 } from "child_process";
+import { promises as fs15 } from "fs";
+import path10 from "path";
+var LARAVEL_PROTECTED_PACKAGES = /^laravel\//;
+var DepsPhpService = class {
+  ecosystem = "php";
+  isLaravel = false;
+  async check(cwd, onProgress) {
+    this.isLaravel = await this.detectLaravel(cwd);
+    const outdated = await this.fetchOutdatedPackages(cwd);
+    const composerJson = await this.readComposerJson(cwd);
+    const packages = [];
+    let processed = 0;
+    for (const pkg of outdated) {
+      const isDev = pkg.name in (composerJson["require-dev"] || {});
+      const upgradeType = this.getUpgradeType(pkg.version, pkg.latest);
+      const canUpgrade = this.canUpgradePackage(pkg.name, upgradeType);
+      const blockedReason = !canUpgrade ? "Laravel major version blocked" : void 0;
+      packages.push({
+        name: pkg.name,
+        current: pkg.version,
+        latest: pkg.latest,
+        latestWithPrefix: pkg.latest,
+        type: isDev ? "dev" : "dep",
+        upgradeType,
+        canUpgrade,
+        blockedReason
+      });
+      processed++;
+      onProgress?.(processed, outdated.length);
     }
-    if (!options.depsOnly && pkg.devDependencies) {
-      for (const [name, version] of Object.entries(pkg.devDependencies)) {
-        if (isNpmVersion(version)) {
-          packagesToCheck.push({ name, current: version, type: "dev" });
-        }
+    return {
+      ecosystem: this.ecosystem,
+      manager: "composer",
+      packages: packages.filter((p) => p.canUpgrade),
+      isLaravel: this.isLaravel
+    };
+  }
+  async upgrade(cwd, options) {
+    const commands = this.getUpgradeCommands(options.packages);
+    if (commands.deps) this.executeUpgrade(commands.deps, cwd);
+    if (commands.devDeps) this.executeUpgrade(commands.devDeps, cwd);
+  }
+  getUpgradeCommands(packages) {
+    const deps = packages.filter((p) => p.type === "dep");
+    const devDeps = packages.filter((p) => p.type === "dev");
+    let depsCmd = null;
+    let devDepsCmd = null;
+    if (deps.length > 0) {
+      const pkgList = deps.map((p) => `${p.name}:${p.latest}`).join(" ");
+      depsCmd = `composer require -W ${pkgList}`;
+    }
+    if (devDeps.length > 0) {
+      const pkgList = devDeps.map((p) => `${p.name}:${p.latest}`).join(" ");
+      devDepsCmd = `composer require --dev -W ${pkgList}`;
+    }
+    return { deps: depsCmd, devDeps: devDepsCmd };
+  }
+  async readComposerJson(cwd) {
+    const composerPath = path10.join(cwd, "composer.json");
+    try {
+      const content = await fs15.readFile(composerPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error("Kh\xF4ng t\xECm th\u1EA5y composer.json trong th\u01B0 m\u1EE5c hi\u1EC7n t\u1EA1i");
       }
+      throw new Error(`L\u1ED7i \u0111\u1ECDc composer.json: ${error.message}`);
     }
-    if (packagesToCheck.length === 0) {
-      console.log(`${colors3.yellow}\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y packages \u0111\u1EC3 ki\u1EC3m tra${colors3.reset}
-`);
-      return;
+  }
+  async detectLaravel(cwd) {
+    try {
+      const composerJson = await this.readComposerJson(cwd);
+      const deps = { ...composerJson.require, ...composerJson["require-dev"] };
+      return "laravel/framework" in deps;
+    } catch {
+      return false;
     }
-    const depsCount = packagesToCheck.filter((p) => p.type === "dep").length;
-    const devCount = packagesToCheck.filter((p) => p.type === "dev").length;
-    console.log(
-      `${colors3.bold}\u{1F4E6} T\xECm th\u1EA5y ${depsCount} dependencies v\xE0 ${devCount} devDependencies${colors3.reset}
-`
-    );
-    console.log(`${colors3.cyan}\u23F3 Ki\u1EC3m tra phi\xEAn b\u1EA3n m\u1EDBi nh\u1EA5t...${colors3.reset}`);
-    const upgradablePackages = await depsService.fetchBulkVersions(
-      packagesToCheck,
-      (completed, total) => {
-        const progress = Math.round(completed / total * 100);
-        const bar = "\u2588".repeat(Math.floor(progress / 5)) + "\u2591".repeat(20 - Math.floor(progress / 5));
-        process.stdout.write(`\r[${bar}] ${completed}/${total} packages`);
+  }
+  async fetchOutdatedPackages(cwd) {
+    try {
+      const output = execSync2("composer outdated --format=json --direct", {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const result = JSON.parse(output);
+      return result.installed || [];
+    } catch (error) {
+      if (error.stdout) {
+        try {
+          const result = JSON.parse(error.stdout);
+          return result.installed || [];
+        } catch {
+        }
       }
-    );
-    console.log("\n");
-    if (upgradablePackages.length === 0) {
-      console.log(`${colors3.green}\u2705 T\u1EA5t c\u1EA3 packages \u0111\xE3 l\xE0 phi\xEAn b\u1EA3n m\u1EDBi nh\u1EA5t!${colors3.reset}
-`);
-      return;
+      throw new Error(`L\u1ED7i ki\u1EC3m tra composer packages: ${error.message}`);
     }
-    displayUpgradeTable(upgradablePackages);
-    if (options.check) {
-      console.log(
-        `${colors3.cyan}\u{1F4A1} Ch\u1EA1y "jai1 deps upgrade" \u0111\u1EC3 ti\u1EBFn h\xE0nh upgrade.${colors3.reset}
-`
-      );
-      return;
+  }
+  getUpgradeType(current, latest) {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] || 0) > (currentParts[0] || 0)) return "major";
+    if ((latestParts[1] || 0) > (currentParts[1] || 0)) return "minor";
+    return "patch";
+  }
+  canUpgradePackage(packageName, upgradeType) {
+    if (this.isLaravel && LARAVEL_PROTECTED_PACKAGES.test(packageName) && upgradeType === "major") {
+      return false;
     }
-    let selectedPackages;
-    if (options.all) {
-      selectedPackages = upgradablePackages;
-      console.log(`${colors3.cyan}\u{1F4CB} \u0110\xE3 ch\u1ECDn t\u1EA5t c\u1EA3 ${selectedPackages.length} packages${colors3.reset}
-`);
+    return true;
+  }
+  executeUpgrade(command, cwd) {
+    execSync2(command, {
+      cwd,
+      stdio: "inherit",
+      env: { ...process.env, FORCE_COLOR: "1" }
+    });
+  }
+};
+
+// src/services/deps-python.service.ts
+import { execSync as execSync3 } from "child_process";
+import { promises as fs16 } from "fs";
+import path11 from "path";
+import pLimit3 from "p-limit";
+var DepsPythonService = class {
+  ecosystem = "python";
+  versionCache = /* @__PURE__ */ new Map();
+  async check(cwd, onProgress) {
+    const manager = await this.detectPackageManager(cwd);
+    let packages;
+    if (manager === "pipenv") {
+      packages = await this.checkPipenv(cwd, onProgress);
     } else {
-      try {
-        const selected = await checkbox3({
-          message: "Ch\u1ECDn packages \u0111\u1EC3 upgrade (ESC \u0111\u1EC3 h\u1EE7y):",
-          choices: upgradablePackages.map((pkg2) => ({
-            name: `${pkg2.name} (${pkg2.current} \u2192 ${pkg2.latestWithPrefix}) [${pkg2.type}]`,
-            value: pkg2.name,
-            checked: true
-            // Mặc định chọn tất cả
-          })),
-          instructions: "\u2191\u2193 navigate \u2022 space select \u2022 a all \u2022 i invert \u2022 \u23CE submit \u2022 esc cancel"
-        });
-        if (selected.length === 0) {
-          console.log(`${colors3.yellow}\u23F8\uFE0F  Kh\xF4ng c\xF3 packages n\xE0o \u0111\u01B0\u1EE3c ch\u1ECDn${colors3.reset}
-`);
-          return;
-        }
-        selectedPackages = upgradablePackages.filter((pkg2) => selected.includes(pkg2.name));
-      } catch {
-        console.log(`
-${colors3.yellow}\u23F8\uFE0F  \u0110\xE3 h\u1EE7y${colors3.reset}
-`);
-        return;
+      packages = await this.checkPip(cwd, onProgress);
+    }
+    return { ecosystem: this.ecosystem, manager, packages };
+  }
+  async upgrade(cwd, options) {
+    const manager = await this.detectPackageManager(cwd);
+    const commands = this.getUpgradeCommands(options.packages);
+    if (manager === "pipenv") {
+      if (commands.deps || commands.devDeps) {
+        const allPackages = options.packages.map((p) => p.name).join(" ");
+        this.executeUpgrade(`pipenv update ${allPackages}`, cwd);
       }
+    } else {
+      if (commands.deps) this.executeUpgrade(commands.deps, cwd);
+      if (commands.devDeps) this.executeUpgrade(commands.devDeps, cwd);
     }
-    let shouldProceed;
-    try {
-      shouldProceed = await confirm6({
-        message: `Ti\u1EBFn h\xE0nh upgrade ${selectedPackages.length} packages?`,
-        default: true
-      });
-    } catch {
-      console.log(`
-${colors3.yellow}\u23F8\uFE0F  \u0110\xE3 h\u1EE7y${colors3.reset}
-`);
-      return;
+  }
+  getUpgradeCommands(packages) {
+    const deps = packages.filter((p) => p.type === "dep");
+    const devDeps = packages.filter((p) => p.type === "dev");
+    let depsCmd = null;
+    let devDepsCmd = null;
+    if (deps.length > 0) {
+      const pkgList = deps.map((p) => `${p.name}==${p.latest}`).join(" ");
+      depsCmd = `pip install --upgrade ${pkgList}`;
     }
-    if (!shouldProceed) {
-      console.log(`${colors3.yellow}\u23F8\uFE0F  Upgrade \u0111\xE3 h\u1EE7y${colors3.reset}
-`);
-      return;
+    if (devDeps.length > 0) {
+      const pkgList = devDeps.map((p) => `${p.name}==${p.latest}`).join(" ");
+      devDepsCmd = `pip install --upgrade ${pkgList}`;
     }
-    const pm = await depsService.detectPackageManager(cwd);
-    console.log(`
-${colors3.cyan}\u{1F527} Package manager: ${pm}${colors3.reset}`);
-    console.log(`${colors3.cyan}\u{1F4E5} \u0110ang upgrade...${colors3.reset}
-`);
-    const commands = depsService.getUpgradeCommands(selectedPackages, pm);
+    return { deps: depsCmd, devDeps: devDepsCmd };
+  }
+  async detectPackageManager(cwd) {
+    if (await this.fileExists(cwd, "Pipfile")) return "pipenv";
+    return "pip";
+  }
+  async checkPip(cwd, onProgress) {
+    const requirementsPath = path11.join(cwd, "requirements.txt");
     try {
-      if (commands.deps) {
-        console.log(`${colors3.dim}$ ${commands.deps}${colors3.reset}
-`);
-        depsService.executeUpgrade(commands.deps);
-      }
-      if (commands.devDeps) {
-        console.log(`
-${colors3.dim}$ ${commands.devDeps}${colors3.reset}
-`);
-        depsService.executeUpgrade(commands.devDeps);
-      }
-      console.log(
-        `
-${colors3.green}\u2705 \u0110\xE3 upgrade ${selectedPackages.length} packages th\xE0nh c\xF4ng!${colors3.reset}
-`
-      );
+      const content = await fs16.readFile(requirementsPath, "utf-8");
+      const packages = this.parseRequirementsTxt(content);
+      return await this.fetchBulkVersions(packages, onProgress);
     } catch (error) {
-      console.error(`
-${colors3.red}\u274C L\u1ED7i khi upgrade:${colors3.reset}`);
-      console.error(`${colors3.red}${error.message}${colors3.reset}
-`);
-      console.log(`${colors3.yellow}\u{1F4A1} B\u1EA1n c\xF3 th\u1EC3 th\u1EED upgrade th\u1EE7 c\xF4ng:${colors3.reset}`);
-      if (commands.deps) console.log(`   ${colors3.cyan}${commands.deps}${colors3.reset}`);
-      if (commands.devDeps) console.log(`   ${colors3.cyan}${commands.devDeps}${colors3.reset}`);
-      console.log("");
-      process.exit(1);
+      if (error.code === "ENOENT") {
+        throw new Error("Kh\xF4ng t\xECm th\u1EA5y requirements.txt trong th\u01B0 m\u1EE5c hi\u1EC7n t\u1EA1i");
+      }
+      throw new Error(`L\u1ED7i \u0111\u1ECDc requirements.txt: ${error.message}`);
     }
-  } catch (error) {
-    console.error(`
-${colors3.red}\u274C ${error.message}${colors3.reset}
-`);
-    process.exit(1);
-  }
-}
-function isNpmVersion(version) {
-  if (version.startsWith("git") || version.startsWith("github") || version.startsWith("file:") || version.startsWith("link:") || version.startsWith("workspace:") || version.includes("://")) {
-    return false;
   }
-  return true;
+  async checkPipenv(cwd, onProgress) {
+    try {
+      const output = execSync3("pipenv run pip list --outdated --format=json", {
+        cwd,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const outdated = JSON.parse(output);
+      const total = outdated.length;
+      let completed = 0;
+      const packages = outdated.map((pkg) => {
+        completed++;
+        onProgress?.(completed, total);
+        return {
+          name: pkg.name,
+          current: pkg.version,
+          latest: pkg.latest_version,
+          latestWithPrefix: pkg.latest_version,
+          type: "dep",
+          upgradeType: this.getUpgradeType(pkg.version, pkg.latest_version),
+          canUpgrade: true
+        };
+      });
+      return packages;
+    } catch (error) {
+      throw new Error(`L\u1ED7i ki\u1EC3m tra pipenv packages: ${error.message}`);
+    }
+  }
+  parseRequirementsTxt(content) {
+    const packages = [];
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const match = trimmed.match(/^([a-zA-Z0-9_-]+)\s*([=><]=?)\s*([0-9.]+)/);
+      if (match) {
+        const [, name, , version] = match;
+        packages.push({ name: name.toLowerCase(), current: version, type: "dep" });
+      }
+    }
+    return packages;
+  }
+  async fetchBulkVersions(packages, onProgress) {
+    const limit = pLimit3(10);
+    const total = packages.length;
+    let completed = 0;
+    const results = await Promise.all(
+      packages.map((pkg) => limit(async () => {
+        const latest = await this.fetchLatestVersion(pkg.name);
+        completed++;
+        onProgress?.(completed, total);
+        if (!latest) return null;
+        const canUpgrade = this.isNewerVersion(latest, pkg.current);
+        if (!canUpgrade) return null;
+        return {
+          name: pkg.name,
+          current: pkg.current,
+          latest,
+          latestWithPrefix: latest,
+          type: pkg.type,
+          upgradeType: this.getUpgradeType(pkg.current, latest),
+          canUpgrade: true
+        };
+      }))
+    );
+    return results.filter((r) => r !== null);
+  }
+  async fetchLatestVersion(packageName) {
+    if (this.versionCache.has(packageName)) return this.versionCache.get(packageName);
+    try {
+      const response = await fetch(
+        `https://pypi.org/pypi/${encodeURIComponent(packageName)}/json`,
+        { signal: AbortSignal.timeout(1e4) }
+      );
+      if (!response.ok) return null;
+      const data = await response.json();
+      this.versionCache.set(packageName, data.info.version);
+      return data.info.version;
+    } catch {
+      return null;
+    }
+  }
+  getUpgradeType(current, latest) {
+    const currentParts = current.split(".").map(Number);
+    const latestParts = latest.split(".").map(Number);
+    if ((latestParts[0] || 0) > (currentParts[0] || 0)) return "major";
+    if ((latestParts[1] || 0) > (currentParts[1] || 0)) return "minor";
+    return "patch";
+  }
+  isNewerVersion(remote, local) {
+    const remoteParts = remote.split(".").map(Number);
+    const localParts = local.split(".").map(Number);
+    for (let i = 0; i < 3; i++) {
+      const r = remoteParts[i] || 0;
+      const l = localParts[i] || 0;
+      if (r > l) return true;
+      if (r < l) return false;
+    }
+    return false;
+  }
+  async fileExists(cwd, filename) {
+    try {
+      await fs16.access(path11.join(cwd, filename));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  executeUpgrade(command, cwd) {
+    execSync3(command, { cwd, stdio: "inherit", env: { ...process.env, FORCE_COLOR: "1" } });
+  }
+};
+
+// src/commands/deps/check.ts
+function createDepsCheckCommand() {
+  const checkCommand = new Command36("check").description("Ki\u1EC3m tra c\xE1c packages c\u1EA7n upgrade").action(async () => {
+    const cwd = process.cwd();
+    const detector = new DepsDetectorService();
+    const spinner = ora("\u0110ang ph\xE1t hi\u1EC7n lo\u1EA1i project...").start();
+    const projects = await detector.detectProjects(cwd);
+    if (projects.length === 0) {
+      spinner.fail("Kh\xF4ng t\xECm th\u1EA5y project n\xE0o \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3");
+      console.log();
+      console.log(chalk11.dim("H\u1ED7 tr\u1EE3: Node.js (package.json), PHP (composer.json), Python (requirements.txt/Pipfile)"));
+      process.exit(1);
+    }
+    spinner.succeed(`Ph\xE1t hi\u1EC7n ${projects.length} project:`);
+    for (const project of projects) {
+      const icon = project.ecosystem === "node" ? "\u{1F4E6}" : project.ecosystem === "php" ? "\u{1F418}" : "\u{1F40D}";
+      const label = project.ecosystem === "node" ? "Node.js" : project.ecosystem === "php" ? "PHP/Composer" : "Python";
+      console.log(`   ${icon} ${label} (${project.manager})`);
+    }
+    console.log();
+    for (const project of projects) {
+      await checkEcosystem(project.ecosystem, project.manager, cwd);
+    }
+    console.log();
+    console.log(chalk11.dim('\u{1F4A1} Ch\u1EA1y "jai1 deps upgrade" \u0111\u1EC3 n\xE2ng c\u1EA5p packages.'));
+  });
+  return checkCommand;
+}
+async function checkEcosystem(ecosystem, manager, cwd) {
+  let service;
+  let icon;
+  let label;
+  switch (ecosystem) {
+    case "node":
+      service = new DepsService();
+      icon = "\u{1F4E6}";
+      label = `Node.js (${manager})`;
+      break;
+    case "php":
+      service = new DepsPhpService();
+      icon = "\u{1F418}";
+      label = "PHP/Composer";
+      break;
+    case "python":
+      service = new DepsPythonService();
+      icon = "\u{1F40D}";
+      label = `Python (${manager})`;
+      break;
+  }
+  const spinner = ora(`\u0110ang ki\u1EC3m tra ${label}...`).start();
+  let result;
+  try {
+    result = await service.check(cwd, (completed, total) => {
+      spinner.text = `\u0110ang ki\u1EC3m tra ${label}... (${completed}/${total})`;
+    });
+  } catch (error) {
+    spinner.fail(`L\u1ED7i ki\u1EC3m tra ${label}`);
+    console.log(chalk11.red(error.message));
+    console.log();
+    return;
+  }
+  if (result.packages.length === 0) {
+    spinner.succeed(`${label} - T\u1EA5t c\u1EA3 packages \u0111\xE3 c\u1EADp nh\u1EADt`);
+    console.log();
+    return;
+  }
+  spinner.succeed(`${label} - ${result.packages.length} packages c\xF3 th\u1EC3 n\xE2ng c\u1EA5p`);
+  console.log();
+  const table = new Table3({
+    head: [
+      chalk11.cyan("Package"),
+      chalk11.cyan("Hi\u1EC7n t\u1EA1i"),
+      chalk11.cyan("M\u1EDBi nh\u1EA5t"),
+      chalk11.cyan("Lo\u1EA1i")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    }
+  });
+  for (const pkg of result.packages) {
+    const upgradeIcon = pkg.upgradeType === "major" ? "\u{1F534}" : pkg.upgradeType === "minor" ? "\u{1F7E1}" : "\u{1F7E2}";
+    table.push([
+      `${upgradeIcon} ${pkg.name}`,
+      chalk11.dim(pkg.current),
+      chalk11.green(pkg.latest),
+      pkg.type === "dev" ? chalk11.dim("dev") : "dep"
+    ]);
+  }
+  console.log(table.toString());
+  console.log();
+  if (result.isLaravel) {
+    const blockedPackages = result.packages.filter((p) => p.blockedReason);
+    if (blockedPackages.length > 0) {
+      console.log(chalk11.yellow("\u26A0\uFE0F  Laravel major version upgrades blocked (nguy hi\u1EC3m):"));
+      for (const pkg of blockedPackages) {
+        console.log(chalk11.dim(`   - ${pkg.name}: ${pkg.current} \u2192 ${pkg.latest}`));
+      }
+      console.log();
+      console.log(chalk11.dim("\u{1F4A1} \u0110\u1EC3 n\xE2ng c\u1EA5p Laravel major version, ch\u1EA1y th\u1EE7 c\xF4ng:"));
+      console.log(chalk11.dim(`   composer require ${blockedPackages[0].name}:^${blockedPackages[0].latest}`));
+      console.log();
+    }
+  }
+}
+
+// src/commands/deps/upgrade.ts
+import { Command as Command37 } from "commander";
+import { checkbox as checkbox3, confirm as confirm6 } from "@inquirer/prompts";
+import chalk12 from "chalk";
+import ora2 from "ora";
+import Table4 from "cli-table3";
+function createDepsUpgradeCommand() {
+  return new Command37("upgrade").description("Upgrade packages l\xEAn version m\u1EDBi nh\u1EA5t").option("--all", "Upgrade t\u1EA5t c\u1EA3 kh\xF4ng c\u1EA7n ch\u1ECDn").action(async (options) => {
+    await handleDepsUpgrade(options);
+  });
+}
+async function handleDepsUpgrade(options) {
+  const cwd = process.cwd();
+  const detector = new DepsDetectorService();
+  try {
+    const spinner = ora2("\u0110ang ph\xE1t hi\u1EC7n lo\u1EA1i project...").start();
+    const projects = await detector.detectProjects(cwd);
+    if (projects.length === 0) {
+      spinner.fail("Kh\xF4ng t\xECm th\u1EA5y project n\xE0o \u0111\u01B0\u1EE3c h\u1ED7 tr\u1EE3");
+      console.log();
+      console.log(chalk12.dim("H\u1ED7 tr\u1EE3: Node.js (package.json), PHP (composer.json), Python (requirements.txt/Pipfile)"));
+      process.exit(1);
+    }
+    spinner.succeed(`Ph\xE1t hi\u1EC7n ${projects.length} project:`);
+    for (const project of projects) {
+      const icon = getEcosystemIcon(project.ecosystem);
+      const label = getEcosystemLabel(project.ecosystem);
+      console.log(`   ${icon} ${label} (${project.manager})`);
+    }
+    console.log();
+    for (const project of projects) {
+      await upgradeEcosystem(project, cwd, options);
+    }
+    console.log();
+    console.log(chalk12.green("\u2705 Ho\xE0n th\xE0nh!"));
+  } catch (error) {
+    console.error(chalk12.red(`
+\u274C ${error.message}
+`));
+    process.exit(1);
+  }
+}
+async function upgradeEcosystem(project, cwd, options) {
+  const service = getService(project.ecosystem);
+  const label = `${getEcosystemIcon(project.ecosystem)} ${getEcosystemLabel(project.ecosystem)}`;
+  console.log(chalk12.bold.cyan(`
+${"\u2501".repeat(80)}`));
+  console.log(chalk12.bold.cyan(`${label}`));
+  console.log(chalk12.bold.cyan("\u2501".repeat(80)));
+  console.log();
+  const spinner = ora2("\u0110ang ki\u1EC3m tra packages...").start();
+  let packages;
+  try {
+    const result = await service.check(cwd, (completed, total) => {
+      spinner.text = `\u0110ang ki\u1EC3m tra packages... (${completed}/${total})`;
+    });
+    packages = result.packages;
+  } catch (error) {
+    spinner.fail("L\u1ED7i ki\u1EC3m tra packages");
+    console.log(chalk12.red(error.message));
+    return;
+  }
+  if (packages.length === 0) {
+    spinner.succeed("T\u1EA5t c\u1EA3 packages \u0111\xE3 c\u1EADp nh\u1EADt");
+    return;
+  }
+  spinner.succeed(`T\xECm th\u1EA5y ${packages.length} packages c\xF3 th\u1EC3 n\xE2ng c\u1EA5p`);
+  console.log();
+  displayUpgradeTable(packages);
+  let selectedPackages;
+  if (options.all) {
+    selectedPackages = packages;
+    console.log(chalk12.cyan(`\u{1F4CB} \u0110\xE3 ch\u1ECDn t\u1EA5t c\u1EA3 ${selectedPackages.length} packages
+`));
+  } else {
+    try {
+      const selected = await checkbox3({
+        message: "Ch\u1ECDn packages \u0111\u1EC3 upgrade (\u2191\u2193 di chuy\u1EC3n \u2022 space ch\u1ECDn \u2022 a t\u1EA5t c\u1EA3 \u2022 i \u0111\u1EA3o \u2022 \u23CE x\xE1c nh\u1EADn \u2022 esc tho\xE1t):",
+        choices: packages.map((pkg) => {
+          const icon = pkg.upgradeType === "major" ? "\u{1F534}" : pkg.upgradeType === "minor" ? "\u{1F7E1}" : "\u{1F7E2}";
+          return {
+            name: `${icon} ${pkg.name} (${pkg.current} \u2192 ${pkg.latest}) [${pkg.type}]`,
+            value: pkg.name,
+            checked: true
+          };
+        }),
+        pageSize: 15
+      });
+      if (selected.length === 0) {
+        console.log(chalk12.yellow("\u23F8\uFE0F  Kh\xF4ng c\xF3 packages n\xE0o \u0111\u01B0\u1EE3c ch\u1ECDn\n"));
+        return;
+      }
+      selectedPackages = packages.filter((p) => selected.includes(p.name));
+    } catch {
+      console.log(chalk12.yellow("\n\u23F8\uFE0F  \u0110\xE3 h\u1EE7y\n"));
+      return;
+    }
+  }
+  let shouldProceed;
+  try {
+    shouldProceed = await confirm6({
+      message: `Ti\u1EBFn h\xE0nh upgrade ${selectedPackages.length} packages? (ESC \u0111\u1EC3 h\u1EE7y)`,
+      default: true
+    });
+  } catch {
+    console.log(chalk12.yellow("\n\u23F8\uFE0F  \u0110\xE3 h\u1EE7y\n"));
+    return;
+  }
+  if (!shouldProceed) {
+    console.log(chalk12.yellow("\u23F8\uFE0F  Upgrade \u0111\xE3 h\u1EE7y\n"));
+    return;
+  }
+  console.log();
+  console.log(chalk12.cyan(`\u{1F527} Package manager: ${project.manager}`));
+  console.log(chalk12.cyan("\u{1F4E5} \u0110ang upgrade...\n"));
+  const commands = service.getUpgradeCommands(selectedPackages);
+  try {
+    if (commands.deps) {
+      console.log(chalk12.dim(`$ ${commands.deps}
+`));
+    }
+    if (commands.devDeps) {
+      console.log(chalk12.dim(`$ ${commands.devDeps}
+`));
+    }
+    await service.upgrade(cwd, { packages: selectedPackages });
+    console.log(chalk12.green(`
+\u2705 \u0110\xE3 upgrade ${selectedPackages.length} packages th\xE0nh c\xF4ng!`));
+  } catch (error) {
+    console.error(chalk12.red("\n\u274C L\u1ED7i khi upgrade:"));
+    console.error(chalk12.red(error.message));
+    console.log(chalk12.yellow("\n\u{1F4A1} B\u1EA1n c\xF3 th\u1EC3 th\u1EED upgrade th\u1EE7 c\xF4ng:"));
+    if (commands.deps) console.log(chalk12.cyan(`   ${commands.deps}`));
+    if (commands.devDeps) console.log(chalk12.cyan(`   ${commands.devDeps}`));
+    console.log();
+    throw error;
+  }
 }
 function displayUpgradeTable(packages) {
-  console.log(`${colors3.bold}\u{1F4CA} C\xF3 th\u1EC3 upgrade:${colors3.reset}
-`);
-  const nameWidth = Math.max(7, ...packages.map((p) => p.name.length));
-  const currentWidth = Math.max(8, ...packages.map((p) => p.current.length));
-  const latestWidth = Math.max(8, ...packages.map((p) => p.latestWithPrefix.length));
-  const header = `\u2502 ${"Package".padEnd(nameWidth)} \u2502 ${"Hi\u1EC7n t\u1EA1i".padEnd(currentWidth)} \u2502 ${"M\u1EDBi nh\u1EA5t".padEnd(latestWidth)} \u2502 Lo\u1EA1i \u2502`;
-  const separator = `\u251C${"\u2500".repeat(nameWidth + 2)}\u253C${"\u2500".repeat(currentWidth + 2)}\u253C${"\u2500".repeat(latestWidth + 2)}\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2524`;
-  const topBorder = `\u250C${"\u2500".repeat(nameWidth + 2)}\u252C${"\u2500".repeat(currentWidth + 2)}\u252C${"\u2500".repeat(latestWidth + 2)}\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2510`;
-  const bottomBorder = `\u2514${"\u2500".repeat(nameWidth + 2)}\u2534${"\u2500".repeat(currentWidth + 2)}\u2534${"\u2500".repeat(latestWidth + 2)}\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2518`;
-  console.log(topBorder);
-  console.log(header);
-  console.log(separator);
+  const table = new Table4({
+    head: [
+      chalk12.cyan("Package"),
+      chalk12.cyan("Hi\u1EC7n t\u1EA1i"),
+      chalk12.cyan("M\u1EDBi nh\u1EA5t"),
+      chalk12.cyan("Lo\u1EA1i")
+    ],
+    style: {
+      head: [],
+      border: ["dim"]
+    }
+  });
   for (const pkg of packages) {
-    const typeLabel = pkg.type === "dep" ? "dep " : "dev ";
-    const typeColor = pkg.type === "dep" ? colors3.cyan : colors3.yellow;
-    console.log(
-      `\u2502 ${pkg.name.padEnd(nameWidth)} \u2502 ${colors3.gray}${pkg.current.padEnd(currentWidth)}${colors3.reset} \u2502 ${colors3.green}${pkg.latestWithPrefix.padEnd(latestWidth)}${colors3.reset} \u2502 ${typeColor}${typeLabel}${colors3.reset}\u2502`
-    );
+    const upgradeIcon = pkg.upgradeType === "major" ? "\u{1F534}" : pkg.upgradeType === "minor" ? "\u{1F7E1}" : "\u{1F7E2}";
+    table.push([
+      `${upgradeIcon} ${pkg.name}`,
+      chalk12.dim(pkg.current),
+      chalk12.green(pkg.latest),
+      pkg.type === "dev" ? chalk12.dim("dev") : "dep"
+    ]);
+  }
+  console.log(table.toString());
+  console.log();
+}
+function getService(ecosystem) {
+  switch (ecosystem) {
+    case "node":
+      return new DepsService();
+    case "php":
+      return new DepsPhpService();
+    case "python":
+      return new DepsPythonService();
+  }
+}
+function getEcosystemIcon(ecosystem) {
+  switch (ecosystem) {
+    case "node":
+      return "\u{1F4E6}";
+    case "php":
+      return "\u{1F418}";
+    case "python":
+      return "\u{1F40D}";
+    default:
+      return "\u{1F4E6}";
+  }
+}
+function getEcosystemLabel(ecosystem) {
+  switch (ecosystem) {
+    case "node":
+      return "Node.js";
+    case "php":
+      return "PHP/Composer";
+    case "python":
+      return "Python";
+    default:
+      return ecosystem;
   }
-  console.log(bottomBorder);
-  console.log("");
 }
 
 // src/commands/deps/index.ts
 function showDepsHelp() {
-  console.log(chalk11.bold.cyan("\u{1F4E6} jai1 deps") + chalk11.dim(" - Qu\u1EA3n l\xFD dependencies trong project"));
+  console.log(chalk13.bold.cyan("\u{1F4E6} jai1 deps") + chalk13.dim(" - Qu\u1EA3n l\xFD dependencies trong project"));
   console.log();
-  console.log(chalk11.bold("C\xE1c l\u1EC7nh:"));
-  console.log(`  ${chalk11.cyan("upgrade")}   N\xE2ng c\u1EA5p dependencies l\xEAn phi\xEAn b\u1EA3n m\u1EDBi nh\u1EA5t`);
+  console.log(chalk13.bold("C\xE1c l\u1EC7nh:"));
+  console.log(`  ${chalk13.cyan("check")}     Ki\u1EC3m tra c\xE1c packages c\u1EA7n upgrade`);
+  console.log(`  ${chalk13.cyan("upgrade")}   N\xE2ng c\u1EA5p dependencies l\xEAn phi\xEAn b\u1EA3n m\u1EDBi nh\u1EA5t`);
+  console.log();
+  console.log(chalk13.bold("H\u1ED7 tr\u1EE3:"));
+  console.log(chalk13.dim("  \u2022 Node.js (npm, pnpm, yarn, bun)"));
+  console.log(chalk13.dim("  \u2022 PHP/Composer (v\u1EDBi b\u1EA3o v\u1EC7 Laravel major version)"));
+  console.log(chalk13.dim("  \u2022 Python (pip, pipenv)"));
   console.log();
-  console.log(chalk11.bold("V\xED d\u1EE5:"));
-  console.log(chalk11.dim("  $ jai1 deps upgrade"));
-  console.log(chalk11.dim("  $ jai1 deps upgrade --dry-run"));
+  console.log(chalk13.bold("V\xED d\u1EE5:"));
+  console.log(chalk13.dim("  $ jai1 deps check"));
+  console.log(chalk13.dim("  $ jai1 deps upgrade"));
+  console.log(chalk13.dim("  $ jai1 deps upgrade --all"));
   console.log();
-  console.log(chalk11.dim('Ch\u1EA1y "jai1 deps <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
+  console.log(chalk13.dim('Ch\u1EA1y "jai1 deps <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
 }
 function createDepsCommand() {
-  const depsCommand = new Command37("deps").description("Qu\u1EA3n l\xFD dependencies trong project").action(() => {
+  const depsCommand = new Command38("deps").description("Qu\u1EA3n l\xFD dependencies trong project").action(() => {
     showDepsHelp();
   });
+  depsCommand.addCommand(createDepsCheckCommand());
   depsCommand.addCommand(createDepsUpgradeCommand());
   return depsCommand;
 }
 
 // src/commands/kit/index.ts
-import { Command as Command41 } from "commander";
-import chalk13 from "chalk";
+import { Command as Command42 } from "commander";
+import chalk15 from "chalk";
 
 // src/commands/kit/list.ts
-import { Command as Command38 } from "commander";
-import chalk12 from "chalk";
-import Table3 from "cli-table3";
+import { Command as Command39 } from "commander";
+import chalk14 from "chalk";
+import Table5 from "cli-table3";
 
 // src/services/starter-kit.service.ts
-import { promises as fs14 } from "fs";
-import { join as join6 } from "path";
+import { promises as fs17 } from "fs";
+import { join as join7 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
   /**
@@ -10768,29 +11353,29 @@ var StarterKitService = class {
       throw new NetworkError(`Failed to download kit: HTTP ${response.status}`);
     }
     if (onProgress) onProgress(30);
-    const tmpDir = join6(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs14.mkdir(tmpDir, { recursive: true });
-    const tmpFile = join6(tmpDir, `${slug}.zip`);
+    const tmpDir = join7(process.env.TMPDIR || "/tmp", "jai1-kits");
+    await fs17.mkdir(tmpDir, { recursive: true });
+    const tmpFile = join7(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs14.writeFile(tmpFile, Buffer.from(buffer));
+    await fs17.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs14.mkdir(targetDir, { recursive: true });
+    await fs17.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs14.unlink(tmpFile);
+    await fs17.unlink(tmpFile);
   }
 };
 
 // src/commands/kit/list.ts
 function createKitListCommand() {
-  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) => {
+  return new Command39("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) {
       throw new ValidationError('Not initialized. Run "jai1 auth" first.');
     }
-    console.log(chalk12.cyan("\u{1F4E6} \u0110ang t\u1EA3i danh s\xE1ch starter kits..."));
+    console.log(chalk14.cyan("\u{1F4E6} \u0110ang t\u1EA3i danh s\xE1ch starter kits..."));
     console.log();
     const kitService = new StarterKitService();
     const kits = await kitService.list(config, {
@@ -10798,9 +11383,9 @@ function createKitListCommand() {
       search: options.search
     });
     if (kits.length === 0) {
-      console.log(chalk12.yellow("Kh\xF4ng t\xECm th\u1EA5y starter kits n\xE0o."));
+      console.log(chalk14.yellow("Kh\xF4ng t\xECm th\u1EA5y starter kits n\xE0o."));
       if (options.category || options.search) {
-        console.log(chalk12.dim("Th\u1EED b\u1ECF filter \u0111\u1EC3 xem t\u1EA5t c\u1EA3."));
+        console.log(chalk14.dim("Th\u1EED b\u1ECF filter \u0111\u1EC3 xem t\u1EA5t c\u1EA3."));
       }
       return;
     }
@@ -10824,35 +11409,35 @@ function createKitListCommand() {
       const categoryKits = byCategory[category];
       const categoryIcon = category === "frontend" ? "\u{1F3A8}" : category === "backend" ? "\u2699\uFE0F" : category === "fullstack" ? "\u{1F680}" : "\u{1F4E6}";
       console.log(
-        chalk12.bold(`${categoryIcon} ${category.charAt(0).toUpperCase() + category.slice(1)}`)
+        chalk14.bold(`${categoryIcon} ${category.charAt(0).toUpperCase() + category.slice(1)}`)
       );
-      const table = new Table3({
+      const table = new Table5({
         head: [
-          chalk12.cyan("Slug"),
-          chalk12.cyan("M\xF4 t\u1EA3"),
-          chalk12.cyan("Version")
+          chalk14.cyan("Slug"),
+          chalk14.cyan("M\xF4 t\u1EA3"),
+          chalk14.cyan("Version")
         ],
         style: { head: [], border: ["gray"] }
       });
       for (const kit of categoryKits) {
         table.push([
-          chalk12.white(kit.slug),
-          chalk12.dim(kit.description.slice(0, 50)),
-          chalk12.green(`v${kit.version}`)
+          chalk14.white(kit.slug),
+          chalk14.dim(kit.description.slice(0, 50)),
+          chalk14.green(`v${kit.version}`)
         ]);
       }
       console.log(table.toString());
       console.log();
     }
-    console.log(chalk12.dim(`T\u1ED5ng c\u1ED9ng: ${kits.length} starter kit(s)`));
-    console.log(chalk12.dim('\n\u{1F4A1} Ch\u1EA1y "jai1 kit create <slug>" \u0111\u1EC3 t\u1EA1o project m\u1EDBi'));
+    console.log(chalk14.dim(`T\u1ED5ng c\u1ED9ng: ${kits.length} starter kit(s)`));
+    console.log(chalk14.dim('\n\u{1F4A1} Ch\u1EA1y "jai1 kit create <slug>" \u0111\u1EC3 t\u1EA1o project m\u1EDBi'));
   });
 }
 
 // src/commands/kit/info.ts
-import { Command as Command39 } from "commander";
+import { Command as Command40 } from "commander";
 function createKitInfoCommand() {
-  return new Command39("info").description("Show detailed information about a starter kit").argument("<slug>", "Starter kit slug").action(async (slug) => {
+  return new Command40("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) {
@@ -10901,9 +11486,9 @@ Post-Init Commands:`);
 }
 
 // src/commands/kit/create.ts
-import { Command as Command40 } from "commander";
-import { promises as fs15 } from "fs";
-import { join as join7 } from "path";
+import { Command as Command41 } from "commander";
+import { promises as fs18 } from "fs";
+import { join as join8 } from "path";
 import { select as select3, input as input2, checkbox as checkbox4 } from "@inquirer/prompts";
 import { execa as execa2 } from "execa";
 
@@ -10946,7 +11531,7 @@ var HookExecutor = class {
 
 // src/commands/kit/create.ts
 function createKitCreateCommand() {
-  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) => {
+  return new Command41("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) {
@@ -10966,9 +11551,9 @@ function createKitCreateCommand() {
         }
       }
     }
-    const targetDir = directory || join7(process.cwd(), options.name || slug);
+    const targetDir = directory || join8(process.cwd(), options.name || slug);
     try {
-      await fs15.access(targetDir);
+      await fs18.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -11086,7 +11671,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs15.readFile(file, "utf-8");
+    let content = await fs18.readFile(file, "utf-8");
     let modified = false;
     for (const [key, value] of Object.entries(variables)) {
       const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
@@ -11096,15 +11681,15 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs15.writeFile(file, content, "utf-8");
+      await fs18.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs15.readdir(dir, { withFileTypes: true });
+  const entries = await fs18.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join7(dir, entry.name);
+    const fullPath = join8(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
         files.push(...await getAllFiles(fullPath));
@@ -11118,23 +11703,23 @@ async function getAllFiles(dir) {
 
 // src/commands/kit/index.ts
 function showKitHelp() {
-  console.log(chalk13.bold.cyan("\u{1F4E6} jai1 kit") + chalk13.dim(" - Qu\u1EA3n l\xFD starter kits"));
+  console.log(chalk15.bold.cyan("\u{1F4E6} jai1 kit") + chalk15.dim(" - Qu\u1EA3n l\xFD starter kits"));
   console.log();
-  console.log(chalk13.bold("C\xE1c l\u1EC7nh:"));
-  console.log(`  ${chalk13.cyan("list")}     Li\u1EC7t k\xEA c\xE1c starter kits c\xF3 s\u1EB5n`);
-  console.log(`  ${chalk13.cyan("info")}     Xem chi ti\u1EBFt m\u1ED9t starter kit`);
-  console.log(`  ${chalk13.cyan("create")}   T\u1EA1o project m\u1EDBi t\u1EEB starter kit`);
+  console.log(chalk15.bold("C\xE1c l\u1EC7nh:"));
+  console.log(`  ${chalk15.cyan("list")}     Li\u1EC7t k\xEA c\xE1c starter kits c\xF3 s\u1EB5n`);
+  console.log(`  ${chalk15.cyan("info")}     Xem chi ti\u1EBFt m\u1ED9t starter kit`);
+  console.log(`  ${chalk15.cyan("create")}   T\u1EA1o project m\u1EDBi t\u1EEB starter kit`);
   console.log();
-  console.log(chalk13.bold("V\xED d\u1EE5:"));
-  console.log(chalk13.dim("  $ jai1 kit list"));
-  console.log(chalk13.dim("  $ jai1 kit list --category frontend"));
-  console.log(chalk13.dim("  $ jai1 kit info next-tw4-shadcn"));
-  console.log(chalk13.dim("  $ jai1 kit create next-tw4-shadcn my-project"));
+  console.log(chalk15.bold("V\xED d\u1EE5:"));
+  console.log(chalk15.dim("  $ jai1 kit list"));
+  console.log(chalk15.dim("  $ jai1 kit list --category frontend"));
+  console.log(chalk15.dim("  $ jai1 kit info next-tw4-shadcn"));
+  console.log(chalk15.dim("  $ jai1 kit create next-tw4-shadcn my-project"));
   console.log();
-  console.log(chalk13.dim('Ch\u1EA1y "jai1 kit <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
+  console.log(chalk15.dim('Ch\u1EA1y "jai1 kit <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
 }
 function createKitCommand() {
-  const cmd = new Command41("kit").description("Manage starter kits for new projects").action(() => {
+  const cmd = new Command42("kit").description("Manage starter kits for new projects").action(() => {
     showKitHelp();
   });
   cmd.addCommand(createKitListCommand());
@@ -11144,21 +11729,21 @@ function createKitCommand() {
 }
 
 // src/commands/rules/index.ts
-import { Command as Command48 } from "commander";
-import chalk15 from "chalk";
+import { Command as Command49 } from "commander";
+import chalk17 from "chalk";
 
 // src/commands/rules/list.ts
-import { Command as Command42 } from "commander";
-import chalk14 from "chalk";
-import Table4 from "cli-table3";
+import { Command as Command43 } from "commander";
+import chalk16 from "chalk";
+import Table6 from "cli-table3";
 function createRulesListCommand() {
-  return new Command42("list").description("List available rule presets").option("--json", "Output as JSON").action(async (options) => {
+  return new Command43("list").description("List available rule presets").option("--json", "Output as JSON").action(async (options) => {
     const configService = new ConfigService();
     const config = await configService.load();
     if (!config) {
       throw new ValidationError('Not initialized. Run "jai1 auth" first.');
     }
-    console.log(chalk14.cyan("\u{1F4CB} \u0110ang t\u1EA3i danh s\xE1ch rule presets..."));
+    console.log(chalk16.cyan("\u{1F4CB} \u0110ang t\u1EA3i danh s\xE1ch rule presets..."));
     console.log();
     try {
       const response = await fetch(`${config.apiUrl}/api/rules/presets`, {
@@ -11175,23 +11760,23 @@ function createRulesListCommand() {
         return;
       }
       if (data.total === 0) {
-        console.log(chalk14.yellow("Kh\xF4ng c\xF3 presets n\xE0o."));
+        console.log(chalk16.yellow("Kh\xF4ng c\xF3 presets n\xE0o."));
         return;
       }
       console.log(
-        chalk14.green(`\u2713 T\xECm th\u1EA5y ${chalk14.bold(data.total)} preset${data.total > 1 ? "s" : ""}`)
+        chalk16.green(`\u2713 T\xECm th\u1EA5y ${chalk16.bold(data.total)} preset${data.total > 1 ? "s" : ""}`)
       );
       console.log();
       for (const preset of data.presets) {
-        console.log(chalk14.bold.cyan(`\u{1F4E6} ${preset.slug}`));
-        const table = new Table4({
+        console.log(chalk16.bold.cyan(`\u{1F4E6} ${preset.slug}`));
+        const table = new Table6({
           style: { head: [], border: ["gray"], compact: true },
           colWidths: [15, 55]
         });
         table.push(
-          [chalk14.dim("T\xEAn"), chalk14.white(preset.name)],
-          [chalk14.dim("M\xF4 t\u1EA3"), chalk14.white(preset.description)],
-          [chalk14.dim("Version"), chalk14.green(`v${preset.version}`)]
+          [chalk16.dim("T\xEAn"), chalk16.white(preset.name)],
+          [chalk16.dim("M\xF4 t\u1EA3"), chalk16.white(preset.description)],
+          [chalk16.dim("Version"), chalk16.green(`v${preset.version}`)]
         );
         const stackParts = [];
         if (preset.stack.frontend) stackParts.push(preset.stack.frontend);
@@ -11199,16 +11784,16 @@ function createRulesListCommand() {
         if (preset.stack.css) stackParts.push(preset.stack.css);
         if (preset.stack.database) stackParts.push(preset.stack.database);
         if (stackParts.length > 0) {
-          table.push([chalk14.dim("Stack"), chalk14.yellow(stackParts.join(" + "))]);
+          table.push([chalk16.dim("Stack"), chalk16.yellow(stackParts.join(" + "))]);
         }
         table.push(
-          [chalk14.dim("Tags"), chalk14.dim(preset.tags.join(", ") || "-")],
-          [chalk14.dim("Downloads"), chalk14.white(preset.downloads.toString())]
+          [chalk16.dim("Tags"), chalk16.dim(preset.tags.join(", ") || "-")],
+          [chalk16.dim("Downloads"), chalk16.white(preset.downloads.toString())]
         );
         console.log(table.toString());
         console.log();
       }
-      console.log(chalk14.dim('\u{1F4A1} Ch\u1EA1y "jai1 rules init --preset=<slug>" \u0111\u1EC3 \xE1p d\u1EE5ng preset'));
+      console.log(chalk16.dim('\u{1F4A1} Ch\u1EA1y "jai1 rules init --preset=<slug>" \u0111\u1EC3 \xE1p d\u1EE5ng preset'));
     } catch (error) {
       throw new Error(
         `L\u1ED7i khi t\u1EA3i presets: ${error instanceof Error ? error.message : String(error)}`
@@ -11218,12 +11803,12 @@ function createRulesListCommand() {
 }
 
 // src/commands/rules/init.ts
-import { Command as Command43 } from "commander";
-import { promises as fs16 } from "fs";
-import { join as join8 } from "path";
+import { Command as Command44 } from "commander";
+import { promises as fs19 } from "fs";
+import { join as join9 } from "path";
 import { select as select4, confirm as confirm7 } from "@inquirer/prompts";
 function createRulesInitCommand() {
-  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) => {
+  return new Command44("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) {
@@ -11305,7 +11890,7 @@ function createRulesInitCommand() {
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
       customContext: "09-custom.mdc"
     };
-    await fs16.writeFile("jai1-rules.json", JSON.stringify(projectConfig, null, 2));
+    await fs19.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:");
@@ -11315,11 +11900,11 @@ function createRulesInitCommand() {
   });
 }
 async function applyCursorFormat(bundle) {
-  const rulesDir = join8(process.cwd(), ".cursor", "rules");
-  await fs16.mkdir(rulesDir, { recursive: true });
+  const rulesDir = join9(process.cwd(), ".cursor", "rules");
+  await fs19.mkdir(rulesDir, { recursive: true });
   for (const [filename, content] of Object.entries(bundle.files)) {
-    const filePath = join8(rulesDir, filename);
-    await fs16.writeFile(filePath, content, "utf-8");
+    const filePath = join9(rulesDir, filename);
+    await fs19.writeFile(filePath, content, "utf-8");
     console.log(`\u2713 Created .cursor/rules/${filename}`);
   }
 }
@@ -11346,14 +11931,14 @@ async function applyAgentsMdFormat(bundle) {
     }
   }
   const agentsMd = sections.join("\n");
-  await fs16.writeFile("AGENTS.md", agentsMd, "utf-8");
+  await fs19.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 fs18 } from "fs";
-import { join as join10 } from "path";
+import { Command as Command45 } from "commander";
+import { promises as fs21 } from "fs";
+import { join as join11 } from "path";
 import { select as select5, confirm as confirm8, checkbox as checkbox5 } from "@inquirer/prompts";
 
 // src/services/rules-generator.service.ts
@@ -11713,8 +12298,8 @@ Follow all instructions and patterns defined in AGENTS.md above.
 };
 
 // src/services/backup.service.ts
-import { promises as fs17 } from "fs";
-import { join as join9, dirname } from "path";
+import { promises as fs20 } from "fs";
+import { join as join10, dirname } from "path";
 var BackupService = class {
   backupDir = ".jai1/backups";
   /**
@@ -11722,7 +12307,7 @@ var BackupService = class {
    */
   async createBackup(ides, presetSlug) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = join9(this.backupDir, timestamp);
+    const backupPath = join10(this.backupDir, timestamp);
     const backedUpFiles = [];
     let hasContent = false;
     for (const ideId of ides) {
@@ -11731,7 +12316,7 @@ var BackupService = class {
         console.warn(`Unknown IDE format: ${ideId}, skipping backup`);
         continue;
       }
-      const rulesPath = format.rulesPath === "." ? process.cwd() : join9(process.cwd(), format.rulesPath);
+      const rulesPath = format.rulesPath === "." ? process.cwd() : join10(process.cwd(), format.rulesPath);
       try {
         const exists = await this.pathExists(rulesPath);
         if (!exists) {
@@ -11744,19 +12329,19 @@ var BackupService = class {
           await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
           hasContent = true;
         } else {
-          const stats = await fs17.stat(rulesPath);
+          const stats = await fs20.stat(rulesPath);
           if (stats.isDirectory()) {
-            const files = await fs17.readdir(rulesPath);
+            const files = await fs20.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 fs17.mkdir(dirname(destPath), { recursive: true });
-                await fs17.copyFile(originalPath, destPath);
+                const originalPath = join10(rulesPath, file);
+                const relativePath = join10(format.rulesPath, file);
+                const destPath = join10(backupPath, ideId, file);
+                await fs20.mkdir(dirname(destPath), { recursive: true });
+                await fs20.copyFile(originalPath, destPath);
                 backedUpFiles.push({
                   originalPath: relativePath,
-                  backupPath: join9(ideId, file),
+                  backupPath: join10(ideId, file),
                   ide: ideId
                 });
                 hasContent = true;
@@ -11777,9 +12362,9 @@ var BackupService = class {
       ides,
       files: backedUpFiles
     };
-    await fs17.mkdir(backupPath, { recursive: true });
-    await fs17.writeFile(
-      join9(backupPath, "metadata.json"),
+    await fs20.mkdir(backupPath, { recursive: true });
+    await fs20.writeFile(
+      join10(backupPath, "metadata.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
     );
@@ -11789,18 +12374,18 @@ var BackupService = class {
    * Backup a single file (for AGENTS.md, GEMINI.md)
    */
   async backupSingleFile(filename, backupPath, ideId, backedUpFiles) {
-    const originalPath = join9(process.cwd(), filename);
+    const originalPath = join10(process.cwd(), filename);
     try {
       const exists = await this.pathExists(originalPath);
       if (!exists) {
         return;
       }
-      const destPath = join9(backupPath, ideId, filename);
-      await fs17.mkdir(dirname(destPath), { recursive: true });
-      await fs17.copyFile(originalPath, destPath);
+      const destPath = join10(backupPath, ideId, filename);
+      await fs20.mkdir(dirname(destPath), { recursive: true });
+      await fs20.copyFile(originalPath, destPath);
       backedUpFiles.push({
         originalPath: filename,
-        backupPath: join9(ideId, filename),
+        backupPath: join10(ideId, filename),
         ide: ideId
       });
     } catch (error) {
@@ -11810,16 +12395,16 @@ var BackupService = class {
    * Restore files from a backup
    */
   async restoreBackup(backupPath) {
-    const metadataPath = join9(backupPath, "metadata.json");
-    const metadataContent = await fs17.readFile(metadataPath, "utf-8");
+    const metadataPath = join10(backupPath, "metadata.json");
+    const metadataContent = await fs20.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 fs17.mkdir(dirname(destPath), { recursive: true });
-      await fs17.copyFile(sourcePath, destPath);
+      const sourcePath = join10(backupPath, file.backupPath);
+      const destPath = join10(process.cwd(), file.originalPath);
+      await fs20.mkdir(dirname(destPath), { recursive: true });
+      await fs20.copyFile(sourcePath, destPath);
       console.log(`\u2713 Restored ${file.originalPath}`);
     }
     console.log("\n\u2705 Backup restored successfully!");
@@ -11829,18 +12414,18 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async listBackups() {
     try {
-      const backupDirPath = join9(process.cwd(), this.backupDir);
+      const backupDirPath = join10(process.cwd(), this.backupDir);
       const exists = await this.pathExists(backupDirPath);
       if (!exists) {
         return [];
       }
-      const entries = await fs17.readdir(backupDirPath, { withFileTypes: true });
+      const entries = await fs20.readdir(backupDirPath, { withFileTypes: true });
       const backups = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const metadataPath = join9(backupDirPath, entry.name, "metadata.json");
+          const metadataPath = join10(backupDirPath, entry.name, "metadata.json");
           try {
-            const metadataContent = await fs17.readFile(metadataPath, "utf-8");
+            const metadataContent = await fs20.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(metadataContent);
             backups.push(metadata);
           } catch {
@@ -11857,7 +12442,7 @@ Restoring backup from ${metadata.timestamp}...`);
    * Delete a specific backup
    */
   async deleteBackup(timestamp) {
-    const backupPath = join9(process.cwd(), this.backupDir, timestamp);
+    const backupPath = join10(process.cwd(), this.backupDir, timestamp);
     await this.deleteDirectory(backupPath);
   }
   /**
@@ -11887,9 +12472,9 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Check if a path exists
    */
-  async pathExists(path10) {
+  async pathExists(path13) {
     try {
-      await fs17.access(path10);
+      await fs20.access(path13);
       return true;
     } catch {
       return false;
@@ -11898,22 +12483,22 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Recursively delete a directory
    */
-  async deleteDirectory(path10) {
+  async deleteDirectory(path13) {
     try {
-      const exists = await this.pathExists(path10);
+      const exists = await this.pathExists(path13);
       if (!exists) {
         return;
       }
-      const entries = await fs17.readdir(path10, { withFileTypes: true });
+      const entries = await fs20.readdir(path13, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join9(path10, entry.name);
+        const fullPath = join10(path13, entry.name);
         if (entry.isDirectory()) {
           await this.deleteDirectory(fullPath);
         } else {
-          await fs17.unlink(fullPath);
+          await fs20.unlink(fullPath);
         }
       }
-      await fs17.rmdir(path10);
+      await fs20.rmdir(path13);
     } catch (error) {
     }
   }
@@ -11921,20 +12506,20 @@ Restoring backup from ${metadata.timestamp}...`);
    * Get backup directory path
    */
   getBackupDir() {
-    return join9(process.cwd(), this.backupDir);
+    return join10(process.cwd(), this.backupDir);
   }
   /**
    * Ensure backup directory exists
    */
   async ensureBackupDir() {
-    const backupDirPath = join9(process.cwd(), this.backupDir);
-    await fs17.mkdir(backupDirPath, { recursive: true });
+    const backupDirPath = join10(process.cwd(), this.backupDir);
+    await fs20.mkdir(backupDirPath, { recursive: true });
   }
 };
 
 // src/commands/rules/apply.ts
 function createRulesApplyCommand() {
-  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) => {
+  return new Command45("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) {
@@ -12084,21 +12669,21 @@ function createRulesApplyCommand() {
       }
     }
     console.log("\n\u{1F4DD} Applying preset...\n");
-    const rulePresetDir = join10(process.cwd(), ".jai1", "rule-preset");
+    const rulePresetDir = join11(process.cwd(), ".jai1", "rule-preset");
     try {
-      await fs18.rm(rulePresetDir, { recursive: true, force: true });
+      await fs21.rm(rulePresetDir, { recursive: true, force: true });
     } catch {
     }
-    await fs18.mkdir(rulePresetDir, { recursive: true });
-    await fs18.writeFile(
-      join10(rulePresetDir, "preset.json"),
+    await fs21.mkdir(rulePresetDir, { recursive: true });
+    await fs21.writeFile(
+      join11(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 fs18.mkdir(join10(filePath, ".."), { recursive: true });
-      await fs18.writeFile(filePath, content, "utf-8");
+      const filePath = join11(rulePresetDir, filename);
+      await fs21.mkdir(join11(filePath, ".."), { recursive: true });
+      await fs21.writeFile(filePath, content, "utf-8");
     }
     console.log(`\u2713 Saved preset to .jai1/rule-preset/`);
     const allGeneratedFiles = [];
@@ -12106,9 +12691,9 @@ function createRulesApplyCommand() {
       try {
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
-          const fullPath = join10(process.cwd(), file.path);
-          await fs18.mkdir(join10(fullPath, ".."), { recursive: true });
-          await fs18.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join11(process.cwd(), file.path);
+          await fs21.mkdir(join11(fullPath, ".."), { recursive: true });
+          await fs21.writeFile(fullPath, file.content, "utf-8");
           console.log(`\u2713 [${ideId}] ${file.path}`);
           allGeneratedFiles.push({
             ide: ideId,
@@ -12135,8 +12720,8 @@ function createRulesApplyCommand() {
       ] : []
     };
     try {
-      const existingConfigPath = join10(process.cwd(), "jai1-rules.json");
-      const existingConfigContent = await fs18.readFile(existingConfigPath, "utf-8");
+      const existingConfigPath = join11(process.cwd(), "jai1-rules.json");
+      const existingConfigContent = await fs21.readFile(existingConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingConfigContent);
       if (existingConfig.backups && existingConfig.backups.length > 0) {
         projectConfig.backups = [
@@ -12147,8 +12732,8 @@ function createRulesApplyCommand() {
       }
     } catch {
     }
-    await fs18.writeFile(
-      join10(process.cwd(), "jai1-rules.json"),
+    await fs21.writeFile(
+      join11(process.cwd(), "jai1-rules.json"),
       JSON.stringify(projectConfig, null, 2),
       "utf-8"
     );
@@ -12179,11 +12764,11 @@ function createRulesApplyCommand() {
 }
 
 // src/commands/rules/restore.ts
-import { Command as Command45 } from "commander";
-import { join as join11 } from "path";
+import { Command as Command46 } from "commander";
+import { join as join12 } from "path";
 import { select as select6, confirm as confirm9 } from "@inquirer/prompts";
 function createRulesRestoreCommand() {
-  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) => {
+  return new Command46("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) {
@@ -12226,7 +12811,7 @@ function createRulesRestoreCommand() {
     }
     console.log("\n\u{1F504} Restoring backup...\n");
     try {
-      const backupPath = join11(backupService.getBackupDir(), selectedBackup.timestamp);
+      const backupPath = join12(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.");
@@ -12251,16 +12836,16 @@ function formatTimestamp(timestamp) {
 }
 
 // src/commands/rules/sync.ts
-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";
+import { Command as Command47 } from "commander";
+import { promises as fs22 } from "fs";
+import { join as join13 } from "path";
+import { checkbox as checkbox6, confirm as confirm10 } from "@inquirer/prompts";
 function createRulesSyncCommand() {
-  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");
+  return new Command47("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 = join13(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs19.readFile(configPath, "utf-8");
+      const configContent = await fs22.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -12307,6 +12892,35 @@ Detected ${detected.length} active IDE(s):
 \u26A0\uFE0F  IDEs not in config: ${notConfigured.join(", ")}`);
         console.log("   They will still be synced, but may not be in jai1-rules.json");
       }
+    } else if (!options.yes) {
+      const currentIdes = projectConfig.ides || [];
+      console.log(`
+Current IDE(s): ${currentIdes.join(", ") || "none"}`);
+      const detectionService = new IdeDetectionService();
+      const detected = await detectionService.detectActiveIdes();
+      const suggestions = await detectionService.suggestIdes();
+      if (detected.length > 0) {
+        const detectedCount = detected.reduce((sum, d) => sum + d.ruleCount + d.workflowCount, 0);
+        console.log(`  (${detectedCount} files detected)`);
+      }
+      if (suggestions.length > 0) {
+        console.log("\n\u{1F4A1} Smart suggestions based on your project:\n");
+        suggestions.slice(0, 3).forEach((s) => {
+          const priority = s.priority === "high" ? "\u2B50" : s.priority === "medium" ? "\u{1F538}" : "\u25AB\uFE0F";
+          console.log(`${priority} ${s.name} - ${s.reason}`);
+        });
+        console.log("");
+      }
+      const choices = buildIdeChoices(currentIdes, detected, suggestions);
+      idesToSync = await checkbox6({
+        message: "Select IDE formats to sync (pre-selected are recommended):",
+        choices,
+        required: true
+      });
+      if (idesToSync.length === 0) {
+        console.log("Cancelled.");
+        return;
+      }
     } else {
       idesToSync = projectConfig.ides || [];
       if (idesToSync.length === 0) {
@@ -12340,14 +12954,14 @@ Detected ${detected.length} active IDE(s):
       throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
     }
     const bundle = await presetResponse.json();
-    const rulePresetDir = join12(process.cwd(), ".jai1", "rule-preset");
+    const rulePresetDir = join13(process.cwd(), ".jai1", "rule-preset");
     const presetExists = await checkPathExists(rulePresetDir);
     if (presetExists) {
-      const files = await fs19.readdir(rulePresetDir);
+      const files = await fs22.readdir(rulePresetDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
-          const filePath = join12(rulePresetDir, file);
-          const content = await fs19.readFile(filePath, "utf-8");
+          const filePath = join13(rulePresetDir, file);
+          const content = await fs22.readFile(filePath, "utf-8");
           bundle.files[file] = content;
         }
       }
@@ -12366,9 +12980,9 @@ 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 fs19.mkdir(join12(fullPath, ".."), { recursive: true });
-          await fs19.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join13(process.cwd(), file.path);
+          await fs22.mkdir(join13(fullPath, ".."), { recursive: true });
+          await fs22.writeFile(fullPath, file.content, "utf-8");
         }
         console.log(`\u2713 ${format.name} - ${files.length} files regenerated`);
       } catch (error) {
@@ -12377,8 +12991,8 @@ Detected ${detected.length} active IDE(s):
     }
     if (JSON.stringify(projectConfig.ides) !== JSON.stringify(idesToSync)) {
       projectConfig.ides = idesToSync;
-      await fs19.writeFile(
-        join12(process.cwd(), "jai1-rules.json"),
+      await fs22.writeFile(
+        join13(process.cwd(), "jai1-rules.json"),
         JSON.stringify(projectConfig, null, 2),
         "utf-8"
       );
@@ -12391,9 +13005,44 @@ Detected ${detected.length} active IDE(s):
     console.log("   \u2022 Edit source files in .jai1/rule-preset/ and sync again\n");
   });
 }
+function buildIdeChoices(currentIdes, detected, suggestions) {
+  const choices = [
+    {
+      name: "Cursor (.cursor/rules/)",
+      value: "cursor",
+      checked: currentIdes.includes("cursor") || detected.some((d) => d.id === "cursor")
+    },
+    {
+      name: "Windsurf (.windsurf/rules/)",
+      value: "windsurf",
+      checked: currentIdes.includes("windsurf") || detected.some((d) => d.id === "windsurf")
+    },
+    {
+      name: "Antigravity (.agent/rules/)",
+      value: "antigravity",
+      checked: currentIdes.includes("antigravity") || detected.some((d) => d.id === "antigravity")
+    },
+    {
+      name: "Claude Code (.claude/rules/)",
+      value: "claude",
+      checked: currentIdes.includes("claude") || detected.some((d) => d.id === "claude")
+    },
+    {
+      name: "AGENTS.md (single file)",
+      value: "agentsmd",
+      checked: currentIdes.includes("agentsmd") || detected.some((d) => d.id === "agentsmd")
+    },
+    {
+      name: "Gemini CLI (GEMINI.md)",
+      value: "gemini",
+      checked: currentIdes.includes("gemini") || detected.some((d) => d.id === "gemini")
+    }
+  ];
+  return choices;
+}
 async function checkPathExists(absolutePath) {
   try {
-    await fs19.access(absolutePath);
+    await fs22.access(absolutePath);
     return true;
   } catch {
     return false;
@@ -12401,15 +13050,15 @@ async function checkPathExists(absolutePath) {
 }
 
 // src/commands/rules/info.ts
-import { Command as Command47 } from "commander";
-import { promises as fs20 } from "fs";
-import { join as join13 } from "path";
+import { Command as Command48 } from "commander";
+import { promises as fs23 } from "fs";
+import { join as join14 } 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");
+  return new Command48("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
+    const configPath = join14(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs20.readFile(configPath, "utf-8");
+      const configContent = await fs23.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -12421,14 +13070,14 @@ function createRulesInfoCommand() {
       return;
     }
     console.log("\u{1F4CB} Current Preset Information\n");
-    const rulePresetDir = join13(process.cwd(), ".jai1", "rule-preset");
-    const presetJsonPath = join13(rulePresetDir, "preset.json");
+    const rulePresetDir = join14(process.cwd(), ".jai1", "rule-preset");
+    const presetJsonPath = join14(rulePresetDir, "preset.json");
     let presetMetadata = null;
     let presetFiles = [];
     try {
-      const presetContent = await fs20.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs23.readFile(presetJsonPath, "utf-8");
       presetMetadata = JSON.parse(presetContent);
-      const files = await fs20.readdir(rulePresetDir);
+      const files = await fs23.readdir(rulePresetDir);
       presetFiles = files.filter((f) => f.endsWith(".mdc"));
     } catch {
     }
@@ -12487,9 +13136,9 @@ Available Backups (${projectConfig.backups.length}):`);
     console.log('  \u2022 "jai1 rules apply" - Apply a different preset (replaces current)');
   });
 }
-async function checkPathExists2(path10) {
+async function checkPathExists2(path13) {
   try {
-    await fs20.access(join13(process.cwd(), path10));
+    await fs23.access(join14(process.cwd(), path13));
     return true;
   } catch {
     return false;
@@ -12511,26 +13160,26 @@ async function checkIdeFilesExist(ideId, format) {
 
 // src/commands/rules/index.ts
 function showRulesHelp() {
-  console.log(chalk15.bold.cyan("\u{1F4CB} jai1 rules") + chalk15.dim(" - Qu\u1EA3n l\xFD rule presets cho AI agents"));
+  console.log(chalk17.bold.cyan("\u{1F4CB} jai1 rules") + chalk17.dim(" - Qu\u1EA3n l\xFD rule presets cho AI agents"));
   console.log();
-  console.log(chalk15.bold("C\xE1c l\u1EC7nh:"));
-  console.log(`  ${chalk15.cyan("list")}      Li\u1EC7t k\xEA c\xE1c presets c\xF3 s\u1EB5n`);
-  console.log(`  ${chalk15.cyan("info")}      Xem chi ti\u1EBFt m\u1ED9t preset`);
-  console.log(`  ${chalk15.cyan("init")}      Kh\u1EDFi t\u1EA1o rules t\u1EEB preset`);
-  console.log(`  ${chalk15.cyan("apply")}     \xC1p d\u1EE5ng preset v\xE0o project`);
-  console.log(`  ${chalk15.cyan("sync")}      \u0110\u1ED3ng b\u1ED9 rules v\u1EDBi server`);
-  console.log(`  ${chalk15.cyan("restore")}   Kh\xF4i ph\u1EE5c rules t\u1EEB backup`);
+  console.log(chalk17.bold("C\xE1c l\u1EC7nh:"));
+  console.log(`  ${chalk17.cyan("list")}      Li\u1EC7t k\xEA c\xE1c presets c\xF3 s\u1EB5n`);
+  console.log(`  ${chalk17.cyan("info")}      Xem chi ti\u1EBFt m\u1ED9t preset`);
+  console.log(`  ${chalk17.cyan("init")}      Kh\u1EDFi t\u1EA1o rules t\u1EEB preset`);
+  console.log(`  ${chalk17.cyan("apply")}     \xC1p d\u1EE5ng preset v\xE0o project`);
+  console.log(`  ${chalk17.cyan("sync")}      \u0110\u1ED3ng b\u1ED9 rules v\u1EDBi server`);
+  console.log(`  ${chalk17.cyan("restore")}   Kh\xF4i ph\u1EE5c rules t\u1EEB backup`);
   console.log();
-  console.log(chalk15.bold("V\xED d\u1EE5:"));
-  console.log(chalk15.dim("  $ jai1 rules list"));
-  console.log(chalk15.dim("  $ jai1 rules info react-typescript"));
-  console.log(chalk15.dim("  $ jai1 rules init --preset=react-typescript"));
-  console.log(chalk15.dim("  $ jai1 rules apply react-typescript"));
+  console.log(chalk17.bold("V\xED d\u1EE5:"));
+  console.log(chalk17.dim("  $ jai1 rules list"));
+  console.log(chalk17.dim("  $ jai1 rules info react-typescript"));
+  console.log(chalk17.dim("  $ jai1 rules init --preset=react-typescript"));
+  console.log(chalk17.dim("  $ jai1 rules apply react-typescript"));
   console.log();
-  console.log(chalk15.dim('Ch\u1EA1y "jai1 rules <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
+  console.log(chalk17.dim('Ch\u1EA1y "jai1 rules <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt'));
 }
 function createRulesCommand() {
-  const rulesCommand = new Command48("rules").description("Manage rule presets for AI agents").action(() => {
+  const rulesCommand = new Command49("rules").description("Manage rule presets for AI agents").action(() => {
     showRulesHelp();
   });
   rulesCommand.addCommand(createRulesListCommand());
@@ -12543,10 +13192,10 @@ function createRulesCommand() {
 }
 
 // src/commands/upgrade.ts
-import { Command as Command49 } from "commander";
+import { Command as Command50 } from "commander";
 import { confirm as confirm11 } from "@inquirer/prompts";
-import { execSync as execSync2 } from "child_process";
-var colors4 = {
+import { execSync as execSync4 } from "child_process";
+var colors3 = {
   yellow: "\x1B[33m",
   green: "\x1B[32m",
   cyan: "\x1B[36m",
@@ -12555,7 +13204,7 @@ var colors4 = {
   bold: "\x1B[1m"
 };
 function createUpgradeCommand() {
-  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) => {
+  return new Command50("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);
   });
 }
@@ -12566,7 +13215,7 @@ async function handleUpgrade(options) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
   }
   try {
-    console.log(`${colors4.cyan}\u{1F50D} Checking for updates...${colors4.reset}`);
+    console.log(`${colors3.cyan}\u{1F50D} Checking for updates...${colors3.reset}`);
     const response = await fetch(`${config.apiUrl}/api/versions/client`, {
       headers: {
         "JAI1-Access-Key": config.accessKey
@@ -12581,20 +13230,20 @@ async function handleUpgrade(options) {
     const latestVersion = data.version;
     const currentVersion = package_default.version;
     console.log(`
-${colors4.bold}Current version:${colors4.reset} ${currentVersion}`);
-    console.log(`${colors4.bold}Latest version:${colors4.reset}  ${latestVersion}
+${colors3.bold}Current version:${colors3.reset} ${currentVersion}`);
+    console.log(`${colors3.bold}Latest version:${colors3.reset}  ${latestVersion}
 `);
     if (!isNewerVersion2(latestVersion, currentVersion)) {
-      console.log(`${colors4.green}\u2705 You're already on the latest version!${colors4.reset}
+      console.log(`${colors3.green}\u2705 You're already on the latest version!${colors3.reset}
 `);
       return;
     }
-    console.log(`${colors4.yellow}\u256D\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\u2500\u2500\u2500\u2500\u2500\u256E${colors4.reset}`);
-    console.log(`${colors4.yellow}\u2502${colors4.reset}  ${colors4.bold}\u2B06\uFE0F  Update available!${colors4.reset} ${currentVersion} \u2192 ${colors4.cyan}${latestVersion}${colors4.reset}                  ${colors4.yellow}\u2502${colors4.reset}`);
-    console.log(`${colors4.yellow}\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\u2500\u2500\u2500\u2500\u2500\u256F${colors4.reset}
+    console.log(`${colors3.yellow}\u256D\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\u2500\u2500\u2500\u2500\u2500\u256E${colors3.reset}`);
+    console.log(`${colors3.yellow}\u2502${colors3.reset}  ${colors3.bold}\u2B06\uFE0F  Update available!${colors3.reset} ${currentVersion} \u2192 ${colors3.cyan}${latestVersion}${colors3.reset}                  ${colors3.yellow}\u2502${colors3.reset}`);
+    console.log(`${colors3.yellow}\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\u2500\u2500\u2500\u2500\u2500\u256F${colors3.reset}
 `);
     if (options.check) {
-      console.log(`${colors4.cyan}Run "jai1 upgrade" to install the latest version.${colors4.reset}
+      console.log(`${colors3.cyan}Run "jai1 upgrade" to install the latest version.${colors3.reset}
 `);
       return;
     }
@@ -12604,24 +13253,24 @@ ${colors4.bold}Current version:${colors4.reset} ${currentVersion}`);
         default: true
       });
       if (!shouldUpdate) {
-        console.log(`${colors4.yellow}\u23F8\uFE0F  Upgrade cancelled.${colors4.reset}
+        console.log(`${colors3.yellow}\u23F8\uFE0F  Upgrade cancelled.${colors3.reset}
 `);
         return;
       }
     }
     console.log(`
-${colors4.cyan}\u{1F4E5} Installing latest version...${colors4.reset}
+${colors3.cyan}\u{1F4E5} Installing latest version...${colors3.reset}
 `);
     try {
       const packageManager2 = detectPackageManager();
       const installCommand = getInstallCommand(packageManager2);
-      console.log(`${colors4.cyan}Using ${packageManager2}...${colors4.reset}`);
-      execSync2(installCommand, {
+      console.log(`${colors3.cyan}Using ${packageManager2}...${colors3.reset}`);
+      execSync4(installCommand, {
         stdio: "inherit",
         env: { ...process.env, FORCE_COLOR: "1" }
       });
       console.log(`
-${colors4.green}\u2705 Successfully upgraded to version ${latestVersion}!${colors4.reset}
+${colors3.green}\u2705 Successfully upgraded to version ${latestVersion}!${colors3.reset}
 `);
       trackAction("upgrade", {
         from_version: currentVersion,
@@ -12631,17 +13280,17 @@ ${colors4.green}\u2705 Successfully upgraded to version ${latestVersion}!${color
       disableUpdateCheck();
     } catch (error) {
       console.error(`
-${colors4.red}\u274C Upgrade failed!${colors4.reset}`);
-      console.error(`${colors4.red}Error: ${error instanceof Error ? error.message : "Unknown error"}${colors4.reset}
+${colors3.red}\u274C Upgrade failed!${colors3.reset}`);
+      console.error(`${colors3.red}Error: ${error instanceof Error ? error.message : "Unknown error"}${colors3.reset}
 `);
-      console.error(`${colors4.yellow}\u{1F4A1} You can try manually upgrading with:${colors4.reset}`);
+      console.error(`${colors3.yellow}\u{1F4A1} You can try manually upgrading with:${colors3.reset}`);
       const manualCommands = {
         npm: `npm install -g @jvittechs/jai1-cli@latest`,
         pnpm: `pnpm add -g @jvittechs/jai1-cli@latest`,
         yarn: `yarn global add @jvittechs/jai1-cli@latest`,
         bun: `bun add -g @jvittechs/jai1-cli@latest`
       };
-      console.error(`   ${colors4.cyan}${manualCommands[packageManager]}${colors4.reset}
+      console.error(`   ${colors3.cyan}${manualCommands[packageManager]}${colors3.reset}
 `);
       throw error;
     }
@@ -12665,7 +13314,7 @@ function isNewerVersion2(remote, local) {
 }
 function detectPackageManager() {
   try {
-    const jai1Path = execSync2("which jai1 || where jai1", {
+    const jai1Path = execSync4("which jai1 || where jai1", {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "ignore"]
     }).trim();
@@ -12703,11 +13352,11 @@ function getInstallCommand(packageManager2) {
 }
 
 // src/commands/clean.ts
-import { Command as Command50 } from "commander";
+import { Command as Command51 } from "commander";
 import { confirm as confirm12, select as select7 } from "@inquirer/prompts";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function createCleanCommand() {
-  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) => {
+  return new Command51("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);
   });
 }
@@ -12718,7 +13367,7 @@ async function handleClean(options) {
     {
       name: "Backups",
       description: "Component backup files (.jai1_backup/)",
-      path: join14(cwd, ".jai1_backup"),
+      path: join15(cwd, ".jai1_backup"),
       check: async () => {
         const backups = await service.listBackups(cwd);
         return { exists: backups.length > 0, count: backups.length };
@@ -12820,10 +13469,10 @@ async function cleanTarget(target, skipConfirm) {
 }
 
 // src/commands/redmine/check.ts
-import { Command as Command51 } from "commander";
+import { Command as Command52 } from "commander";
 
 // src/services/redmine-config.service.ts
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { resolve as resolve2 } from "path";
 
 // src/types/redmine.types.ts
@@ -12882,7 +13531,7 @@ var RedmineConfigService = class {
    */
   async load() {
     try {
-      const content = await readFile6(this.configPath, "utf-8");
+      const content = await readFile7(this.configPath, "utf-8");
       const rawConfig = parse(content);
       return RedmineConfigSchema.parse(rawConfig);
     } catch (error) {
@@ -12921,7 +13570,7 @@ var RedmineConfigService = class {
 // src/api.ts
 import { fetch as fetch2 } from "undici";
 import pRetry2 from "p-retry";
-import pLimit3 from "p-limit";
+import pLimit4 from "p-limit";
 var RedmineApiError = class extends Error {
   constructor(message, status, response) {
     super(message);
@@ -12939,10 +13588,10 @@ var RedmineApiClient = class {
     this.baseUrl = config.baseUrl.replace(/\/$/, "");
     this.apiAccessToken = config.apiAccessToken;
     this.retryConfig = config.defaults.retry;
-    this.concurrencyLimit = pLimit3(config.defaults.concurrency);
+    this.concurrencyLimit = pLimit4(config.defaults.concurrency);
   }
-  async request(path10, options = {}) {
-    const url = `${this.baseUrl}${path10}`;
+  async request(path13, options = {}) {
+    const url = `${this.baseUrl}${path13}`;
     const headers = {
       "X-Redmine-API-Key": this.apiAccessToken,
       "Content-Type": "application/json",
@@ -13003,8 +13652,8 @@ var RedmineApiClient = class {
     if (include && include.length > 0) {
       params.append("include", include.join(","));
     }
-    const path10 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
-    return this.request(path10);
+    const path13 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
+    return this.request(path13);
   }
   async getIssues(projectId, options = {}) {
     const params = new URLSearchParams();
@@ -13024,8 +13673,8 @@ var RedmineApiClient = class {
     if (options.updatedSince) {
       params.append("updated_on", `>=${options.updatedSince}`);
     }
-    const path10 = `/issues.json?${params.toString()}`;
-    return this.request(path10);
+    const path13 = `/issues.json?${params.toString()}`;
+    return this.request(path13);
   }
   async getAllIssues(projectId, options = {}) {
     const pageSize = options.pageSize || 100;
@@ -13127,7 +13776,7 @@ async function checkConnectivity(config) {
 
 // src/commands/redmine/check.ts
 function createRedmineCheckCommand() {
-  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) => {
+  const cmd = new Command52("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;
@@ -13155,7 +13804,7 @@ async function handleRedmineCheck(options) {
 }
 
 // src/commands/redmine/sync-issue.ts
-import { Command as Command52 } from "commander";
+import { Command as Command53 } from "commander";
 
 // src/sync-issue.ts
 import { resolve as resolve3, relative } from "path";
@@ -13297,7 +13946,7 @@ function generateFilename(issueId, title, config, existingSlugs = /* @__PURE__ *
 }
 
 // src/file.util.ts
-import { readFile as readFile7, writeFile as writeFile2, mkdir } from "fs/promises";
+import { readFile as readFile8, writeFile as writeFile2, mkdir } from "fs/promises";
 import { dirname as dirname2 } from "path";
 import matter4 from "gray-matter";
 async function ensureDir(filePath) {
@@ -13306,7 +13955,7 @@ async function ensureDir(filePath) {
 }
 async function readMarkdownFile(filePath) {
   try {
-    const content = await readFile7(filePath, "utf-8");
+    const content = await readFile8(filePath, "utf-8");
     return parseMarkdownContent(content);
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -13539,7 +14188,7 @@ function extractIssueIdFromUrl(url) {
 
 // src/commands/redmine/sync-issue.ts
 function createSyncIssueCommand() {
-  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) => {
+  const cmd = new Command53("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;
@@ -13583,7 +14232,7 @@ async function handleSyncIssue(options) {
 }
 
 // src/commands/redmine/sync-project.ts
-import { Command as Command53 } from "commander";
+import { Command as Command54 } from "commander";
 
 // src/sync-project.ts
 async function syncProject(config, options = {}) {
@@ -13653,7 +14302,7 @@ async function syncProject(config, options = {}) {
 
 // src/commands/redmine/sync-project.ts
 function createSyncProjectCommand() {
-  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) => {
+  const cmd = new Command54("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;
@@ -13708,12 +14357,12 @@ async function handleSyncProject(options) {
 }
 
 // src/commands/framework/info.ts
-import { Command as Command54 } from "commander";
-import { promises as fs21 } from "fs";
-import { join as join15 } from "path";
+import { Command as Command55 } from "commander";
+import { promises as fs24 } from "fs";
+import { join as join16 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
-  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) => {
+  const cmd = new Command55("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;
@@ -13724,7 +14373,7 @@ async function handleInfo(options) {
   if (!config) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
   }
-  const frameworkPath = join15(homedir5(), ".jai1", "framework");
+  const frameworkPath = join16(homedir5(), ".jai1", "framework");
   const projectStatus = await getProjectStatus2();
   const info = {
     configPath: configService.getConfigPath(),
@@ -13759,9 +14408,9 @@ function maskKey3(key) {
   return "****" + key.slice(-4);
 }
 async function getProjectStatus2() {
-  const projectJai1 = join15(process.cwd(), ".jai1");
+  const projectJai1 = join16(process.cwd(), ".jai1");
   try {
-    await fs21.access(projectJai1);
+    await fs24.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -13769,10 +14418,10 @@ async function getProjectStatus2() {
 }
 
 // src/commands/self-update.ts
-import { Command as Command55 } from "commander";
+import { Command as Command56 } from "commander";
 import { confirm as confirm13 } from "@inquirer/prompts";
-import { execSync as execSync3 } from "child_process";
-var colors5 = {
+import { execSync as execSync5 } from "child_process";
+var colors4 = {
   yellow: "\x1B[33m",
   green: "\x1B[32m",
   cyan: "\x1B[36m",
@@ -13781,7 +14430,7 @@ var colors5 = {
   bold: "\x1B[1m"
 };
 function createSelfUpdateCommand() {
-  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) => {
+  return new Command56("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);
   });
 }
@@ -13792,7 +14441,7 @@ async function handleSelfUpdate(options) {
     throw new ValidationError('Not initialized. Run "jai1 auth" first.');
   }
   try {
-    console.log(`${colors5.cyan}\u{1F50D} Checking for updates...${colors5.reset}`);
+    console.log(`${colors4.cyan}\u{1F50D} Checking for updates...${colors4.reset}`);
     const response = await fetch(`${config.apiUrl}/api/versions/client`, {
       headers: {
         "JAI1-Access-Key": config.accessKey
@@ -13807,20 +14456,20 @@ async function handleSelfUpdate(options) {
     const latestVersion = data.version;
     const currentVersion = package_default.version;
     console.log(`
-${colors5.bold}Current version:${colors5.reset} ${currentVersion}`);
-    console.log(`${colors5.bold}Latest version:${colors5.reset}  ${latestVersion}
+${colors4.bold}Current version:${colors4.reset} ${currentVersion}`);
+    console.log(`${colors4.bold}Latest version:${colors4.reset}  ${latestVersion}
 `);
     if (!isNewerVersion3(latestVersion, currentVersion)) {
-      console.log(`${colors5.green}\u2705 You're already on the latest version!${colors5.reset}
+      console.log(`${colors4.green}\u2705 You're already on the latest version!${colors4.reset}
 `);
       return;
     }
-    console.log(`${colors5.yellow}\u256D\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\u2500\u2500\u2500\u2500\u2500\u256E${colors5.reset}`);
-    console.log(`${colors5.yellow}\u2502${colors5.reset}  ${colors5.bold}\u2B06\uFE0F  Update available!${colors5.reset} ${currentVersion} \u2192 ${colors5.cyan}${latestVersion}${colors5.reset}                  ${colors5.yellow}\u2502${colors5.reset}`);
-    console.log(`${colors5.yellow}\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\u2500\u2500\u2500\u2500\u2500\u256F${colors5.reset}
+    console.log(`${colors4.yellow}\u256D\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\u2500\u2500\u2500\u2500\u2500\u256E${colors4.reset}`);
+    console.log(`${colors4.yellow}\u2502${colors4.reset}  ${colors4.bold}\u2B06\uFE0F  Update available!${colors4.reset} ${currentVersion} \u2192 ${colors4.cyan}${latestVersion}${colors4.reset}                  ${colors4.yellow}\u2502${colors4.reset}`);
+    console.log(`${colors4.yellow}\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\u2500\u2500\u2500\u2500\u2500\u256F${colors4.reset}
 `);
     if (options.check) {
-      console.log(`${colors5.cyan}Run "jai1 self-update" to install the latest version.${colors5.reset}
+      console.log(`${colors4.cyan}Run "jai1 self-update" to install the latest version.${colors4.reset}
 `);
       return;
     }
@@ -13830,24 +14479,24 @@ ${colors5.bold}Current version:${colors5.reset} ${currentVersion}`);
         default: true
       });
       if (!shouldUpdate) {
-        console.log(`${colors5.yellow}\u23F8\uFE0F  Update cancelled.${colors5.reset}
+        console.log(`${colors4.yellow}\u23F8\uFE0F  Update cancelled.${colors4.reset}
 `);
         return;
       }
     }
     console.log(`
-${colors5.cyan}\u{1F4E5} Installing latest version...${colors5.reset}
+${colors4.cyan}\u{1F4E5} Installing latest version...${colors4.reset}
 `);
     try {
       const packageManager2 = detectPackageManager2();
       const installCommand = getInstallCommand2(packageManager2);
-      console.log(`${colors5.cyan}Using ${packageManager2}...${colors5.reset}`);
-      execSync3(installCommand, {
+      console.log(`${colors4.cyan}Using ${packageManager2}...${colors4.reset}`);
+      execSync5(installCommand, {
         stdio: "inherit",
         env: { ...process.env, FORCE_COLOR: "1" }
       });
       console.log(`
-${colors5.green}\u2705 Successfully updated to version ${latestVersion}!${colors5.reset}
+${colors4.green}\u2705 Successfully updated to version ${latestVersion}!${colors4.reset}
 `);
       trackAction("self_update", {
         from_version: currentVersion,
@@ -13857,11 +14506,11 @@ ${colors5.green}\u2705 Successfully updated to version ${latestVersion}!${colors
       disableUpdateCheck();
     } catch (error) {
       console.error(`
-${colors5.red}\u274C Update failed!${colors5.reset}`);
-      console.error(`${colors5.red}Error: ${error instanceof Error ? error.message : "Unknown error"}${colors5.reset}
+${colors4.red}\u274C Update failed!${colors4.reset}`);
+      console.error(`${colors4.red}Error: ${error instanceof Error ? error.message : "Unknown error"}${colors4.reset}
 `);
-      console.error(`${colors5.yellow}\u{1F4A1} You can try manually updating with:${colors5.reset}`);
-      console.error(`   ${colors5.cyan}npm install -g @jvittechs/jai1-cli@latest${colors5.reset}
+      console.error(`${colors4.yellow}\u{1F4A1} You can try manually updating with:${colors4.reset}`);
+      console.error(`   ${colors4.cyan}npm install -g @jvittechs/jai1-cli@latest${colors4.reset}
 `);
       throw error;
     }
@@ -13889,17 +14538,17 @@ function detectPackageManager2() {
   if (userAgent.includes("yarn")) return "yarn";
   if (userAgent.includes("bun")) return "bun";
   try {
-    execSync3("pnpm --version", { stdio: "ignore" });
+    execSync5("pnpm --version", { stdio: "ignore" });
     return "pnpm";
   } catch {
   }
   try {
-    execSync3("yarn --version", { stdio: "ignore" });
+    execSync5("yarn --version", { stdio: "ignore" });
     return "yarn";
   } catch {
   }
   try {
-    execSync3("bun --version", { stdio: "ignore" });
+    execSync5("bun --version", { stdio: "ignore" });
     return "bun";
   } catch {
   }
@@ -13921,10 +14570,10 @@ function getInstallCommand2(packageManager2) {
 }
 
 // src/commands/clear-backups.ts
-import { Command as Command56 } from "commander";
+import { Command as Command57 } from "commander";
 import { confirm as confirm14 } from "@inquirer/prompts";
 function createClearBackupsCommand() {
-  return new Command56("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command57("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) {
@@ -13949,10 +14598,10 @@ function createClearBackupsCommand() {
 }
 
 // src/commands/vscode/index.ts
-import { Command as Command57 } from "commander";
+import { Command as Command58 } 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 fs25 from "fs/promises";
+import path12 from "path";
 import { existsSync as existsSync3 } from "fs";
 var PERFORMANCE_GROUPS2 = {
   telemetry: {
@@ -14089,7 +14738,7 @@ var PERFORMANCE_GROUPS2 = {
   }
 };
 function createVSCodeCommand() {
-  const vscodeCommand = new Command57("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
+  const vscodeCommand = new Command58("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
   vscodeCommand.action(async () => {
     await interactiveMode2();
   });
@@ -14172,8 +14821,8 @@ async function selectGroupsToApply2(action) {
   }
 }
 async function applyGroups2(groupKeys, action) {
-  const vscodeDir = path9.join(process.cwd(), ".vscode");
-  const settingsPath = path9.join(vscodeDir, "settings.json");
+  const vscodeDir = path12.join(process.cwd(), ".vscode");
+  const settingsPath = path12.join(vscodeDir, "settings.json");
   const invalidGroups = groupKeys.filter((key) => !PERFORMANCE_GROUPS2[key]);
   if (invalidGroups.length > 0) {
     console.log(`
@@ -14182,13 +14831,13 @@ async function applyGroups2(groupKeys, action) {
     return;
   }
   if (!existsSync3(vscodeDir)) {
-    await fs22.mkdir(vscodeDir, { recursive: true });
+    await fs25.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 fs22.readFile(settingsPath, "utf-8");
+      const content = await fs25.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 {
@@ -14228,14 +14877,14 @@ async function applyGroups2(groupKeys, action) {
       }
     }
   }
-  await fs22.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+  await fs25.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 = path9.join(process.cwd(), ".vscode");
-  const settingsPath = path9.join(vscodeDir, "settings.json");
+  const vscodeDir = path12.join(process.cwd(), ".vscode");
+  const settingsPath = path12.join(vscodeDir, "settings.json");
   if (!existsSync3(settingsPath)) {
     console.log("\n\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y file settings.json");
     return;
@@ -14249,7 +14898,7 @@ async function resetSettings2(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs22.unlink(settingsPath);
+    await fs25.unlink(settingsPath);
     console.log("\n\u2705 \u0110\xE3 x\xF3a file settings.json");
   } else {
     await applyGroups2(groupKeys, "disable");
@@ -14260,9 +14909,9 @@ async function resetSettings2(groupKeys) {
 // src/commands/context.ts
 import React43 from "react";
 import { render as render6 } 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"];
@@ -14339,10 +14988,10 @@ async function printStats2() {
 }
 
 // src/commands/migrate-ide.ts
-import { Command as Command59 } from "commander";
+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;
@@ -14449,54 +15098,54 @@ async function runMigrateIde(options) {
 
 // src/utils/help-formatter.ts
 import boxen4 from "boxen";
-import chalk16 from "chalk";
+import chalk18 from "chalk";
 import gradient from "gradient-string";
 import figlet from "figlet";
 function showCustomHelp(version) {
   const title = figlet.textSync("JAI1", { font: "Small" });
   console.log(gradient.pastel(title));
   console.log(
-    boxen4(chalk16.cyan(`Agentic Coding CLI v${version}`), {
+    boxen4(chalk18.cyan(`Agentic Coding CLI v${version}`), {
       padding: { left: 1, right: 1, top: 0, bottom: 0 },
       borderStyle: "round",
       borderColor: "cyan"
     })
   );
-  console.log(chalk16.bold("\n\u{1F527} Thi\u1EBFt l\u1EADp & Th\xF4ng tin"));
+  console.log(chalk18.bold("\n\u{1F527} Thi\u1EBFt l\u1EADp & Th\xF4ng tin"));
   console.log("   auth           X\xE1c th\u1EF1c v\xE0 c\u1EA5u h\xECnh jai1-client");
   console.log("   status         Hi\u1EC3n th\u1ECB tr\u1EA1ng th\xE1i c\u1EA5u h\xECnh");
   console.log("   guide          Trung t\xE2m h\u1ECDc Agentic Coding");
-  console.log(chalk16.bold("\n\u{1F4E6} Qu\u1EA3n l\xFD Components"));
+  console.log(chalk18.bold("\n\u{1F4E6} Qu\u1EA3n l\xFD Components"));
   console.log("   apply          C\xE0i \u0111\u1EB7t components (interactive)");
   console.log("   update         C\u1EADp nh\u1EADt components \u0111\xE3 c\xE0i");
   console.log("   check          Ki\u1EC3m tra c\u1EADp nh\u1EADt t\u1EEB server");
-  console.log(chalk16.bold("\n\u{1F5A5}\uFE0F  IDE & T\xEDch h\u1EE3p"));
+  console.log(chalk18.bold("\n\u{1F5A5}\uFE0F  IDE & T\xEDch h\u1EE3p"));
   console.log("   ide            L\u1EC7nh c\u1EA5u h\xECnh IDE");
   console.log("   chat           Chat AI v\u1EDBi Jai1 LLM Proxy");
   console.log("   openai-keys    Th\xF4ng tin API credentials");
-  console.log(chalk16.bold("\n\u{1F916} AI Tools"));
+  console.log(chalk18.bold("\n\u{1F916} AI Tools"));
   console.log("   translate      D\u1ECBch v\u0103n b\u1EA3n/file b\u1EB1ng AI");
   console.log("   image          T\u1EA1o \u1EA3nh (Coming Soon)");
   console.log("   stats          Th\u1ED1ng k\xEA s\u1EED d\u1EE5ng LLM");
   console.log("   feedback       G\u1EEDi b\xE1o c\xE1o/\u0111\u1EC1 xu\u1EA5t");
-  console.log(chalk16.bold("\n\u{1F4C1} Project"));
+  console.log(chalk18.bold("\n\u{1F4C1} Project"));
   console.log("   kit            Qu\u1EA3n l\xFD starter kits");
   console.log("   rules          Qu\u1EA3n l\xFD rule presets");
   console.log("   deps           Qu\u1EA3n l\xFD dependencies");
   console.log("   redmine        Redmine context sync");
-  console.log(chalk16.bold("\n\u2699\uFE0F  B\u1EA3o tr\xEC"));
+  console.log(chalk18.bold("\n\u2699\uFE0F  B\u1EA3o tr\xEC"));
   console.log("   upgrade        C\u1EADp nh\u1EADt jai1-client");
   console.log("   clean          D\u1ECDn d\u1EB9p cache/backup");
   console.log("   utils          Developer utilities");
-  console.log(chalk16.dim("\nS\u1EED d\u1EE5ng: jai1 [l\u1EC7nh] --help \u0111\u1EC3 xem chi ti\u1EBFt"));
+  console.log(chalk18.dim("\nS\u1EED d\u1EE5ng: jai1 [l\u1EC7nh] --help \u0111\u1EC3 xem chi ti\u1EBFt"));
 }
 function showUnknownCommand(commandName) {
-  console.error(chalk16.red(`\u274C L\u1EC7nh kh\xF4ng t\u1ED3n t\u1EA1i: ${commandName}`));
-  console.error(chalk16.dim("\nG\u1EE3i \xFD: Ch\u1EA1y jai1 --help \u0111\u1EC3 xem danh s\xE1ch l\u1EC7nh"));
+  console.error(chalk18.red(`\u274C L\u1EC7nh kh\xF4ng t\u1ED3n t\u1EA1i: ${commandName}`));
+  console.error(chalk18.dim("\nG\u1EE3i \xFD: Ch\u1EA1y jai1 --help \u0111\u1EC3 xem danh s\xE1ch l\u1EC7nh"));
 }
 
 // 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")) {
@@ -14530,9 +15179,9 @@ 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);