@jvittechs/j 1.0.32 → 1.0.34

package/dist/cli.js

@@ -1,4 +1,11 @@
 #!/usr/bin/env node
+import {
+  ComponentsService,
+  Jai1Error,
+  NetworkError,
+  NotFoundError,
+  ValidationError
+} from "./chunk-XZ7VS36G.js";
 import {
   BLOCKED_ICON,
   PRIORITY_ICONS,
@@ -42,34 +49,7 @@ function checkNodeVersion() {
 }
 
 // src/cli.ts
-import { Command as Command79 } from "commander";
-
-// src/errors/index.ts
-var Jai1Error = class extends Error {
-  constructor(message, exitCode) {
-    super(message);
-    this.exitCode = exitCode;
-    this.name = "Jai1Error";
-  }
-};
-var ValidationError = class extends Jai1Error {
-  constructor(message) {
-    super(message, 2);
-    this.name = "ValidationError";
-  }
-};
-var NotFoundError = class extends Jai1Error {
-  constructor(message) {
-    super(message, 4);
-    this.name = "NotFoundError";
-  }
-};
-var NetworkError = class extends Jai1Error {
-  constructor(message) {
-    super(message, 5);
-    this.name = "NetworkError";
-  }
-};
+import { Command as Command85 } from "commander";
 
 // src/services/error-log.service.ts
 import { promises as fs } from "fs";
@@ -164,12 +144,12 @@ var ErrorLogService = class {
 };
 
 // src/cli.ts
-import { basename as basename4 } from "path";
+import { basename as basename5 } from "path";
 
 // package.json
 var package_default = {
   name: "@jvittechs/j",
-  version: "1.0.32",
+  version: "1.0.34",
   description: "A unified CLI tool for JV-IT TECHS developers to manage Jai1 Framework. Supports both `j` and `jai1` commands. Please contact TeamAI for usage instructions.",
   type: "module",
   bin: {
@@ -612,295 +592,9 @@ async function handleAuth(options) {
 import { Command as Command2 } from "commander";
 import chalk3 from "chalk";
 import boxen2 from "boxen";
-
-// src/services/components.service.ts
 import { promises as fs3 } from "fs";
 import { join as join3 } from "path";
 import { homedir as homedir4 } from "os";
-import { gunzipSync } from "zlib";
-import { createHash } from "crypto";
-var ComponentsService = class {
-  cacheDir;
-  manifestFile;
-  constructor(projectRoot = process.cwd()) {
-    this.cacheDir = join3(homedir4(), ".jai1", "cache");
-    this.manifestFile = join3(projectRoot, ".jai1", "manifest.json");
-  }
-  /**
-   * Expand component paths with special prefixes
-   *
-   * Supported formats:
-   * - Standard paths: "rule-presets/react-spa-zustand", "rules/jai1.md", "workflows/commit-it.md"
-   * - Package prefix: "package:core" -> expands to all components in that package
-   *
-   * @param config - Jai1 config
-   * @param paths - Array of component paths (may include special prefixes)
-   * @returns Array of expanded component paths
-   */
-  async expandPaths(config, paths) {
-    const expandedPaths = [];
-    for (const path13 of paths) {
-      if (path13.startsWith("package:")) {
-        const packageName = path13.substring("package:".length);
-        const components = await this.list(config);
-        if (packageName === "core") {
-          expandedPaths.push(...components.map((c) => c.filepath));
-        } else {
-          console.warn(`Warning: Unknown package '${packageName}', skipping`);
-        }
-      } else {
-        expandedPaths.push(path13);
-      }
-    }
-    return expandedPaths;
-  }
-  /**
-   * List components from API
-   */
-  async list(config, options) {
-    const params = new URLSearchParams();
-    if (options?.tag) params.set("tag", options.tag);
-    if (options?.search) params.set("search", options.search);
-    const url = `${config.apiUrl}/api/components${params.toString() ? "?" + params.toString() : ""}`;
-    const response = await fetch(url, {
-      headers: { "JAI1-Access-Key": config.accessKey }
-    });
-    if (!response.ok) {
-      throw new NetworkError(`Failed to list components: HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data.components;
-  }
-  /**
-   * List available tags
-   */
-  async listTags(config) {
-    const response = await fetch(`${config.apiUrl}/api/tags`, {
-      headers: { "JAI1-Access-Key": config.accessKey }
-    });
-    if (!response.ok) {
-      throw new NetworkError(`Failed to list tags: HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data.tags;
-  }
-  /**
-   * Get single component
-   */
-  async get(config, filepath) {
-    const encodedPath = encodeURIComponent(filepath);
-    const response = await fetch(`${config.apiUrl}/api/components/${encodedPath}`, {
-      headers: { "JAI1-Access-Key": config.accessKey }
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        throw new Error(`Component not found: ${filepath}`);
-      }
-      throw new NetworkError(`Failed to get component: HTTP ${response.status}`);
-    }
-    return await response.json();
-  }
-  /**
-   * Get core components
-   */
-  async getCore(config) {
-    const response = await fetch(`${config.apiUrl}/api/components/core`, {
-      headers: { "JAI1-Access-Key": config.accessKey }
-    });
-    if (!response.ok) {
-      throw new NetworkError(`Failed to get core components: HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data.components;
-  }
-  /**
-   * Download and install a component
-   */
-  async install(config, filepath, targetDir) {
-    const component = await this.get(config, filepath);
-    if (!component.content) {
-      throw new Error(`Component ${filepath} has no content`);
-    }
-    let checksumContent = component.content;
-    if (component.contentType === "bundle" || component.contentType === "zip") {
-      let bundleJson;
-      if (component.contentType === "bundle") {
-        const compressed = Buffer.from(component.content, "base64");
-        bundleJson = gunzipSync(compressed).toString("utf-8");
-        checksumContent = bundleJson;
-      } else {
-        bundleJson = component.content;
-      }
-      const bundle = JSON.parse(bundleJson);
-      const skillDir = join3(targetDir, filepath);
-      await fs3.mkdir(skillDir, { recursive: true });
-      await fs3.writeFile(join3(skillDir, "SKILL.md"), bundle.main);
-      for (const [assetPath, content] of Object.entries(bundle.assets)) {
-        if (assetPath === "SKILL.md") continue;
-        const assetFullPath = join3(skillDir, assetPath);
-        await fs3.mkdir(join3(assetFullPath, ".."), { recursive: true });
-        await fs3.writeFile(assetFullPath, content);
-      }
-    } else if (component.contentType === "rule-preset") {
-      const compressed = Buffer.from(component.content, "base64");
-      const bundleJson = gunzipSync(compressed).toString("utf-8");
-      checksumContent = bundleJson;
-      const bundle = JSON.parse(bundleJson);
-      const presetDir = join3(targetDir, "rule-preset");
-      try {
-        await fs3.rm(presetDir, { recursive: true, force: true });
-      } catch {
-      }
-      await fs3.mkdir(presetDir, { recursive: true });
-      await fs3.writeFile(
-        join3(presetDir, "preset.json"),
-        JSON.stringify(bundle.preset, null, 2)
-      );
-      for (const [filename, content] of Object.entries(bundle.files)) {
-        const filePath = join3(presetDir, filename);
-        await fs3.mkdir(join3(filePath, ".."), { recursive: true });
-        await fs3.writeFile(filePath, content);
-      }
-    } else {
-      if (component.contentType === "markdown") {
-        checksumContent = component.content;
-      }
-      const targetPath = join3(targetDir, filepath);
-      const targetFolder = join3(targetPath, "..");
-      await fs3.mkdir(targetFolder, { recursive: true });
-      await fs3.writeFile(targetPath, component.content);
-    }
-    await this.markInstalled(filepath, component.version, this.calculateChecksum(checksumContent));
-  }
-  /**
-   * Get installed components
-   */
-  async getInstalled() {
-    try {
-      const content = await fs3.readFile(this.manifestFile, "utf-8");
-      return JSON.parse(content);
-    } catch {
-      return {};
-    }
-  }
-  /**
-   * Mark component as installed
-   */
-  async markInstalled(filepath, version, checksum) {
-    const installed = await this.getInstalled();
-    installed[filepath] = {
-      filepath,
-      version,
-      checksum,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      modified: false
-    };
-    await fs3.mkdir(join3(this.manifestFile, ".."), { recursive: true });
-    await fs3.writeFile(this.manifestFile, JSON.stringify(installed, null, 2));
-  }
-  /**
-   * Get checksums for multiple components
-   */
-  async getChecksums(config, filepaths) {
-    const response = await fetch(`${config.apiUrl}/api/components/checksums`, {
-      method: "POST",
-      headers: {
-        "JAI1-Access-Key": config.accessKey,
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ filepaths })
-    });
-    if (!response.ok) {
-      throw new NetworkError(`Failed to get checksums: HTTP ${response.status}`);
-    }
-    const data = await response.json();
-    return data.checksums;
-  }
-  /**
-   * Resolve dependencies recursively
-   */
-  async resolveWithDependencies(config, filepaths) {
-    const resolved = /* @__PURE__ */ new Set();
-    const queue = [...filepaths];
-    const seen = /* @__PURE__ */ new Set();
-    while (queue.length > 0) {
-      const current = queue.shift();
-      if (seen.has(current)) continue;
-      seen.add(current);
-      resolved.add(current);
-      try {
-        const component = await this.get(config, current);
-        if (component.dependencies) {
-          for (const dep of component.dependencies) {
-            if (!dep.filepath) continue;
-            const depPath = typeof dep === "string" ? dep : dep.filepath;
-            if (!seen.has(depPath)) {
-              queue.push(depPath);
-            }
-          }
-        }
-      } catch (error) {
-        console.warn(`Warning: Could not resolve dependencies for ${current}: ${error}`);
-      }
-    }
-    return Array.from(resolved);
-  }
-  /**
-   * Backup component file before update
-   */
-  async backupFile(filepath, targetDir) {
-    const sourcePath = join3(targetDir, filepath);
-    try {
-      await fs3.access(sourcePath);
-    } catch {
-      return null;
-    }
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupDir = join3(targetDir, "..", ".jai1_backup", timestamp);
-    const backupPath = join3(backupDir, filepath);
-    const stats = await fs3.stat(sourcePath);
-    await fs3.mkdir(join3(backupPath, ".."), { recursive: true });
-    if (stats.isDirectory()) {
-      await fs3.cp(sourcePath, backupPath, { recursive: true });
-    } else {
-      await fs3.copyFile(sourcePath, backupPath);
-    }
-    return backupPath;
-  }
-  /**
-   * List all backup directories
-   */
-  async listBackups(projectRoot) {
-    const backupRoot = join3(projectRoot, ".jai1_backup");
-    try {
-      const entries = await fs3.readdir(backupRoot, { withFileTypes: true });
-      return entries.filter((e) => e.isDirectory()).map((e) => e.name).sort().reverse();
-    } catch {
-      return [];
-    }
-  }
-  /**
-   * Clear all backups
-   */
-  async clearBackups(projectRoot) {
-    const backupRoot = join3(projectRoot, ".jai1_backup");
-    try {
-      await fs3.rm(backupRoot, { recursive: true, force: true });
-    } catch (error) {
-    }
-  }
-  /**
-   * Calculate SHA256 checksum (matches server logic)
-   */
-  calculateChecksum(content) {
-    return createHash("sha256").update(content).digest("hex").substring(0, 16);
-  }
-};
-
-// src/commands/status.ts
-import { promises as fs4 } from "fs";
-import { join as join4 } from "path";
-import { homedir as homedir5 } from "os";
 function createStatusCommand() {
   const cmd = new Command2("status").description("Hi\u1EC3n th\u1ECB tr\u1EA1ng th\xE1i c\u1EA5u h\xECnh v\xE0 components").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
     await handleStatus(options);
@@ -914,7 +608,7 @@ async function handleStatus(options) {
     throw new ValidationError(`Not initialized. Run "${getCliName()} auth" first.`);
   }
   const componentsService = new ComponentsService();
-  const frameworkPath = join4(homedir5(), ".jai1", "framework");
+  const frameworkPath = join3(homedir4(), ".jai1", "framework");
   const projectStatus = await getProjectStatus();
   const installedComponents = await componentsService.getInstalled();
   const componentCount = Object.keys(installedComponents).length;
@@ -971,9 +665,9 @@ function maskKey(key) {
   return "****" + key.slice(-4);
 }
 async function getProjectStatus() {
-  const projectJai1 = join4(process.cwd(), ".jai1");
+  const projectJai1 = join3(process.cwd(), ".jai1");
   try {
-    await fs4.access(projectJai1);
+    await fs3.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -992,7 +686,7 @@ import Spinner from "ink-spinner";
 import TextInput from "ink-text-input";
 
 // src/services/migrate-ide.service.ts
-import { promises as fs5 } from "fs";
+import { promises as fs4 } from "fs";
 import path from "path";
 import matter from "gray-matter";
 
@@ -1180,18 +874,18 @@ var MigrateIdeService = class {
     const items = [];
     const presetDir = path.join(this.jai1Path, "rule-preset");
     try {
-      await fs5.access(presetDir);
+      await fs4.access(presetDir);
     } catch {
       return items;
     }
-    const files = await fs5.readdir(presetDir);
+    const files = await fs4.readdir(presetDir);
     for (const file of files) {
       if (!file.endsWith(".md") && !file.endsWith(".mdc")) continue;
       if (file === "preset.json") continue;
       const filepath = path.join(presetDir, file);
-      const stat = await fs5.stat(filepath);
+      const stat = await fs4.stat(filepath);
       if (!stat.isFile()) continue;
-      const content = await fs5.readFile(filepath, "utf-8");
+      const content = await fs4.readFile(filepath, "utf-8");
       let frontmatter = {};
       try {
         const { data } = matter(content);
@@ -1221,17 +915,17 @@ var MigrateIdeService = class {
     const items = [];
     const dirPath = path.join(this.jai1Path, type);
     try {
-      await fs5.access(dirPath);
+      await fs4.access(dirPath);
     } catch {
       return items;
     }
-    const files = await fs5.readdir(dirPath);
+    const files = await fs4.readdir(dirPath);
     for (const file of files) {
       if (!file.endsWith(".md")) continue;
       const filepath = path.join(dirPath, file);
-      const stat = await fs5.stat(filepath);
+      const stat = await fs4.stat(filepath);
       if (!stat.isFile()) continue;
-      const content = await fs5.readFile(filepath, "utf-8");
+      const content = await fs4.readFile(filepath, "utf-8");
       let frontmatter = {};
       try {
         const { data } = matter(content);
@@ -1270,7 +964,7 @@ var MigrateIdeService = class {
       alwaysApply: sourceItem.alwaysApply,
       sourceFile: sourceItem.relativePath
     });
-    const sourceContent = await fs5.readFile(sourceItem.filepath, "utf-8");
+    const sourceContent = await fs4.readFile(sourceItem.filepath, "utf-8");
     const bodyContent = extractBody(sourceContent);
     if (frontmatter) {
       return `${frontmatter}
@@ -1316,7 +1010,7 @@ ${bodyContent}
     try {
       let status = "created";
       try {
-        await fs5.access(agentsPath);
+        await fs4.access(agentsPath);
         status = "updated";
       } catch {
       }
@@ -1325,7 +1019,7 @@ ${bodyContent}
         ""
       ];
       for (const rule of rules) {
-        const content = await fs5.readFile(rule.filepath, "utf-8");
+        const content = await fs4.readFile(rule.filepath, "utf-8");
         const body = extractBody(content);
         if (body.trim()) {
           lines.push(downshiftHeadings(body));
@@ -1333,7 +1027,7 @@ ${bodyContent}
         }
       }
       lines.push("");
-      await fs5.writeFile(agentsPath, lines.join("\n"), "utf-8");
+      await fs4.writeFile(agentsPath, lines.join("\n"), "utf-8");
       return {
         source: {
           type: "rules",
@@ -1379,15 +1073,15 @@ ${bodyContent}
         };
       }
       const targetDir = path.dirname(targetPath);
-      await fs5.mkdir(targetDir, { recursive: true });
+      await fs4.mkdir(targetDir, { recursive: true });
       let status = "created";
       try {
-        await fs5.access(targetPath);
+        await fs4.access(targetPath);
         status = "updated";
       } catch {
       }
       const copiedContent = await this.generateCopiedContent(ide, item);
-      await fs5.writeFile(targetPath, copiedContent, "utf-8");
+      await fs4.writeFile(targetPath, copiedContent, "utf-8");
       return {
         source: item,
         targetIDE: ide,
@@ -2629,7 +2323,7 @@ import { Command as Command7 } from "commander";
 import chalk6 from "chalk";
 
 // src/services/context-scanner.service.ts
-import { promises as fs6 } from "fs";
+import { promises as fs5 } from "fs";
 import path2 from "path";
 import matter2 from "gray-matter";
 
@@ -2850,7 +2544,7 @@ var ContextScannerService = class {
     } else {
       dirPath = path2.join(this.projectPath, config.basePath, relativePath);
       try {
-        await fs6.access(dirPath);
+        await fs5.access(dirPath);
       } catch {
         return [];
       }
@@ -2861,10 +2555,10 @@ var ContextScannerService = class {
       const skillItems = await this.scanSkills(dirPath, ide);
       items.push(...skillItems);
     } else {
-      const files = await fs6.readdir(dirPath);
+      const files = await fs5.readdir(dirPath);
       for (const file of files) {
         const filepath = path2.join(dirPath, file);
-        const stat = await fs6.stat(filepath);
+        const stat = await fs5.stat(filepath);
         if (!stat.isFile()) continue;
         const matchesExtension = extensions.some((ext) => file.endsWith(ext));
         if (!matchesExtension) continue;
@@ -2884,13 +2578,13 @@ var ContextScannerService = class {
   async scanSkills(skillsDir, ide) {
     const items = [];
     try {
-      const entries = await fs6.readdir(skillsDir, { withFileTypes: true });
+      const entries = await fs5.readdir(skillsDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
         const skillPath = path2.join(skillsDir, entry.name);
         const skillFilePath = path2.join(skillPath, "SKILL.md");
         try {
-          await fs6.access(skillFilePath);
+          await fs5.access(skillFilePath);
         } catch {
           continue;
         }
@@ -2925,8 +2619,8 @@ var ContextScannerService = class {
    * Parse a context item from file
    */
   async parseContextItem(filepath, ide, type) {
-    const content = await fs6.readFile(filepath, "utf-8");
-    const stat = await fs6.stat(filepath);
+    const content = await fs5.readFile(filepath, "utf-8");
+    const stat = await fs5.stat(filepath);
     let frontmatter = {};
     let bodyContent = content;
     try {
@@ -3014,7 +2708,7 @@ var ContextScannerService = class {
    */
   async pathExists(filepath) {
     try {
-      await fs6.access(filepath);
+      await fs5.access(filepath);
       return true;
     } catch {
       return false;
@@ -3179,7 +2873,7 @@ function createContextSubcommand() {
 // src/commands/ide/setup.ts
 import { Command as Command8 } from "commander";
 import { checkbox, confirm as confirm2, select } from "@inquirer/prompts";
-import fs7 from "fs/promises";
+import fs6 from "fs/promises";
 import path3 from "path";
 import { existsSync } from "fs";
 
@@ -3431,13 +3125,13 @@ async function applyGroups(groupKeys, action) {
     return;
   }
   if (!existsSync(vscodeDir)) {
-    await fs7.mkdir(vscodeDir, { recursive: true });
+    await fs6.mkdir(vscodeDir, { recursive: true });
     console.log("\u{1F4C1} Created .vscode/ directory");
   }
   let currentSettings = {};
   if (existsSync(settingsPath)) {
     try {
-      const content = await fs7.readFile(settingsPath, "utf-8");
+      const content = await fs6.readFile(settingsPath, "utf-8");
       currentSettings = JSON.parse(content);
       console.log("\u{1F4C4} Read current settings from settings.json");
     } catch {
@@ -3477,7 +3171,7 @@ async function applyGroups(groupKeys, action) {
       }
     }
   }
-  await fs7.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+  await fs6.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
   console.log(`
 \u2705 Updated IDE settings at: ${settingsPath}`);
   console.log("\u{1F4A1} Tip: Restart your IDE to apply changes.");
@@ -3498,7 +3192,7 @@ async function resetSettings(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs7.unlink(settingsPath);
+    await fs6.unlink(settingsPath);
     console.log("\n\u2705 Deleted settings.json file");
   } else {
     await applyGroups(groupKeys, "disable");
@@ -3636,8 +3330,8 @@ async function runSync(options) {
 import { Command as Command10 } from "commander";
 
 // src/services/ide-detection.service.ts
-import { promises as fs8 } from "fs";
-import { join as join5 } from "path";
+import { promises as fs7 } from "fs";
+import { join as join4 } from "path";
 
 // src/config/ide-formats.ts
 var IDE_FORMATS = {
@@ -3749,7 +3443,7 @@ var IdeDetectionService = class {
       confidence: "low"
     };
     if (ideId === "agentsmd") {
-      const agentsPath = join5(this.projectPath, "AGENTS.md");
+      const agentsPath = join4(this.projectPath, "AGENTS.md");
       const exists = await this.pathExists(agentsPath);
       detection.detected = exists;
       if (exists) {
@@ -3761,11 +3455,11 @@ var IdeDetectionService = class {
       return detection;
     }
     if (ideId === "gemini") {
-      const geminiPath = join5(this.projectPath, "GEMINI.md");
+      const geminiPath = join4(this.projectPath, "GEMINI.md");
       const exists = await this.pathExists(geminiPath);
       detection.detected = exists;
       if (exists) {
-        const agentsPath = join5(this.projectPath, "AGENTS.md");
+        const agentsPath = join4(this.projectPath, "AGENTS.md");
         const agentsExists = await this.pathExists(agentsPath);
         if (agentsExists) {
           const customCount = await this.countAgentsMdCustomSections(agentsPath);
@@ -3777,9 +3471,9 @@ var IdeDetectionService = class {
       return detection;
     }
     if (ideId === "opencode") {
-      const agentsPath = join5(this.projectPath, "AGENTS.md");
+      const agentsPath = join4(this.projectPath, "AGENTS.md");
       const hasAgents = await this.pathExists(agentsPath);
-      const commandPath = join5(this.projectPath, ".opencode/command");
+      const commandPath = join4(this.projectPath, ".opencode/command");
       const hasCommands = await this.pathExists(commandPath);
       if (hasAgents) {
         const customCount = await this.countAgentsMdCustomSections(agentsPath);
@@ -3794,7 +3488,7 @@ var IdeDetectionService = class {
       detection.confidence = detection.detected ? hasAgents && hasCommands ? "high" : "medium" : "low";
       return detection;
     }
-    const rulesPath = join5(this.projectPath, format.rulesPath);
+    const rulesPath = join4(this.projectPath, format.rulesPath);
     const rulesExist = await this.pathExists(rulesPath);
     if (rulesExist) {
       const totalRules = await this.countFiles(rulesPath, format.fileExtension);
@@ -3806,7 +3500,7 @@ var IdeDetectionService = class {
       }
     }
     if (format.workflowsPath) {
-      const workflowsPath = join5(this.projectPath, format.workflowsPath);
+      const workflowsPath = join4(this.projectPath, format.workflowsPath);
       const workflowsExist = await this.pathExists(workflowsPath);
       if (workflowsExist) {
         detection.hasWorkflows = true;
@@ -3873,13 +3567,13 @@ var IdeDetectionService = class {
         }
       } else if (ideId === "opencode") {
         const hasAgents = await this.pathExists("AGENTS.md");
-        const commandPath = join5(this.projectPath, ".opencode/command");
+        const commandPath = join4(this.projectPath, ".opencode/command");
         const hasCommands = await this.pathExists(commandPath);
         if (hasAgents || hasCommands) {
           detected.push(ideId);
         }
       } else {
-        const rulesPath = join5(this.projectPath, format.rulesPath);
+        const rulesPath = join4(this.projectPath, format.rulesPath);
         if (await this.pathExists(rulesPath)) {
           const count = await this.countFiles(rulesPath, format.fileExtension);
           if (count > 0) {
@@ -3912,7 +3606,7 @@ var IdeDetectionService = class {
    */
   async pathExists(path13) {
     try {
-      await fs8.access(path13);
+      await fs7.access(path13);
       return true;
     } catch {
       return false;
@@ -3923,7 +3617,7 @@ var IdeDetectionService = class {
    */
   async countFiles(dirPath, extension, excludeKeywords = []) {
     try {
-      const entries = await fs8.readdir(dirPath, { withFileTypes: true });
+      const entries = await fs7.readdir(dirPath, { withFileTypes: true });
       return entries.filter((entry) => {
         if (!entry.isFile() || !entry.name.endsWith(extension)) return false;
         if (excludeKeywords.length > 0) {
@@ -3942,7 +3636,7 @@ var IdeDetectionService = class {
    */
   async countAgentsMdCustomSections(filePath) {
     try {
-      const content = await fs8.readFile(filePath, "utf-8");
+      const content = await fs7.readFile(filePath, "utf-8");
       const h2Headings = content.match(/^## .+$/gm) || [];
       return h2Headings.filter(
         (h) => !h.toLowerCase().includes(DEFAULT_RULE_KEYWORD)
@@ -3962,7 +3656,7 @@ var IdeDetectionService = class {
    */
   async suggestIdes() {
     const suggestions = [];
-    if (await this.pathExists(join5(this.projectPath, ".vscode"))) {
+    if (await this.pathExists(join4(this.projectPath, ".vscode"))) {
       suggestions.push({
         ideId: "cursor",
         name: "Cursor",
@@ -3970,7 +3664,7 @@ var IdeDetectionService = class {
         priority: "high"
       });
     }
-    if (await this.pathExists(join5(this.projectPath, "package.json"))) {
+    if (await this.pathExists(join4(this.projectPath, "package.json"))) {
       suggestions.push({
         ideId: "windsurf",
         name: "Windsurf",
@@ -3984,7 +3678,7 @@ var IdeDetectionService = class {
       reason: "Universal format, works with all IDEs",
       priority: "high"
     });
-    const hasClaudeConfig = await this.pathExists(join5(this.projectPath, ".claude"));
+    const hasClaudeConfig = await this.pathExists(join4(this.projectPath, ".claude"));
     if (hasClaudeConfig) {
       suggestions.push({
         ideId: "claude",
@@ -3993,7 +3687,7 @@ var IdeDetectionService = class {
         priority: "high"
       });
     }
-    const hasOpenCodeConfig = await this.pathExists(join5(this.projectPath, ".opencode"));
+    const hasOpenCodeConfig = await this.pathExists(join4(this.projectPath, ".opencode"));
     if (hasOpenCodeConfig) {
       suggestions.push({
         ideId: "opencode",
@@ -4173,6 +3867,15 @@ function showGuide(name) {
   console.log(`  ${chalk8.cyan(`${name} ide sync`)}        \u0110\u1ED3ng b\u1ED9 .jai1 content \u0111\u1EBFn IDE`);
   console.log(`  ${chalk8.cyan(`${name} rules apply`)}     C\u1EA5u h\xECnh rules cho IDE`);
   console.log();
+  console.log(chalk8.bold("\u2501\u2501\u2501 SKILLS \u2501\u2501\u2501"));
+  console.log(`  ${chalk8.cyan(`${name} s find`)}      ${chalk8.dim("<query>")}                    T\xECm skills tr\xEAn server`);
+  console.log(`  ${chalk8.cyan(`${name} s find`)}      ${chalk8.dim("<query> --skillsh")}           T\xECm tr\xEAn npm skills`);
+  console.log(`  ${chalk8.cyan(`${name} s add`)}       ${chalk8.dim("<name>")}                      C\xE0i skill v\xE0o .jai1/skills/`);
+  console.log(`  ${chalk8.cyan(`${name} s list`)}                                    Skills \u0111\xE3 c\xE0i`);
+  console.log(`  ${chalk8.cyan(`${name} s list`)}      ${chalk8.dim("--available")}                 Skills tr\xEAn server`);
+  console.log(`  ${chalk8.cyan(`${name} s info`)}      ${chalk8.dim("<name>")}                      Chi ti\u1EBFt skill`);
+  console.log(`  ${chalk8.cyan(`${name} s sync`)}      ${chalk8.dim("--all -y")}                    Sync sang t\u1EA5t c\u1EA3 IDEs`);
+  console.log();
   console.log(chalk8.bold("\u2501\u2501\u2501 TASK MANAGEMENT \u2501\u2501\u2501"));
   console.log(`  ${chalk8.cyan(`${name} t add`)}      ${chalk8.dim('"title"')} ${chalk8.dim("[-p 0-3] [-P parent]")}   T\u1EA1o task`);
   console.log(`  ${chalk8.cyan(`${name} t list`)}     ${chalk8.dim("[-s status] [-P parent]")}        Li\u1EC7t k\xEA tasks`);
@@ -4258,8 +3961,8 @@ function showQuickstart(name) {
 // src/commands/doctor.ts
 import { Command as Command14 } from "commander";
 import chalk10 from "chalk";
-import { promises as fs9 } from "fs";
-import { join as join6 } from "path";
+import { promises as fs8 } from "fs";
+import { join as join5 } from "path";
 var CORE_FILES = [
   "workflows/gen-project-overview.md",
   "context/jv-it-context.md",
@@ -4378,9 +4081,9 @@ async function checkAuth(cliName) {
   }
 }
 async function checkCoreFiles(cliName) {
-  const jai1Dir = join6(process.cwd(), ".jai1");
+  const jai1Dir = join5(process.cwd(), ".jai1");
   try {
-    await fs9.access(jai1Dir);
+    await fs8.access(jai1Dir);
   } catch {
     return {
       name: "Core Package",
@@ -4392,9 +4095,9 @@ async function checkCoreFiles(cliName) {
   const missing = [];
   const found = [];
   for (const file of CORE_FILES) {
-    const filePath = join6(jai1Dir, file);
+    const filePath = join5(jai1Dir, file);
     try {
-      await fs9.access(filePath);
+      await fs8.access(filePath);
       found.push(file);
     } catch {
       missing.push(file);
@@ -5157,7 +4860,7 @@ var ChatApp = ({ service, initialModel }) => {
 
 // src/server/web-chat-server.ts
 import http from "http";
-import fs11 from "fs";
+import fs10 from "fs";
 import path5 from "path";
 import { fileURLToPath } from "url";
 
@@ -5291,7 +4994,7 @@ var SessionManager = class {
 };
 
 // src/server/file-service.ts
-import fs10 from "fs";
+import fs9 from "fs";
 import path4 from "path";
 import ignore from "ignore";
 var ALWAYS_EXCLUDED = [
@@ -5500,8 +5203,8 @@ var FileService = class {
     this.ignoreFilter.add(ALWAYS_EXCLUDED);
     const gitignorePath = path4.join(this.workingDir, ".gitignore");
     try {
-      if (fs10.existsSync(gitignorePath)) {
-        const content = fs10.readFileSync(gitignorePath, "utf-8");
+      if (fs9.existsSync(gitignorePath)) {
+        const content = fs9.readFileSync(gitignorePath, "utf-8");
         this.ignoreFilter.add(content);
       }
     } catch {
@@ -5542,7 +5245,7 @@ var FileService = class {
     const searchDir = async (dirPath, depth = 0) => {
       if (depth > 10 || results.length >= maxResults) return;
       try {
-        const entries = await fs10.promises.readdir(dirPath, { withFileTypes: true });
+        const entries = await fs9.promises.readdir(dirPath, { withFileTypes: true });
         for (const entry of entries) {
           if (results.length >= maxResults) break;
           const entryPath = path4.join(dirPath, entry.name);
@@ -5552,7 +5255,7 @@ var FileService = class {
           if (normalizedRelPath.includes(normalizedQuery)) {
             if (entry.isFile() && isTextFile(entry.name)) {
               try {
-                const stat = await fs10.promises.stat(entryPath);
+                const stat = await fs9.promises.stat(entryPath);
                 results.push({
                   path: relativePath,
                   name: entry.name,
@@ -5592,14 +5295,14 @@ var FileService = class {
     if (!isTextFile(absolutePath)) {
       throw new Error("Only text files can be read");
     }
-    const stat = await fs10.promises.stat(absolutePath);
+    const stat = await fs9.promises.stat(absolutePath);
     if (!stat.isFile()) {
       throw new Error("Path is not a file");
     }
     if (stat.size > this.maxFileSize) {
       throw new Error(`File exceeds maximum size of ${Math.round(this.maxFileSize / 1024)}KB`);
     }
-    const content = await fs10.promises.readFile(absolutePath, "utf-8");
+    const content = await fs9.promises.readFile(absolutePath, "utf-8");
     return {
       path: normalizedRelPath,
       content,
@@ -5729,14 +5432,14 @@ function createWebChatServer(options) {
       return;
     }
     try {
-      const stat = await fs11.promises.stat(fullPath);
+      const stat = await fs10.promises.stat(fullPath);
       if (!stat.isFile()) {
         sendError(res, 404, "ERR-WC-007", "Not found");
         return;
       }
       const ext = path5.extname(fullPath);
       const contentType = MIME_TYPES[ext] || "application/octet-stream";
-      const content = await fs11.promises.readFile(fullPath);
+      const content = await fs10.promises.readFile(fullPath);
       res.writeHead(200, { "Content-Type": contentType });
       res.end(content);
     } catch (error) {
@@ -6310,7 +6013,7 @@ function createStatsCommand() {
 import { Command as Command18 } from "commander";
 
 // src/services/translation.service.ts
-import { promises as fs12 } from "fs";
+import { promises as fs11 } from "fs";
 import path6 from "path";
 import pLimit from "p-limit";
 import pRetry from "p-retry";
@@ -6329,7 +6032,7 @@ var TranslationService = class {
    */
   async detectInputType(input5) {
     try {
-      const stat = await fs12.stat(input5);
+      const stat = await fs11.stat(input5);
       if (stat.isDirectory()) return "folder";
       if (stat.isFile()) return "file";
     } catch {
@@ -6366,13 +6069,13 @@ var TranslationService = class {
    */
   async translateFile(filePath) {
     try {
-      const content = await fs12.readFile(filePath, "utf-8");
+      const content = await fs11.readFile(filePath, "utf-8");
       const ext = path6.extname(filePath).toLowerCase();
       const fileType = this.getFileType(ext);
       const translatedContent = await this.translateWithRetry(content, fileType);
       const outputPath = this.generateOutputPath(filePath);
       if (!this.options.dryRun) {
-        await fs12.writeFile(outputPath, translatedContent, "utf-8");
+        await fs11.writeFile(outputPath, translatedContent, "utf-8");
       }
       return {
         inputPath: filePath,
@@ -6437,7 +6140,7 @@ var TranslationService = class {
    * Discover translatable files in folder recursively
    */
   async discoverFiles(folderPath) {
-    const entries = await fs12.readdir(folderPath, { withFileTypes: true });
+    const entries = await fs11.readdir(folderPath, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
       const fullPath = path6.join(folderPath, entry.name);
@@ -6970,20 +6673,20 @@ function createImageCommand() {
 import { Command as Command24 } from "commander";
 import { select as select2, input, confirm as confirm5 } from "@inquirer/prompts";
 import os from "os";
-import { promises as fs13 } from "fs";
-import { join as join7 } from "path";
+import { promises as fs12 } from "fs";
+import { join as join6 } from "path";
 async function collectContext() {
   const context = {
     os: `${os.platform()} ${os.release()}`
   };
   try {
     const packageJsonPath = new URL("../../package.json", import.meta.url);
-    const packageJson = JSON.parse(await fs13.readFile(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(await fs12.readFile(packageJsonPath, "utf-8"));
     context.cli_version = packageJson.version;
   } catch {
   }
   try {
-    const projectPackageJson = await fs13.readFile(join7(process.cwd(), "package.json"), "utf-8");
+    const projectPackageJson = await fs12.readFile(join6(process.cwd(), "package.json"), "utf-8");
     const projectData = JSON.parse(projectPackageJson);
     context.project_name = projectData.name;
   } catch {
@@ -7186,8 +6889,8 @@ function createFeedbackCommand() {
 import { Command as Command25 } from "commander";
 import { confirm as confirm6 } from "@inquirer/prompts";
 import os2 from "os";
-import { promises as fs14 } from "fs";
-import { basename as basename2, join as join8 } from "path";
+import { promises as fs13 } from "fs";
+import { basename as basename2, join as join7 } from "path";
 import { version as nodeVersion2 } from "process";
 function createClientInfoCommand() {
   const cmd = new Command25("client-info").description("T\u1EA1o th\xF4ng tin client \u0111\u1EC3 g\u1EEDi \u0111\u1ED9i ph\xE1t tri\u1EC3n jai1").option("--json", "Output as JSON").option("--full", "Include component list (top 20)").option("--submit", "Submit client info to Jai1 feedback endpoint").option("--message <text>", "Additional message when submitting").option("--show-paths", "Include full project path").action(async (options) => {
@@ -7302,9 +7005,9 @@ async function collectClientInfo(config, options) {
   return payload;
 }
 async function hasProjectJai1() {
-  const projectJai1 = join8(process.cwd(), ".jai1");
+  const projectJai1 = join7(process.cwd(), ".jai1");
   try {
-    await fs14.access(projectJai1);
+    await fs13.access(projectJai1);
     return true;
   } catch {
     return false;
@@ -9653,7 +9356,7 @@ var HttpView = () => {
 import React23, { useState as useState17 } from "react";
 import { Box as Box19, Text as Text20, useInput as useInput15 } from "ink";
 import TextInput14 from "ink-text-input";
-import * as fs15 from "fs";
+import * as fs14 from "fs";
 import * as path7 from "path";
 var MarkdownView = () => {
   const [filePath, setFilePath] = useState17("");
@@ -9675,11 +9378,11 @@ var MarkdownView = () => {
     try {
       setError("");
       const resolvedPath = path7.resolve(filePath);
-      if (!fs15.existsSync(resolvedPath)) {
+      if (!fs14.existsSync(resolvedPath)) {
         setError(`File not found: ${resolvedPath}`);
         return;
       }
-      let fileContent = fs15.readFileSync(resolvedPath, "utf-8");
+      let fileContent = fs14.readFileSync(resolvedPath, "utf-8");
       fileContent = fileContent.replace(/```mermaid\n([\s\S]*?)```/g, (match, code) => {
         return `
 \u{1F3A8} **Mermaid Diagram**
@@ -9989,7 +9692,7 @@ import Table4 from "cli-table3";
 import ora from "ora";
 
 // src/services/deps-detector.service.ts
-import * as fs16 from "fs/promises";
+import * as fs15 from "fs/promises";
 import * as path8 from "path";
 var DepsDetectorService = class {
   /**
@@ -10057,7 +9760,7 @@ var DepsDetectorService = class {
   async detectLaravel(cwd) {
     try {
       const composerPath = path8.join(cwd, "composer.json");
-      const content = await fs16.readFile(composerPath, "utf-8");
+      const content = await fs15.readFile(composerPath, "utf-8");
       const composerJson = JSON.parse(content);
       const deps = {
         ...composerJson.require,
@@ -10073,7 +9776,7 @@ var DepsDetectorService = class {
    */
   async fileExists(cwd, filename) {
     try {
-      await fs16.access(path8.join(cwd, filename));
+      await fs15.access(path8.join(cwd, filename));
       return true;
     } catch {
       return false;
@@ -10082,7 +9785,7 @@ var DepsDetectorService = class {
 };
 
 // src/services/deps.service.ts
-import { promises as fs17 } from "fs";
+import { promises as fs16 } from "fs";
 import path9 from "path";
 import { execSync } from "child_process";
 import pLimit2 from "p-limit";
@@ -10119,7 +9822,7 @@ var DepsService = class {
   async readPackageJson(cwd) {
     const pkgPath = path9.join(cwd, "package.json");
     try {
-      const content = await fs17.readFile(pkgPath, "utf-8");
+      const content = await fs16.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -10210,7 +9913,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs17.access(path9.join(cwd, file));
+        await fs16.access(path9.join(cwd, file));
         return pm;
       } catch {
       }
@@ -10281,7 +9984,7 @@ var DepsService = class {
 
 // src/services/deps-php.service.ts
 import { execSync as execSync2 } from "child_process";
-import { promises as fs18 } from "fs";
+import { promises as fs17 } from "fs";
 import path10 from "path";
 var LARAVEL_PROTECTED_PACKAGES = /^laravel\//;
 var DepsPhpService = class {
@@ -10341,7 +10044,7 @@ var DepsPhpService = class {
   async readComposerJson(cwd) {
     const composerPath = path10.join(cwd, "composer.json");
     try {
-      const content = await fs18.readFile(composerPath, "utf-8");
+      const content = await fs17.readFile(composerPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -10403,7 +10106,7 @@ var DepsPhpService = class {
 
 // src/services/deps-python.service.ts
 import { execSync as execSync3 } from "child_process";
-import { promises as fs19 } from "fs";
+import { promises as fs18 } from "fs";
 import path11 from "path";
 import pLimit3 from "p-limit";
 var DepsPythonService = class {
@@ -10454,7 +10157,7 @@ var DepsPythonService = class {
   async checkPip(cwd, onProgress) {
     const requirementsPath = path11.join(cwd, "requirements.txt");
     try {
-      const content = await fs19.readFile(requirementsPath, "utf-8");
+      const content = await fs18.readFile(requirementsPath, "utf-8");
       const packages = this.parseRequirementsTxt(content);
       return await this.fetchBulkVersions(packages, onProgress);
     } catch (error) {
@@ -10566,7 +10269,7 @@ var DepsPythonService = class {
   }
   async fileExists(cwd, filename) {
     try {
-      await fs19.access(path11.join(cwd, filename));
+      await fs18.access(path11.join(cwd, filename));
       return true;
     } catch {
       return false;
@@ -11414,8 +11117,8 @@ import chalk30 from "chalk";
 import Table6 from "cli-table3";
 
 // src/services/starter-kit.service.ts
-import { promises as fs20 } from "fs";
-import { join as join10 } from "path";
+import { promises as fs19 } from "fs";
+import { join as join9 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
   /**
@@ -11462,17 +11165,17 @@ var StarterKitService = class {
       throw new NetworkError(`Failed to download kit: HTTP ${response.status}`);
     }
     if (onProgress) onProgress(30);
-    const tmpDir = join10(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs20.mkdir(tmpDir, { recursive: true });
-    const tmpFile = join10(tmpDir, `${slug}.zip`);
+    const tmpDir = join9(process.env.TMPDIR || "/tmp", "jai1-kits");
+    await fs19.mkdir(tmpDir, { recursive: true });
+    const tmpFile = join9(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs20.writeFile(tmpFile, Buffer.from(buffer));
+    await fs19.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs20.mkdir(targetDir, { recursive: true });
+    await fs19.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs20.unlink(tmpFile);
+    await fs19.unlink(tmpFile);
   }
 };
 
@@ -11596,8 +11299,8 @@ Post-Init Commands:`);
 
 // src/commands/kit/create.ts
 import { Command as Command60 } from "commander";
-import { promises as fs21 } from "fs";
-import { join as join11 } from "path";
+import { promises as fs20 } from "fs";
+import { join as join10 } from "path";
 import { select as select3, input as input2, checkbox as checkbox4 } from "@inquirer/prompts";
 import { execa as execa2 } from "execa";
 
@@ -11660,9 +11363,9 @@ function createKitCreateCommand() {
         }
       }
     }
-    const targetDir = directory || join11(process.cwd(), options.name || slug);
+    const targetDir = directory || join10(process.cwd(), options.name || slug);
     try {
-      await fs21.access(targetDir);
+      await fs20.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -11725,7 +11428,7 @@ function createKitCreateCommand() {
       );
       for (const filepath of expandedPaths) {
         console.log(`   \u{1F4E5} Installing ${filepath}...`);
-        await componentsService.install(config, filepath, join11(targetDir, ".jai1"));
+        await componentsService.install(config, filepath, join10(targetDir, ".jai1"));
       }
       console.log("   \u2713 Framework components applied");
     }
@@ -11787,7 +11490,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs21.readFile(file, "utf-8");
+    let content = await fs20.readFile(file, "utf-8");
     let modified = false;
     for (const [key, value] of Object.entries(variables)) {
       const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
@@ -11797,15 +11500,15 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs21.writeFile(file, content, "utf-8");
+      await fs20.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs21.readdir(dir, { withFileTypes: true });
+  const entries = await fs20.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = join11(dir, entry.name);
+    const fullPath = join10(dir, entry.name);
     if (entry.isDirectory()) {
       if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
         files.push(...await getAllFiles(fullPath));
@@ -11920,28 +11623,28 @@ function createRulesListCommand() {
 
 // src/commands/rules/init.ts
 import { Command as Command63 } from "commander";
-import { promises as fs23 } from "fs";
-import { join as join13 } from "path";
+import { promises as fs22 } from "fs";
+import { join as join12 } from "path";
 import { select as select4, confirm as confirm10 } from "@inquirer/prompts";
 
 // src/services/project-config.service.ts
-import { promises as fs22 } from "fs";
-import { join as join12 } from "path";
+import { promises as fs21 } from "fs";
+import { join as join11 } from "path";
 var ProjectConfigService = class {
   projectRoot;
   configDir;
   configPath;
   constructor(projectRoot = process.cwd()) {
     this.projectRoot = projectRoot;
-    this.configDir = join12(this.projectRoot, ".jai1");
-    this.configPath = join12(this.configDir, "project.json");
+    this.configDir = join11(this.projectRoot, ".jai1");
+    this.configPath = join11(this.configDir, "project.json");
   }
   /**
    * Check if config file exists
    */
   async exists() {
     try {
-      await fs22.access(this.configPath);
+      await fs21.access(this.configPath);
       return true;
     } catch {
       return false;
@@ -11956,7 +11659,7 @@ var ProjectConfigService = class {
       return null;
     }
     try {
-      const content = await fs22.readFile(this.configPath, "utf-8");
+      const content = await fs21.readFile(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       throw new Error(
@@ -11970,8 +11673,8 @@ var ProjectConfigService = class {
    */
   async save(config) {
     try {
-      await fs22.mkdir(this.configDir, { recursive: true });
-      await fs22.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      await fs21.mkdir(this.configDir, { recursive: true });
+      await fs21.writeFile(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       throw new Error(
         `Failed to save project config: ${error instanceof Error ? error.message : String(error)}`
@@ -12140,11 +11843,11 @@ function createRulesInitCommand() {
   });
 }
 async function applyCursorFormat(bundle) {
-  const rulesDir = join13(process.cwd(), ".cursor", "rules");
-  await fs23.mkdir(rulesDir, { recursive: true });
+  const rulesDir = join12(process.cwd(), ".cursor", "rules");
+  await fs22.mkdir(rulesDir, { recursive: true });
   for (const [filename, content] of Object.entries(bundle.files)) {
-    const filePath = join13(rulesDir, filename);
-    await fs23.writeFile(filePath, content, "utf-8");
+    const filePath = join12(rulesDir, filename);
+    await fs22.writeFile(filePath, content, "utf-8");
     console.log(`\u2713 Created .cursor/rules/${filename}`);
   }
 }
@@ -12171,14 +11874,14 @@ async function applyAgentsMdFormat(bundle) {
     }
   }
   const agentsMd = sections.join("\n");
-  await fs23.writeFile("AGENTS.md", agentsMd, "utf-8");
+  await fs22.writeFile("AGENTS.md", agentsMd, "utf-8");
   console.log("\u2713 Created AGENTS.md");
 }
 
 // src/commands/rules/apply.ts
 import { Command as Command64 } from "commander";
-import { promises as fs25 } from "fs";
-import { join as join15 } from "path";
+import { promises as fs24 } from "fs";
+import { join as join14 } from "path";
 import { search, confirm as confirm11, checkbox as checkbox5 } from "@inquirer/prompts";
 
 // src/services/rules-generator.service.ts
@@ -12469,8 +12172,8 @@ Follow all instructions and patterns defined in AGENTS.md above.
 };
 
 // src/services/backup.service.ts
-import { promises as fs24 } from "fs";
-import { join as join14, dirname } from "path";
+import { promises as fs23 } from "fs";
+import { join as join13, dirname } from "path";
 var BackupService = class {
   backupDir = ".jai1/backups";
   /**
@@ -12478,7 +12181,7 @@ var BackupService = class {
    */
   async createBackup(ides, presetSlug) {
     const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const backupPath = join14(this.backupDir, timestamp);
+    const backupPath = join13(this.backupDir, timestamp);
     const backedUpFiles = [];
     let hasContent = false;
     for (const ideId of ides) {
@@ -12487,7 +12190,7 @@ var BackupService = class {
         console.warn(`Unknown IDE format: ${ideId}, skipping backup`);
         continue;
       }
-      const rulesPath = format.rulesPath === "." ? process.cwd() : join14(process.cwd(), format.rulesPath);
+      const rulesPath = format.rulesPath === "." ? process.cwd() : join13(process.cwd(), format.rulesPath);
       try {
         const exists = await this.pathExists(rulesPath);
         if (!exists) {
@@ -12500,19 +12203,19 @@ var BackupService = class {
           await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
           hasContent = true;
         } else {
-          const stats = await fs24.stat(rulesPath);
+          const stats = await fs23.stat(rulesPath);
           if (stats.isDirectory()) {
-            const files = await fs24.readdir(rulesPath);
+            const files = await fs23.readdir(rulesPath);
             for (const file of files) {
               if (file.endsWith(format.fileExtension)) {
-                const originalPath = join14(rulesPath, file);
-                const relativePath = join14(format.rulesPath, file);
-                const destPath = join14(backupPath, ideId, file);
-                await fs24.mkdir(dirname(destPath), { recursive: true });
-                await fs24.copyFile(originalPath, destPath);
+                const originalPath = join13(rulesPath, file);
+                const relativePath = join13(format.rulesPath, file);
+                const destPath = join13(backupPath, ideId, file);
+                await fs23.mkdir(dirname(destPath), { recursive: true });
+                await fs23.copyFile(originalPath, destPath);
                 backedUpFiles.push({
                   originalPath: relativePath,
-                  backupPath: join14(ideId, file),
+                  backupPath: join13(ideId, file),
                   ide: ideId
                 });
                 hasContent = true;
@@ -12533,9 +12236,9 @@ var BackupService = class {
       ides,
       files: backedUpFiles
     };
-    await fs24.mkdir(backupPath, { recursive: true });
-    await fs24.writeFile(
-      join14(backupPath, "metadata.json"),
+    await fs23.mkdir(backupPath, { recursive: true });
+    await fs23.writeFile(
+      join13(backupPath, "metadata.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
     );
@@ -12545,18 +12248,18 @@ var BackupService = class {
    * Backup a single file (for AGENTS.md, GEMINI.md)
    */
   async backupSingleFile(filename, backupPath, ideId, backedUpFiles) {
-    const originalPath = join14(process.cwd(), filename);
+    const originalPath = join13(process.cwd(), filename);
     try {
       const exists = await this.pathExists(originalPath);
       if (!exists) {
         return;
       }
-      const destPath = join14(backupPath, ideId, filename);
-      await fs24.mkdir(dirname(destPath), { recursive: true });
-      await fs24.copyFile(originalPath, destPath);
+      const destPath = join13(backupPath, ideId, filename);
+      await fs23.mkdir(dirname(destPath), { recursive: true });
+      await fs23.copyFile(originalPath, destPath);
       backedUpFiles.push({
         originalPath: filename,
-        backupPath: join14(ideId, filename),
+        backupPath: join13(ideId, filename),
         ide: ideId
       });
     } catch (error) {
@@ -12566,16 +12269,16 @@ var BackupService = class {
    * Restore files from a backup
    */
   async restoreBackup(backupPath) {
-    const metadataPath = join14(backupPath, "metadata.json");
-    const metadataContent = await fs24.readFile(metadataPath, "utf-8");
+    const metadataPath = join13(backupPath, "metadata.json");
+    const metadataContent = await fs23.readFile(metadataPath, "utf-8");
     const metadata = JSON.parse(metadataContent);
     console.log(`
 Restoring backup from ${metadata.timestamp}...`);
     for (const file of metadata.files) {
-      const sourcePath = join14(backupPath, file.backupPath);
-      const destPath = join14(process.cwd(), file.originalPath);
-      await fs24.mkdir(dirname(destPath), { recursive: true });
-      await fs24.copyFile(sourcePath, destPath);
+      const sourcePath = join13(backupPath, file.backupPath);
+      const destPath = join13(process.cwd(), file.originalPath);
+      await fs23.mkdir(dirname(destPath), { recursive: true });
+      await fs23.copyFile(sourcePath, destPath);
       console.log(`\u2713 Restored ${file.originalPath}`);
     }
     console.log("\n\u2705 Backup restored successfully!");
@@ -12585,18 +12288,18 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async listBackups() {
     try {
-      const backupDirPath = join14(process.cwd(), this.backupDir);
+      const backupDirPath = join13(process.cwd(), this.backupDir);
       const exists = await this.pathExists(backupDirPath);
       if (!exists) {
         return [];
       }
-      const entries = await fs24.readdir(backupDirPath, { withFileTypes: true });
+      const entries = await fs23.readdir(backupDirPath, { withFileTypes: true });
       const backups = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const metadataPath = join14(backupDirPath, entry.name, "metadata.json");
+          const metadataPath = join13(backupDirPath, entry.name, "metadata.json");
           try {
-            const metadataContent = await fs24.readFile(metadataPath, "utf-8");
+            const metadataContent = await fs23.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(metadataContent);
             backups.push(metadata);
           } catch {
@@ -12613,7 +12316,7 @@ Restoring backup from ${metadata.timestamp}...`);
    * Delete a specific backup
    */
   async deleteBackup(timestamp) {
-    const backupPath = join14(process.cwd(), this.backupDir, timestamp);
+    const backupPath = join13(process.cwd(), this.backupDir, timestamp);
     await this.deleteDirectory(backupPath);
   }
   /**
@@ -12645,7 +12348,7 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async pathExists(path13) {
     try {
-      await fs24.access(path13);
+      await fs23.access(path13);
       return true;
     } catch {
       return false;
@@ -12660,16 +12363,16 @@ Restoring backup from ${metadata.timestamp}...`);
       if (!exists) {
         return;
       }
-      const entries = await fs24.readdir(path13, { withFileTypes: true });
+      const entries = await fs23.readdir(path13, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join14(path13, entry.name);
+        const fullPath = join13(path13, entry.name);
         if (entry.isDirectory()) {
           await this.deleteDirectory(fullPath);
         } else {
-          await fs24.unlink(fullPath);
+          await fs23.unlink(fullPath);
         }
       }
-      await fs24.rmdir(path13);
+      await fs23.rmdir(path13);
     } catch (error) {
     }
   }
@@ -12677,14 +12380,14 @@ Restoring backup from ${metadata.timestamp}...`);
    * Get backup directory path
    */
   getBackupDir() {
-    return join14(process.cwd(), this.backupDir);
+    return join13(process.cwd(), this.backupDir);
   }
   /**
    * Ensure backup directory exists
    */
   async ensureBackupDir() {
-    const backupDirPath = join14(process.cwd(), this.backupDir);
-    await fs24.mkdir(backupDirPath, { recursive: true });
+    const backupDirPath = join13(process.cwd(), this.backupDir);
+    await fs23.mkdir(backupDirPath, { recursive: true });
   }
 };
 
@@ -12856,21 +12559,21 @@ function createRulesApplyCommand() {
       }
     }
     console.log("\n\u{1F4DD} Applying preset...\n");
-    const rulePresetDir = join15(process.cwd(), ".jai1", "rule-preset");
+    const rulePresetDir = join14(process.cwd(), ".jai1", "rule-preset");
     try {
-      await fs25.rm(rulePresetDir, { recursive: true, force: true });
+      await fs24.rm(rulePresetDir, { recursive: true, force: true });
     } catch {
     }
-    await fs25.mkdir(rulePresetDir, { recursive: true });
-    await fs25.writeFile(
-      join15(rulePresetDir, "preset.json"),
+    await fs24.mkdir(rulePresetDir, { recursive: true });
+    await fs24.writeFile(
+      join14(rulePresetDir, "preset.json"),
       JSON.stringify(bundle.preset, null, 2),
       "utf-8"
     );
     for (const [filename, content] of Object.entries(bundle.files)) {
-      const filePath = join15(rulePresetDir, filename);
-      await fs25.mkdir(join15(filePath, ".."), { recursive: true });
-      await fs25.writeFile(filePath, content, "utf-8");
+      const filePath = join14(rulePresetDir, filename);
+      await fs24.mkdir(join14(filePath, ".."), { recursive: true });
+      await fs24.writeFile(filePath, content, "utf-8");
     }
     console.log(`\u2713 Saved preset to .jai1/rule-preset/`);
     const allGeneratedFiles = [];
@@ -12878,9 +12581,9 @@ function createRulesApplyCommand() {
       try {
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
-          const fullPath = join15(process.cwd(), file.path);
-          await fs25.mkdir(join15(fullPath, ".."), { recursive: true });
-          await fs25.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join14(process.cwd(), file.path);
+          await fs24.mkdir(join14(fullPath, ".."), { recursive: true });
+          await fs24.writeFile(fullPath, file.content, "utf-8");
           console.log(`\u2713 [${ideId}] ${file.path}`);
           allGeneratedFiles.push({
             ide: ideId,
@@ -12986,7 +12689,7 @@ function createRulesApplyCommand() {
 
 // src/commands/rules/restore.ts
 import { Command as Command65 } from "commander";
-import { join as join16 } from "path";
+import { join as join15 } from "path";
 import { select as select5, confirm as confirm12 } from "@inquirer/prompts";
 function createRulesRestoreCommand() {
   return new Command65("restore").description("Restore rules from a backup").option("--latest", "Restore the most recent backup").option("-y, --yes", "Skip confirmation").action(async (options) => {
@@ -13033,7 +12736,7 @@ function createRulesRestoreCommand() {
     }
     console.log("\n\u{1F504} Restoring backup...\n");
     try {
-      const backupPath = join16(backupService.getBackupDir(), selectedBackup.timestamp);
+      const backupPath = join15(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.");
@@ -13059,17 +12762,17 @@ function formatTimestamp(timestamp) {
 
 // src/commands/rules/sync.ts
 import { Command as Command66 } from "commander";
-import { promises as fs26 } from "fs";
-import { join as join17 } from "path";
+import { promises as fs25 } from "fs";
+import { join as join16 } from "path";
 import { checkbox as checkbox6, confirm as confirm13, Separator } from "@inquirer/prompts";
 function createRulesSyncCommand() {
   return new Command66("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 rulePresetDir = join17(process.cwd(), ".jai1", "rule-preset");
-    const presetJsonPath = join17(rulePresetDir, "preset.json");
+    const rulePresetDir = join16(process.cwd(), ".jai1", "rule-preset");
+    const presetJsonPath = join16(rulePresetDir, "preset.json");
     let presetExists = false;
     let presetData = null;
     try {
-      const presetContent = await fs26.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs25.readFile(presetJsonPath, "utf-8");
       presetData = JSON.parse(presetContent);
       presetExists = true;
     } catch {
@@ -13199,11 +12902,11 @@ Current IDE(s): ${currentIdes.join(", ") || "none"}`);
       throw new Error(`Failed to fetch preset: ${presetResponse.statusText}`);
     }
     const bundle = await presetResponse.json();
-    const files = await fs26.readdir(rulePresetDir);
+    const files = await fs25.readdir(rulePresetDir);
     for (const file of files) {
       if (file.endsWith(".mdc") || file.endsWith(".md")) {
-        const filePath = join17(rulePresetDir, file);
-        const content = await fs26.readFile(filePath, "utf-8");
+        const filePath = join16(rulePresetDir, file);
+        const content = await fs25.readFile(filePath, "utf-8");
         bundle.files[file] = content;
       }
     }
@@ -13217,9 +12920,9 @@ Current IDE(s): ${currentIdes.join(", ") || "none"}`);
         }
         const files2 = generatorService.generateForIde(bundle, ideId);
         for (const file of files2) {
-          const fullPath = join17(process.cwd(), file.path);
-          await fs26.mkdir(join17(fullPath, ".."), { recursive: true });
-          await fs26.writeFile(fullPath, file.content, "utf-8");
+          const fullPath = join16(process.cwd(), file.path);
+          await fs25.mkdir(join16(fullPath, ".."), { recursive: true });
+          await fs25.writeFile(fullPath, file.content, "utf-8");
         }
         console.log(`\u2713 ${format.name} - ${files2.length} files regenerated`);
       } catch (error) {
@@ -13282,8 +12985,8 @@ function buildIdeChoices(currentIdes, detected, suggestions) {
 
 // src/commands/rules/info.ts
 import { Command as Command67 } from "commander";
-import { promises as fs27 } from "fs";
-import { join as join18 } from "path";
+import { promises as fs26 } from "fs";
+import { join as join17 } from "path";
 function createRulesInfoCommand() {
   return new Command67("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
     const projectConfigService = new ProjectConfigService();
@@ -13298,14 +13001,14 @@ function createRulesInfoCommand() {
       return;
     }
     console.log("\u{1F4CB} Current Preset Information\n");
-    const rulePresetDir = join18(process.cwd(), ".jai1", "rule-preset");
-    const presetJsonPath = join18(rulePresetDir, "preset.json");
+    const rulePresetDir = join17(process.cwd(), ".jai1", "rule-preset");
+    const presetJsonPath = join17(rulePresetDir, "preset.json");
     let presetMetadata = null;
     let presetFiles = [];
     try {
-      const presetContent = await fs27.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs26.readFile(presetJsonPath, "utf-8");
       presetMetadata = JSON.parse(presetContent);
-      const files = await fs27.readdir(rulePresetDir);
+      const files = await fs26.readdir(rulePresetDir);
       presetFiles = files.filter((f) => f.endsWith(".mdc"));
     } catch {
     }
@@ -13366,7 +13069,7 @@ Available Backups (${rulesConfig.backups.length}):`);
 }
 async function checkPathExists(path13) {
   try {
-    await fs27.access(join18(process.cwd(), path13));
+    await fs26.access(join17(process.cwd(), path13));
     return true;
   } catch {
     return false;
@@ -13419,9 +13122,723 @@ function createRulesCommand() {
   return rulesCommand;
 }
 
-// src/commands/upgrade.ts
+// src/commands/skills/index.ts
+import { Command as Command74 } from "commander";
+import chalk39 from "chalk";
+
+// src/commands/skills/find.ts
 import { Command as Command69 } from "commander";
-import { confirm as confirm14 } from "@inquirer/prompts";
+import chalk34 from "chalk";
+import Table8 from "cli-table3";
+
+// src/services/skills.service.ts
+import { promises as fs27 } from "fs";
+import { join as join18 } from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var IDE_SKILL_TARGETS = [
+  { id: "cursor", name: "Cursor", icon: "\u{1F52E}", skillsPath: ".agents/skills" },
+  { id: "windsurf", name: "Windsurf", icon: "\u{1F3C4}", skillsPath: ".windsurf/skills" },
+  { id: "antigravity", name: "Antigravity", icon: "\u{1F680}", skillsPath: ".agent/skills" },
+  { id: "claudecode", name: "Claude Code", icon: "\u{1F916}", skillsPath: ".claude/skills" },
+  { id: "opencode", name: "OpenCode", icon: "\u{1F4BB}", skillsPath: ".agents/skills" }
+];
+var SkillsService = class {
+  componentsService;
+  constructor(projectRoot = process.cwd()) {
+    this.componentsService = new ComponentsService(projectRoot);
+  }
+  /**
+   * Search skills on Jai1 server
+   */
+  async searchFromServer(config, query) {
+    const options = {};
+    if (query) options.search = query;
+    const components = await this.componentsService.list(config, options);
+    return components.filter((c) => c.filepath.startsWith("skills/"));
+  }
+  /**
+   * Install skill from Jai1 server to .jai1/skills/
+   */
+  async installFromServer(config, skillName, targetDir) {
+    const filepath = skillName.startsWith("skills/") ? skillName : `skills/${skillName}`;
+    await this.componentsService.install(config, filepath, targetDir);
+  }
+  /**
+   * List locally installed skills from .jai1/skills/
+   */
+  async listLocal(projectRoot) {
+    const skillsDir = join18(projectRoot, ".jai1", "skills");
+    const skills = [];
+    try {
+      const entries = await fs27.readdir(skillsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const skillPath = join18(skillsDir, entry.name);
+        const skillMd = join18(skillPath, "SKILL.md");
+        try {
+          await fs27.access(skillMd);
+        } catch {
+          continue;
+        }
+        const content = await fs27.readFile(skillMd, "utf-8");
+        const { name, description } = this.parseFrontmatter(content);
+        const fileCount = await this.countFiles(skillPath);
+        skills.push({
+          name: name || entry.name,
+          slug: entry.name,
+          description: description || "",
+          path: skillPath,
+          fileCount
+        });
+      }
+    } catch {
+    }
+    return skills.sort((a, b) => a.slug.localeCompare(b.slug));
+  }
+  /**
+   * Get detailed info for a single skill
+   */
+  async getSkillInfo(projectRoot, skillName) {
+    const skillPath = join18(projectRoot, ".jai1", "skills", skillName);
+    const skillMd = join18(skillPath, "SKILL.md");
+    try {
+      await fs27.access(skillMd);
+    } catch {
+      return null;
+    }
+    const content = await fs27.readFile(skillMd, "utf-8");
+    const { name, description } = this.parseFrontmatter(content);
+    const fileCount = await this.countFiles(skillPath);
+    return {
+      name: name || skillName,
+      slug: skillName,
+      description: description || "",
+      path: skillPath,
+      fileCount
+    };
+  }
+  /**
+   * Search skills via npm `skills` package (wrapper)
+   */
+  async npmSkillsFind(query) {
+    try {
+      const { stdout } = await execFileAsync("npx", ["-y", "skills", "find", query], {
+        timeout: 3e4
+      });
+      return stdout;
+    } catch (error) {
+      throw new Error(
+        `npm skills find failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Install skill via npm `skills` package (wrapper)
+   *
+   * Source format: "owner/repo" or "owner/repo@skill"
+   * Runs: npx skills add owner/repo [--skill name] --copy --yes
+   * Then copies installed skills into .jai1/skills/
+   */
+  async npmSkillsAdd(source, projectRoot) {
+    const { repo, skill } = this.parseSkillshSource(source);
+    const args = ["-y", "skills", "add", repo, "--copy", "--yes"];
+    if (skill) {
+      args.push("--skill", skill);
+    }
+    try {
+      const { stdout } = await execFileAsync("npx", args, {
+        timeout: 6e4,
+        cwd: projectRoot
+      });
+      await this.copySkillshResultsToJai1(projectRoot, skill);
+      return stdout;
+    } catch (error) {
+      throw new Error(
+        `skills.sh add failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Parse skills.sh source format: "owner/repo@skill" → { repo, skill }
+   */
+  parseSkillshSource(source) {
+    const atIndex = source.lastIndexOf("@");
+    if (atIndex > 0 && !source.substring(atIndex + 1).includes("/")) {
+      return {
+        repo: source.substring(0, atIndex),
+        skill: source.substring(atIndex + 1)
+      };
+    }
+    return { repo: source };
+  }
+  /**
+   * After npx skills add, copy newly installed skills from agent dirs into .jai1/skills/
+   */
+  async copySkillshResultsToJai1(projectRoot, specificSkill) {
+    const jai1SkillsDir = join18(projectRoot, ".jai1", "skills");
+    await fs27.mkdir(jai1SkillsDir, { recursive: true });
+    const agentDirs = [".agents/skills", ".agent/skills", ".claude/skills", ".windsurf/skills", ".cursor/skills"];
+    for (const agentDir of agentDirs) {
+      const fullDir = join18(projectRoot, agentDir);
+      try {
+        const entries = await fs27.readdir(fullDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (specificSkill && entry.name !== specificSkill) continue;
+          const srcSkill = join18(fullDir, entry.name);
+          const skillMd = join18(srcSkill, "SKILL.md");
+          try {
+            await fs27.access(skillMd);
+          } catch {
+            continue;
+          }
+          const targetSkill = join18(jai1SkillsDir, entry.name);
+          try {
+            await fs27.access(targetSkill);
+          } catch {
+            await fs27.mkdir(targetSkill, { recursive: true });
+            await this.copyDir(srcSkill, targetSkill);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  /**
+   * Get available IDE skill targets
+   */
+  getIDETargets() {
+    return IDE_SKILL_TARGETS;
+  }
+  /**
+   * Get IDE skill target by ID
+   */
+  getIDETarget(id) {
+    return IDE_SKILL_TARGETS.find((t) => t.id === id);
+  }
+  /**
+   * Sync skills from .jai1/skills/ to IDE directories
+   */
+  async syncToIdes(projectRoot, ides, skillSlugs, onProgress) {
+    const localSkills = await this.listLocal(projectRoot);
+    const skillsToSync = skillSlugs ? localSkills.filter((s) => skillSlugs.includes(s.slug)) : localSkills;
+    if (skillsToSync.length === 0) {
+      return { created: 0, updated: 0, errors: 0 };
+    }
+    let created = 0;
+    let updated = 0;
+    let errors = 0;
+    for (const ide of ides) {
+      const target = this.getIDETarget(ide);
+      if (!target) continue;
+      for (const skill of skillsToSync) {
+        const targetPath = join18(projectRoot, target.skillsPath, skill.slug);
+        try {
+          let status = "created";
+          try {
+            await fs27.access(targetPath);
+            status = "updated";
+            await fs27.rm(targetPath, { recursive: true, force: true });
+          } catch {
+          }
+          await fs27.mkdir(targetPath, { recursive: true });
+          await this.copyDir(skill.path, targetPath);
+          if (status === "created") created++;
+          else updated++;
+          onProgress?.({
+            ide: target.name,
+            skill: skill.slug,
+            status,
+            path: targetPath
+          });
+        } catch (error) {
+          errors++;
+          onProgress?.({
+            ide: target.name,
+            skill: skill.slug,
+            status: "error",
+            path: targetPath,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    return { created, updated, errors };
+  }
+  /**
+   * Parse YAML frontmatter from SKILL.md
+   */
+  parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match) {
+      const headingMatch = content.match(/^#\s+(.+)/m);
+      return {
+        name: headingMatch?.[1] || "",
+        description: ""
+      };
+    }
+    const frontmatter = match[1] ?? "";
+    let name = "";
+    let description = "";
+    for (const line of frontmatter.split("\n")) {
+      const nameMatch = line.match(/^name:\s*(.+)/);
+      if (nameMatch?.[1]) name = nameMatch[1].trim().replace(/^["']|["']$/g, "");
+      const descMatch = line.match(/^description:\s*(.+)/);
+      if (descMatch?.[1]) description = descMatch[1].trim().replace(/^["']|["']$/g, "");
+    }
+    return { name, description };
+  }
+  /**
+   * Count files in a directory recursively
+   */
+  async countFiles(dirPath) {
+    let count = 0;
+    const entries = await fs27.readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        count += await this.countFiles(join18(dirPath, entry.name));
+      } else {
+        count++;
+      }
+    }
+    return count;
+  }
+  /**
+   * Copy directory recursively
+   */
+  async copyDir(source, target) {
+    const entries = await fs27.readdir(source, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcPath = join18(source, entry.name);
+      const tgtPath = join18(target, entry.name);
+      if (entry.isDirectory()) {
+        await fs27.mkdir(tgtPath, { recursive: true });
+        await this.copyDir(srcPath, tgtPath);
+      } else {
+        await fs27.copyFile(srcPath, tgtPath);
+      }
+    }
+  }
+};
+
+// src/commands/skills/find.ts
+function createSkillsFindCommand() {
+  return new Command69("find").description("Search for skills on server or npm").argument("<query>", "Search query").option("--skillsh", "Search on npm skills registry instead of Jai1 server").option("--all", "Search on both Jai1 server and npm").action(async (query, options) => {
+    const searchNpm = options.skillsh || options.all;
+    const searchServer = !options.skillsh || options.all;
+    if (searchServer) {
+      const configService = new ConfigService();
+      const config = await configService.load();
+      if (!config) {
+        throw new ValidationError('Ch\u01B0a x\xE1c th\u1EF1c. Ch\u1EA1y "jai1 auth" tr\u01B0\u1EDBc.');
+      }
+      console.log(chalk34.cyan("\u{1F50D} \u0110ang t\xECm ki\u1EBFm tr\xEAn Jai1 server..."));
+      console.log();
+      const skillsService = new SkillsService();
+      const results = await skillsService.searchFromServer(config, query);
+      if (results.length === 0) {
+        console.log(chalk34.yellow("Kh\xF4ng t\xECm th\u1EA5y skills n\xE0o tr\xEAn server."));
+      } else {
+        const table = new Table8({
+          head: [
+            chalk34.cyan("T\xEAn"),
+            chalk34.cyan("M\xF4 t\u1EA3"),
+            chalk34.cyan("Version"),
+            chalk34.cyan("Downloads")
+          ],
+          style: { head: [], border: ["gray"] },
+          colWidths: [25, 40, 10, 12]
+        });
+        for (const skill of results) {
+          const name = skill.filepath.replace("skills/", "");
+          table.push([
+            chalk34.white(name),
+            chalk34.dim((skill.description || "").slice(0, 38)),
+            chalk34.green(skill.version || "-"),
+            chalk34.dim(String(skill.downloads || 0))
+          ]);
+        }
+        console.log(chalk34.bold(`\u{1F4E6} Jai1 Server (${results.length} k\u1EBFt qu\u1EA3)`));
+        console.log(table.toString());
+        console.log();
+      }
+    }
+    if (searchNpm) {
+      console.log(chalk34.cyan("\u{1F50D} \u0110ang t\xECm ki\u1EBFm tr\xEAn npm skills..."));
+      console.log();
+      const skillsService = new SkillsService();
+      try {
+        const output = await skillsService.npmSkillsFind(query);
+        console.log(chalk34.bold("\u{1F310} npm Skills Registry"));
+        console.log(output);
+      } catch (error) {
+        console.log(chalk34.yellow(
+          `Kh\xF4ng th\u1EC3 t\xECm ki\u1EBFm tr\xEAn npm: ${error instanceof Error ? error.message : String(error)}`
+        ));
+      }
+    }
+    if (searchServer && !searchNpm) {
+      console.log(chalk34.dim('\u{1F4A1} D\xF9ng "j skills add <t\xEAn>" \u0111\u1EC3 c\xE0i \u0111\u1EB7t t\u1EEB server'));
+    } else if (searchNpm && !searchServer) {
+      console.log(chalk34.dim('\u{1F4A1} D\xF9ng "j skills add <owner/repo@skill> --skillsh" \u0111\u1EC3 c\xE0i \u0111\u1EB7t'));
+    } else {
+      console.log(chalk34.dim("\u{1F4A1} C\xE0i \u0111\u1EB7t:"));
+      console.log(chalk34.dim("   Server:   j skills add <t\xEAn>"));
+      console.log(chalk34.dim("   Skills.sh: j skills add <owner/repo@skill> --skillsh"));
+    }
+  });
+}
+
+// src/commands/skills/add.ts
+import { Command as Command70 } from "commander";
+import { join as join19 } from "path";
+import chalk35 from "chalk";
+import { checkbox as checkbox7 } from "@inquirer/prompts";
+function createSkillsAddCommand() {
+  return new Command70("add").description("Install a skill to .jai1/skills/").argument("<name>", "Skill name or source (npm: GitHub shorthand, URL)").option("--skillsh", "Install from npm skills registry instead of Jai1 server").option("--sync", "Auto-sync to IDE(s) after install").option("--ides <ides...>", "Target IDEs for sync (cursor, windsurf, antigravity, claudecode, opencode)").option("--all", "Sync to all available IDEs").option("-y, --yes", "Headless mode (skip all prompts)").action(async (name, options) => {
+    const skillsService = new SkillsService();
+    const projectRoot = process.cwd();
+    const headless = options.yes === true;
+    if (options.skillsh) {
+      console.log(chalk35.cyan(`\u{1F310} \u0110ang c\xE0i \u0111\u1EB7t skill t\u1EEB npm: ${name}...`));
+      console.log();
+      const output = await skillsService.npmSkillsAdd(name, projectRoot);
+      console.log(output);
+      console.log(chalk35.green("\u2705 C\xE0i \u0111\u1EB7t t\u1EEB npm th\xE0nh c\xF4ng!"));
+    } else {
+      const configService = new ConfigService();
+      const config = await configService.load();
+      if (!config) {
+        throw new ValidationError('Ch\u01B0a x\xE1c th\u1EF1c. Ch\u1EA1y "jai1 auth" tr\u01B0\u1EDBc.');
+      }
+      console.log(chalk35.cyan(`\u{1F4E6} \u0110ang c\xE0i \u0111\u1EB7t skill: ${name}...`));
+      console.log();
+      const targetDir = join19(projectRoot, ".jai1");
+      await skillsService.installFromServer(config, name, targetDir);
+      console.log(chalk35.green(`\u2705 \u0110\xE3 c\xE0i \u0111\u1EB7t skill "${name}" v\xE0o .jai1/skills/${name}/`));
+    }
+    console.log();
+    if (options.sync) {
+      let selectedIdes;
+      if (options.all) {
+        selectedIdes = skillsService.getIDETargets().map((t) => t.id);
+      } else if (options.ides && options.ides.length > 0) {
+        selectedIdes = options.ides;
+      } else if (headless) {
+        throw new Error(
+          "Headless mode (-y) v\u1EDBi --sync y\xEAu c\u1EA7u --ides ho\u1EB7c --all.\nV\xED d\u1EE5:\n  j skills add brainstorming --sync --ides cursor windsurf -y\n  j skills add brainstorming --sync --all -y"
+        );
+      } else {
+        const targets = skillsService.getIDETargets();
+        selectedIdes = await checkbox7({
+          message: "Sync sang IDE(s) n\xE0o?",
+          choices: targets.map((t) => ({
+            name: `${t.icon} ${t.name}`,
+            value: t.id
+          })),
+          theme: checkboxTheme
+        });
+      }
+      if (selectedIdes.length > 0) {
+        console.log(chalk35.cyan("\u{1F504} \u0110ang sync sang IDE(s)..."));
+        console.log();
+        const slug = name.includes("/") ? name.split("/").pop() : name;
+        const result = await skillsService.syncToIdes(
+          projectRoot,
+          selectedIdes,
+          [slug],
+          (res) => {
+            const icon = res.status === "created" ? "\u2713" : res.status === "updated" ? "\u21BB" : "\u2717";
+            console.log(`   ${icon} ${res.ide}: ${res.skill} \u2192 ${res.path}`);
+          }
+        );
+        console.log();
+        console.log(chalk35.green(`\u2705 Sync ho\xE0n t\u1EA5t! Created: ${result.created}, Updated: ${result.updated}`));
+        if (result.errors > 0) {
+          console.log(chalk35.yellow(`\u26A0\uFE0F  Errors: ${result.errors}`));
+        }
+      }
+    } else {
+      console.log(chalk35.dim('\u{1F4A1} Ch\u1EA1y "j skills sync" \u0111\u1EC3 \u0111\u1ED3ng b\u1ED9 sang IDE(s)'));
+      console.log(chalk35.dim('   ho\u1EB7c "j ide sync" \u0111\u1EC3 sync to\xE0n b\u1ED9 .jai1/'));
+    }
+  });
+}
+
+// src/commands/skills/list.ts
+import { Command as Command71 } from "commander";
+import chalk36 from "chalk";
+import Table9 from "cli-table3";
+function createSkillsListCommand() {
+  return new Command71("list").description("List installed skills or available skills on server").option("--available", "List all skills available on Jai1 server").option("-s, --search <term>", "Search skills by name or description").action(async (options) => {
+    const skillsService = new SkillsService();
+    if (options.available) {
+      const configService = new ConfigService();
+      const config = await configService.load();
+      if (!config) {
+        throw new ValidationError('Ch\u01B0a x\xE1c th\u1EF1c. Ch\u1EA1y "jai1 auth" tr\u01B0\u1EDBc.');
+      }
+      console.log(chalk36.cyan("\u{1F4E6} \u0110ang t\u1EA3i danh s\xE1ch skills t\u1EEB server..."));
+      console.log();
+      const results = await skillsService.searchFromServer(config, options.search);
+      if (results.length === 0) {
+        console.log(chalk36.yellow("Kh\xF4ng t\xECm th\u1EA5y skills n\xE0o."));
+        return;
+      }
+      const table = new Table9({
+        head: [
+          chalk36.cyan("T\xEAn"),
+          chalk36.cyan("M\xF4 t\u1EA3"),
+          chalk36.cyan("Version"),
+          chalk36.cyan("Downloads")
+        ],
+        style: { head: [], border: ["gray"] },
+        colWidths: [28, 40, 10, 12]
+      });
+      for (const skill of results) {
+        const name = skill.filepath.replace("skills/", "");
+        table.push([
+          chalk36.white(name),
+          chalk36.dim((skill.description || "").slice(0, 38)),
+          chalk36.green(skill.version || "-"),
+          chalk36.dim(String(skill.downloads || 0))
+        ]);
+      }
+      console.log(table.toString());
+      console.log();
+      console.log(chalk36.dim(`T\u1ED5ng c\u1ED9ng: ${results.length} skill(s)`));
+      console.log(chalk36.dim('\n\u{1F4A1} D\xF9ng "j skills add <t\xEAn>" \u0111\u1EC3 c\xE0i \u0111\u1EB7t'));
+    } else {
+      const projectRoot = process.cwd();
+      const skills = await skillsService.listLocal(projectRoot);
+      if (skills.length === 0) {
+        console.log(chalk36.yellow("Ch\u01B0a c\xF3 skills n\xE0o \u0111\u01B0\u1EE3c c\xE0i \u0111\u1EB7t."));
+        console.log();
+        console.log(chalk36.dim('\u{1F4A1} D\xF9ng "j skills add <t\xEAn>" \u0111\u1EC3 c\xE0i \u0111\u1EB7t'));
+        console.log(chalk36.dim('   ho\u1EB7c "j skills list --available" \u0111\u1EC3 xem skills c\xF3 s\u1EB5n'));
+        return;
+      }
+      console.log(chalk36.bold.cyan("\u{1F6E0} Skills \u0111\xE3 c\xE0i \u0111\u1EB7t"));
+      console.log();
+      const table = new Table9({
+        head: [
+          chalk36.cyan("T\xEAn"),
+          chalk36.cyan("M\xF4 t\u1EA3"),
+          chalk36.cyan("Files")
+        ],
+        style: { head: [], border: ["gray"] },
+        colWidths: [28, 45, 8]
+      });
+      for (const skill of skills) {
+        table.push([
+          chalk36.white(skill.slug),
+          chalk36.dim(skill.description.slice(0, 43)),
+          chalk36.dim(String(skill.fileCount))
+        ]);
+      }
+      console.log(table.toString());
+      console.log();
+      console.log(chalk36.dim(`T\u1ED5ng c\u1ED9ng: ${skills.length} skill(s)`));
+      console.log(chalk36.dim('\n\u{1F4A1} D\xF9ng "j skills sync" \u0111\u1EC3 \u0111\u1ED3ng b\u1ED9 sang IDE(s)'));
+    }
+  });
+}
+
+// src/commands/skills/info.ts
+import { Command as Command72 } from "commander";
+import chalk37 from "chalk";
+function createSkillsInfoCommand() {
+  return new Command72("info").description("Show detailed information about a skill").argument("<name>", "Skill name").option("--server", "Show info from Jai1 server instead of local").action(async (name, options) => {
+    const skillsService = new SkillsService();
+    if (options.server) {
+      const configService = new ConfigService();
+      const config = await configService.load();
+      if (!config) {
+        console.log(chalk37.red('\u274C Ch\u01B0a x\xE1c th\u1EF1c. Ch\u1EA1y "jai1 auth" tr\u01B0\u1EDBc.'));
+        process.exit(1);
+      }
+      const filepath = name.startsWith("skills/") ? name : `skills/${name}`;
+      const { ComponentsService: ComponentsService2 } = await import("./components.service-NWAWKII3.js");
+      const componentsService = new ComponentsService2();
+      try {
+        const component = await componentsService.get(config, filepath);
+        console.log(`
+\u{1F6E0} ${chalk37.bold(component.name || name)}
+`);
+        console.log(`Filepath:    ${component.filepath}`);
+        console.log(`Version:     ${component.version}`);
+        console.log(`Downloads:   ${component.downloads}`);
+        if (component.description) {
+          console.log(`Description: ${component.description}`);
+        }
+        if (component.tags && component.tags.length > 0) {
+          console.log(`Tags:        ${component.tags.join(", ")}`);
+        }
+        console.log(`Type:        ${component.contentType}`);
+        console.log();
+        console.log(chalk37.dim('\u{1F4A1} D\xF9ng "j skills add ' + name + '" \u0111\u1EC3 c\xE0i \u0111\u1EB7t'));
+      } catch (error) {
+        console.log(chalk37.red(`\u274C Kh\xF4ng t\xECm th\u1EA5y skill "${name}" tr\xEAn server.`));
+        process.exit(1);
+      }
+    } else {
+      const projectRoot = process.cwd();
+      const skill = await skillsService.getSkillInfo(projectRoot, name);
+      if (!skill) {
+        console.log(chalk37.red(`\u274C Skill "${name}" ch\u01B0a \u0111\u01B0\u1EE3c c\xE0i \u0111\u1EB7t.`));
+        console.log(chalk37.dim('\u{1F4A1} D\xF9ng "j skills info ' + name + ' --server" \u0111\u1EC3 xem tr\xEAn server'));
+        console.log(chalk37.dim('   ho\u1EB7c "j skills add ' + name + '" \u0111\u1EC3 c\xE0i \u0111\u1EB7t'));
+        process.exit(1);
+      }
+      console.log(`
+\u{1F6E0} ${chalk37.bold(skill.name)}
+`);
+      console.log(`Slug:        ${skill.slug}`);
+      console.log(`Description: ${skill.description || chalk37.dim("(none)")}`);
+      console.log(`Path:        ${skill.path}`);
+      console.log(`Files:       ${skill.fileCount}`);
+      console.log();
+      console.log(chalk37.dim('\u{1F4A1} D\xF9ng "j skills sync" \u0111\u1EC3 \u0111\u1ED3ng b\u1ED9 sang IDE(s)'));
+    }
+  });
+}
+
+// src/commands/skills/sync.ts
+import { Command as Command73 } from "commander";
+import chalk38 from "chalk";
+import { confirm as confirm15, checkbox as checkbox8 } from "@inquirer/prompts";
+function createSkillsSyncCommand() {
+  return new Command73("sync").description("Sync skills from .jai1/skills/ to IDE directories").option("--ides <ides...>", "Target IDEs (cursor, windsurf, antigravity, claudecode, opencode)").option("--skills <skills...>", "Specific skill slugs to sync (default: all)").option("--all", "Select all available IDEs").option("--dry-run", "Preview changes without writing files").option("-y, --yes", "Headless mode (skip all prompts)").action(async (options) => {
+    const skillsService = new SkillsService();
+    const projectRoot = process.cwd();
+    const headless = options.yes === true;
+    console.log(chalk38.bold.cyan("\n\u{1F504} Sync skills sang IDE(s)\n"));
+    const localSkills = await skillsService.listLocal(projectRoot);
+    if (localSkills.length === 0) {
+      console.log(chalk38.yellow("\u26A0\uFE0F  Kh\xF4ng c\xF3 skills n\xE0o trong .jai1/skills/"));
+      console.log(chalk38.dim('\u{1F4A1} Ch\u1EA1y "j skills add <t\xEAn>" \u0111\u1EC3 c\xE0i \u0111\u1EB7t skills tr\u01B0\u1EDBc'));
+      process.exit(1);
+    }
+    console.log(`\u{1F4C1} T\xECm th\u1EA5y ${localSkills.length} skill(s) trong .jai1/skills/`);
+    console.log();
+    let selectedSlugs;
+    if (options.skills && options.skills.length > 0) {
+      selectedSlugs = options.skills;
+      console.log(`\u{1F6E0} Skills: ${selectedSlugs.join(", ")}`);
+    } else {
+      console.log(`\u{1F6E0} Skills: t\u1EA5t c\u1EA3 (${localSkills.length})`);
+    }
+    let selectedIdes;
+    const targets = skillsService.getIDETargets();
+    if (options.all) {
+      selectedIdes = targets.map((t) => t.id);
+    } else if (options.ides && options.ides.length > 0) {
+      selectedIdes = options.ides;
+    } else if (headless) {
+      throw new Error(
+        "Headless mode (-y) y\xEAu c\u1EA7u --ides ho\u1EB7c --all.\nV\xED d\u1EE5:\n  j skills sync --ides cursor windsurf -y\n  j skills sync --all -y"
+      );
+    } else {
+      selectedIdes = await checkbox8({
+        message: "Ch\u1ECDn IDE(s) \u0111\u1EC3 sync (SPACE \u0111\u1EC3 ch\u1ECDn, ENTER \u0111\u1EC3 x\xE1c nh\u1EADn):",
+        choices: targets.map((t) => ({
+          name: `${t.icon} ${t.name}`,
+          value: t.id
+        })),
+        theme: checkboxTheme
+      });
+      if (selectedIdes.length === 0) {
+        console.log(chalk38.yellow("\n\u26A0\uFE0F  Ch\u01B0a ch\u1ECDn IDE n\xE0o!"));
+        process.exit(0);
+      }
+    }
+    const ideNames = selectedIdes.map((id) => targets.find((t) => t.id === id)).filter(Boolean).map((t) => t.name);
+    const skillCount = selectedSlugs ? selectedSlugs.length : localSkills.length;
+    const totalFiles = skillCount * selectedIdes.length;
+    console.log(`
+\u{1F4CA} Preview:
+`);
+    console.log(`   IDEs: ${ideNames.join(", ")}`);
+    console.log(`   Skills: ${skillCount}`);
+    console.log(`   Total: ${totalFiles} skill folder(s) s\u1EBD \u0111\u01B0\u1EE3c sync
+`);
+    if (options.dryRun) {
+      console.log(chalk38.dim("\u{1F50D} DRY RUN - Kh\xF4ng c\xF3 file n\xE0o \u0111\u01B0\u1EE3c ghi\n"));
+      return;
+    }
+    if (!headless) {
+      const confirmed = await confirm15({
+        message: "Ti\u1EBFp t\u1EE5c sync?",
+        default: true
+      });
+      if (!confirmed) {
+        console.log(chalk38.yellow("\n\u274C \u0110\xE3 h\u1EE7y sync.\n"));
+        process.exit(0);
+      }
+    }
+    console.log(chalk38.cyan("\n\u{1F504} \u0110ang sync...\n"));
+    const result = await skillsService.syncToIdes(
+      projectRoot,
+      selectedIdes,
+      selectedSlugs,
+      (res) => {
+        const icon = res.status === "created" ? "\u2713" : res.status === "updated" ? "\u21BB" : "\u2717";
+        const statusColor = res.status === "error" ? chalk38.red : chalk38.green;
+        console.log(`   ${statusColor(icon)} ${res.ide}: ${res.skill} \u2192 ${chalk38.dim(res.path)}`);
+        if (res.status === "error" && res.error) {
+          console.log(`      ${chalk38.red("Error:")} ${res.error}`);
+        }
+      }
+    );
+    console.log(chalk38.green("\n\u2705 Sync ho\xE0n t\u1EA5t!\n"));
+    console.log(`   Created: ${result.created}`);
+    console.log(`   Updated: ${result.updated}`);
+    if (result.errors > 0) {
+      console.log(`   Errors:  ${result.errors}`);
+    }
+    console.log();
+  });
+}
+
+// src/commands/skills/index.ts
+function showSkillsHelp() {
+  const cli = getCliName();
+  console.log(chalk39.bold.cyan("\u{1F6E0} " + cli + " skills") + chalk39.dim(" - Qu\u1EA3n l\xFD agent skills"));
+  console.log();
+  console.log(chalk39.bold("C\xE1c l\u1EC7nh:"));
+  console.log(`  ${chalk39.cyan("find")}     T\xECm ki\u1EBFm skills tr\xEAn server ho\u1EB7c npm`);
+  console.log(`  ${chalk39.cyan("add")}      C\xE0i \u0111\u1EB7t skill v\xE0o .jai1/skills/`);
+  console.log(`  ${chalk39.cyan("list")}     Li\u1EC7t k\xEA skills \u0111\xE3 c\xE0i ho\u1EB7c c\xF3 s\u1EB5n`);
+  console.log(`  ${chalk39.cyan("info")}     Xem chi ti\u1EBFt m\u1ED9t skill`);
+  console.log(`  ${chalk39.cyan("sync")}     \u0110\u1ED3ng b\u1ED9 skills sang c\xE1c IDE`);
+  console.log();
+  console.log(chalk39.bold("V\xED d\u1EE5:"));
+  console.log(chalk39.dim(`  $ ${cli} skills find audit`));
+  console.log(chalk39.dim(`  $ ${cli} skills find "react" --skillsh`));
+  console.log(chalk39.dim(`  $ ${cli} skills add brainstorming`));
+  console.log(chalk39.dim(`  $ ${cli} skills add vercel/next-skills --skillsh`));
+  console.log(chalk39.dim(`  $ ${cli} skills list`));
+  console.log(chalk39.dim(`  $ ${cli} skills sync --all -y`));
+  console.log();
+  console.log(chalk39.dim(`Ch\u1EA1y "${cli} skills <l\u1EC7nh> --help" \u0111\u1EC3 xem chi ti\u1EBFt`));
+}
+function createSkillsCommand() {
+  const cmd = new Command74("skills").alias("s").description("Manage agent skills (search, install, sync to IDEs)").action(() => {
+    showSkillsHelp();
+  });
+  cmd.addCommand(createSkillsFindCommand());
+  cmd.addCommand(createSkillsAddCommand());
+  cmd.addCommand(createSkillsListCommand());
+  cmd.addCommand(createSkillsInfoCommand());
+  cmd.addCommand(createSkillsSyncCommand());
+  return cmd;
+}
+
+// src/commands/upgrade.ts
+import { Command as Command75 } from "commander";
+import { confirm as confirm16 } from "@inquirer/prompts";
 import { execSync as execSync4 } from "child_process";
 var colors2 = {
   yellow: "\x1B[33m",
@@ -13432,7 +13849,7 @@ var colors2 = {
   bold: "\x1B[1m"
 };
 function createUpgradeCommand() {
-  return new Command69("upgrade").description("Upgrade CLI client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force upgrade without confirmation").action(async (options) => {
+  return new Command75("upgrade").description("Upgrade CLI 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);
   });
 }
@@ -13476,7 +13893,7 @@ ${colors2.bold}Current version:${colors2.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm14({
+      const shouldUpdate = await confirm16({
         message: "Update to the latest version now?",
         default: true
       });
@@ -13580,11 +13997,11 @@ function getInstallCommand(packageManager2) {
 }
 
 // src/commands/clean.ts
-import { Command as Command70 } from "commander";
-import { confirm as confirm15, select as select6 } from "@inquirer/prompts";
-import { join as join19 } from "path";
+import { Command as Command76 } from "commander";
+import { confirm as confirm17, select as select6 } from "@inquirer/prompts";
+import { join as join20 } from "path";
 function createCleanCommand() {
-  return new Command70("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 Command76("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);
   });
 }
@@ -13595,7 +14012,7 @@ async function handleClean(options) {
     {
       name: "Backups",
       description: "Component backup files (.jai1_backup/)",
-      path: join19(cwd, ".jai1_backup"),
+      path: join20(cwd, ".jai1_backup"),
       check: async () => {
         const backups = await service.listBackups(cwd);
         return { exists: backups.length > 0, count: backups.length };
@@ -13680,7 +14097,7 @@ async function cleanTarget(target, skipConfirm) {
   }
   const countStr = info.count ? ` (${info.count} items)` : "";
   if (!skipConfirm) {
-    const confirmed = await confirm15({
+    const confirmed = await confirm17({
       message: `Delete ${target.name}${countStr}?`,
       default: false
     });
@@ -13698,7 +14115,7 @@ async function cleanTarget(target, skipConfirm) {
 }
 
 // src/commands/redmine/check.ts
-import { Command as Command71 } from "commander";
+import { Command as Command77 } from "commander";
 
 // src/services/redmine-config.service.ts
 import { readFile as readFile7 } from "fs/promises";
@@ -14005,7 +14422,7 @@ async function checkConnectivity(config) {
 
 // src/commands/redmine/check.ts
 function createRedmineCheckCommand() {
-  const cmd = new Command71("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 Command77("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;
@@ -14033,7 +14450,7 @@ async function handleRedmineCheck(options) {
 }
 
 // src/commands/redmine/sync-issue.ts
-import { Command as Command72 } from "commander";
+import { Command as Command78 } from "commander";
 
 // src/sync-issue.ts
 import { resolve as resolve3, relative } from "path";
@@ -14417,7 +14834,7 @@ function extractIssueIdFromUrl(url) {
 
 // src/commands/redmine/sync-issue.ts
 function createSyncIssueCommand() {
-  const cmd = new Command72("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 Command78("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;
@@ -14461,7 +14878,7 @@ async function handleSyncIssue(options) {
 }
 
 // src/commands/redmine/sync-project.ts
-import { Command as Command73 } from "commander";
+import { Command as Command79 } from "commander";
 
 // src/sync-project.ts
 async function syncProject(config, options = {}) {
@@ -14531,7 +14948,7 @@ async function syncProject(config, options = {}) {
 
 // src/commands/redmine/sync-project.ts
 function createSyncProjectCommand() {
-  const cmd = new Command73("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 Command79("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;
@@ -14586,12 +15003,12 @@ async function handleSyncProject(options) {
 }
 
 // src/commands/framework/info.ts
-import { Command as Command74 } from "commander";
+import { Command as Command80 } from "commander";
 import { promises as fs28 } from "fs";
-import { join as join20 } from "path";
-import { homedir as homedir6 } from "os";
+import { join as join21 } from "path";
+import { homedir as homedir5 } from "os";
 function createInfoCommand() {
-  const cmd = new Command74("info").description("Show client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
+  const cmd = new Command80("info").description("Show client configuration and status").option("--json", "Output as JSON").option("--verbose", "Show detailed information").action(async (options) => {
     await handleInfo(options);
   });
   return cmd;
@@ -14602,7 +15019,7 @@ async function handleInfo(options) {
   if (!config) {
     throw new ValidationError(`Not initialized. Run "${getCliName()} auth" first.`);
   }
-  const frameworkPath = join20(homedir6(), ".jai1", "framework");
+  const frameworkPath = join21(homedir5(), ".jai1", "framework");
   const projectStatus = await getProjectStatus2();
   const info = {
     configPath: configService.getConfigPath(),
@@ -14637,7 +15054,7 @@ function maskKey4(key) {
   return "****" + key.slice(-4);
 }
 async function getProjectStatus2() {
-  const projectJai1 = join20(process.cwd(), ".jai1");
+  const projectJai1 = join21(process.cwd(), ".jai1");
   try {
     await fs28.access(projectJai1);
     return { exists: true, version: "Synced" };
@@ -14647,8 +15064,8 @@ async function getProjectStatus2() {
 }
 
 // src/commands/self-update.ts
-import { Command as Command75 } from "commander";
-import { confirm as confirm16 } from "@inquirer/prompts";
+import { Command as Command81 } from "commander";
+import { confirm as confirm18 } from "@inquirer/prompts";
 import { execSync as execSync5 } from "child_process";
 var colors3 = {
   yellow: "\x1B[33m",
@@ -14659,7 +15076,7 @@ var colors3 = {
   bold: "\x1B[1m"
 };
 function createSelfUpdateCommand() {
-  return new Command75("self-update").description("Update CLI client to the latest version").option("--check", "Only check for updates without installing").option("--force", "Force update without confirmation").action(async (options) => {
+  return new Command81("self-update").description("Update CLI 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);
   });
 }
@@ -14703,7 +15120,7 @@ ${colors3.bold}Current version:${colors3.reset} ${currentVersion}`);
       return;
     }
     if (!options.force) {
-      const shouldUpdate = await confirm16({
+      const shouldUpdate = await confirm18({
         message: "Update to the latest version now?",
         default: true
       });
@@ -14799,10 +15216,10 @@ function getInstallCommand2(packageManager2) {
 }
 
 // src/commands/clear-backups.ts
-import { Command as Command76 } from "commander";
-import { confirm as confirm17 } from "@inquirer/prompts";
+import { Command as Command82 } from "commander";
+import { confirm as confirm19 } from "@inquirer/prompts";
 function createClearBackupsCommand() {
-  return new Command76("clear-backups").description("Clear backup files").option("-y, --yes", "Skip confirmation").action(async (options) => {
+  return new Command82("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) {
@@ -14818,7 +15235,7 @@ function createClearBackupsCommand() {
     }
     console.log();
     if (!options.yes) {
-      const ok = await confirm17({ message: "Delete all backups?", default: false });
+      const ok = await confirm19({ message: "Delete all backups?", default: false });
       if (!ok) return;
     }
     await service.clearBackups(process.cwd());
@@ -14827,8 +15244,8 @@ function createClearBackupsCommand() {
 }
 
 // src/commands/vscode/index.ts
-import { Command as Command77 } from "commander";
-import { checkbox as checkbox7, confirm as confirm18, select as select7 } from "@inquirer/prompts";
+import { Command as Command83 } from "commander";
+import { checkbox as checkbox9, confirm as confirm20, select as select7 } from "@inquirer/prompts";
 import fs29 from "fs/promises";
 import path12 from "path";
 import { existsSync as existsSync3 } from "fs";
@@ -14967,7 +15384,7 @@ var PERFORMANCE_GROUPS2 = {
   }
 };
 function createVSCodeCommand() {
-  const vscodeCommand = new Command77("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
+  const vscodeCommand = new Command83("vscode").description("Qu\u1EA3n l\xFD c\xE0i \u0111\u1EB7t VSCode cho d\u1EF1 \xE1n hi\u1EC7n t\u1EA1i");
   vscodeCommand.action(async () => {
     await interactiveMode2();
   });
@@ -15036,7 +15453,7 @@ async function selectGroupsToApply2(action) {
     value: key
   }));
   try {
-    const selectedGroups = await checkbox7({
+    const selectedGroups = await checkbox9({
       message: `Ch\u1ECDn c\xE1c nh\xF3m \u0111\u1EC3 ${action === "enable" ? "enable" : "disable"} (SPACE \u0111\u1EC3 ch\u1ECDn, ENTER \u0111\u1EC3 x\xE1c nh\u1EADn):`,
       choices,
       theme: checkboxTheme
@@ -15073,7 +15490,7 @@ async function applyGroups2(groupKeys, action) {
       console.log("\u{1F4C4} \u0110\xE3 \u0111\u1ECDc c\xE0i \u0111\u1EB7t hi\u1EC7n t\u1EA1i t\u1EEB settings.json");
     } catch {
       console.warn("\u26A0\uFE0F  Kh\xF4ng th\u1EC3 \u0111\u1ECDc settings.json (c\xF3 th\u1EC3 ch\u1EE9a comments).");
-      const confirmOverwrite = await confirm18({
+      const confirmOverwrite = await confirm20({
         message: "Ghi \u0111\xE8 file settings.json hi\u1EC7n t\u1EA1i?",
         default: false
       });
@@ -15120,7 +15537,7 @@ async function resetSettings2(groupKeys) {
     console.log("\n\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y file settings.json");
     return;
   }
-  const confirmReset = await confirm18({
+  const confirmReset = await confirm20({
     message: groupKeys.length === 0 ? "Reset T\u1EA4T C\u1EA2 settings v\u1EC1 m\u1EB7c \u0111\u1ECBnh (x\xF3a to\xE0n b\u1ED9 file)?" : `Reset c\xE1c nh\xF3m: ${groupKeys.join(", ")}?`,
     default: false
   });
@@ -15138,10 +15555,10 @@ async function resetSettings2(groupKeys) {
 }
 
 // src/commands/migrate-ide.ts
-import { Command as Command78 } from "commander";
-import { checkbox as checkbox8, confirm as confirm19 } from "@inquirer/prompts";
+import { Command as Command84 } from "commander";
+import { checkbox as checkbox10, confirm as confirm21 } from "@inquirer/prompts";
 function createMigrateIdeCommand() {
-  const cmd = new Command78("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 Command84("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;
@@ -15169,7 +15586,7 @@ async function runMigrateIde(options) {
         value: ide
       };
     });
-    selectedIdes = await checkbox8({
+    selectedIdes = await checkbox10({
       message: "Ch\u1ECDn IDE(s) \u0111\u1EC3 migrate (SPACE \u0111\u1EC3 ch\u1ECDn, ENTER \u0111\u1EC3 x\xE1c nh\u1EADn):",
       choices: ideChoices,
       theme: checkboxTheme
@@ -15189,7 +15606,7 @@ async function runMigrateIde(options) {
       { name: `Workflows (${content.workflows.length} files)`, value: "workflows" },
       { name: `Commands (${content.commands.length} files)`, value: "commands" }
     ];
-    selectedTypes = await checkbox8({
+    selectedTypes = await checkbox10({
       message: "Ch\u1ECDn content types \u0111\u1EC3 migrate:",
       choices: typeChoices,
       theme: checkboxTheme
@@ -15212,7 +15629,7 @@ async function runMigrateIde(options) {
   if (options.dryRun) {
     console.log("\u{1F50D} DRY RUN - No files will be written\n");
   }
-  const confirmed = await confirm19({
+  const confirmed = await confirm21({
     message: "Proceed with migration?",
     default: true
   });
@@ -15250,20 +15667,20 @@ async function runMigrateIde(options) {
 
 // src/utils/help-formatter.ts
 import boxen4 from "boxen";
-import chalk34 from "chalk";
+import chalk40 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(chalk34.cyan(`Agentic Coding CLI v${version}`), {
+    boxen4(chalk40.cyan(`Agentic Coding CLI v${version}`), {
       padding: { left: 1, right: 1, top: 0, bottom: 0 },
       borderStyle: "round",
       borderColor: "cyan"
     })
   );
-  console.log(chalk34.bold("\n\u{1F527} Thi\u1EBFt l\u1EADp & Th\xF4ng tin"));
+  console.log(chalk40.bold("\n\u{1F527} Thi\u1EBFt l\u1EADp & Th\xF4ng tin"));
   console.log("   auth           X\xE1c th\u1EF1c v\xE0 c\u1EA5u h\xECnh client");
   console.log("   status         Hi\u1EC3n th\u1ECB tr\u1EA1ng th\xE1i c\u1EA5u h\xECnh");
   console.log("   client-info    T\u1EA1o th\xF4ng tin client \u0111\u1EC3 g\u1EEDi \u0111\u1ED9i ph\xE1t tri\u1EC3n");
@@ -15271,43 +15688,43 @@ function showCustomHelp(version) {
   console.log("   guide          H\u01B0\u1EDBng d\u1EABn s\u1EED d\u1EE5ng nhanh");
   console.log("   quickstart     B\u1EAFt \u0111\u1EA7u t\u1EEB \u0111\xE2u? (theo t\xECnh hu\u1ED1ng)");
   console.log("   doctor         Chu\u1EA9n \u0111o\xE1n project hi\u1EC7n t\u1EA1i");
-  console.log(chalk34.bold("\n\u{1F4E6} Qu\u1EA3n l\xFD Components"));
+  console.log(chalk40.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(chalk34.bold("\n\u{1F5A5}\uFE0F  IDE & T\xEDch h\u1EE3p"));
+  console.log(chalk40.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(chalk34.bold("\n\u{1F916} AI Tools"));
+  console.log(chalk40.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(chalk34.bold("\n\u{1F4C1} Project"));
+  console.log(chalk40.bold("\n\u{1F4C1} Project"));
   console.log("   kit            Qu\u1EA3n l\xFD starter kits");
   console.log("   tasks (t)      Qu\u1EA3n l\xFD tasks ph\xE1t tri\u1EC3n");
   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(chalk34.bold("\n\u2699\uFE0F  B\u1EA3o tr\xEC"));
+  console.log(chalk40.bold("\n\u2699\uFE0F  B\u1EA3o tr\xEC"));
   console.log("   upgrade        C\u1EADp nh\u1EADt CLI client");
   console.log("   clean          D\u1ECDn d\u1EB9p cache/backup");
   console.log("   utils          Developer utilities");
   const name = getCliName();
-  console.log(chalk34.dim(`
+  console.log(chalk40.dim(`
 S\u1EED d\u1EE5ng: ${name} [l\u1EC7nh] --help \u0111\u1EC3 xem chi ti\u1EBFt`));
 }
 function showUnknownCommand(commandName) {
-  console.error(chalk34.red(`\u274C L\u1EC7nh kh\xF4ng t\u1ED3n t\u1EA1i: ${commandName}`));
+  console.error(chalk40.red(`\u274C L\u1EC7nh kh\xF4ng t\u1ED3n t\u1EA1i: ${commandName}`));
   const name = getCliName();
-  console.error(chalk34.dim(`
+  console.error(chalk40.dim(`
 G\u1EE3i \xFD: Ch\u1EA1y ${name} --help \u0111\u1EC3 xem danh s\xE1ch l\u1EC7nh`));
 }
 
 // src/cli.ts
 checkNodeVersion();
-var program = new Command79();
+var program = new Command85();
 if (process.argv.includes("-v") || process.argv.includes("--version")) {
   console.log(package_default.version);
   if (!process.argv.includes("--skip-update-check")) {
@@ -15345,11 +15762,12 @@ program.addCommand(createDepsCommand());
 program.addCommand(createTasksCommand());
 program.addCommand(createKitCommand());
 program.addCommand(createRulesCommand());
+program.addCommand(createSkillsCommand());
 program.addCommand(createUpgradeCommand());
 program.addCommand(createCleanCommand());
-var redmineCommand = new Command79("redmine").description("Redmine context sync commands");
+var redmineCommand = new Command85("redmine").description("Redmine context sync commands");
 redmineCommand.addCommand(createRedmineCheckCommand());
-var syncCommand = new Command79("sync").description("Sync Redmine issues to markdown files");
+var syncCommand = new Command85("sync").description("Sync Redmine issues to markdown files");
 syncCommand.addCommand(createSyncIssueCommand());
 syncCommand.addCommand(createSyncProjectCommand());
 redmineCommand.addCommand(syncCommand);
@@ -15367,7 +15785,7 @@ program.on("command:*", (operands) => {
 process.on("unhandledRejection", (error) => {
   void new ErrorLogService().logError(error, {
     command: process.argv.slice(2).join(" "),
-    cwdBase: basename4(process.cwd())
+    cwdBase: basename5(process.cwd())
   });
   if (error instanceof Jai1Error) {
     console.error("\u274C", error.message);
@@ -15388,7 +15806,7 @@ program.parseAsync(process.argv).then(async () => {
 }).catch((error) => {
   void new ErrorLogService().logError(error, {
     command: process.argv.slice(2).join(" "),
-    cwdBase: basename4(process.cwd())
+    cwdBase: basename5(process.cwd())
   });
   console.error("\u274C", error.message);
   process.exit(1);