@jvittechs/jai1-cli 0.1.95 → 0.1.97

package/dist/cli.js

@@ -33,7 +33,7 @@ var NetworkError = class extends Jai1Error {
 // package.json
 var package_default = {
   name: "@jvittechs/jai1-cli",
-  version: "0.1.95",
+  version: "0.1.97",
   description: "A unified CLI tool for JV-IT TECHS developers to manage Jai1 Framework. Please contact TeamAI for usage instructions.",
   type: "module",
   bin: {
@@ -70,7 +70,8 @@ var package_default = {
     "coding"
   ],
   scripts: {
-    build: "tsup src/cli.ts --dts --format esm --target node22 --out-dir dist --sourcemap",
+    build: "tsup src/cli.ts --dts --format esm --target node22 --out-dir dist --sourcemap && npm run copy-web-chat",
+    "copy-web-chat": "mkdir -p dist/web-chat && cp -r src/web-chat/* dist/web-chat/",
     dev: "tsx src/cli.ts --help",
     lint: "eslint .",
     test: "vitest run",
@@ -92,6 +93,7 @@ var package_default = {
     "ink-text-input": "^6.0.0",
     marked: "^12.0.0",
     "marked-terminal": "^7.0.0",
+    open: "^10.1.0",
     "p-limit": "^5.0.0",
     "p-queue": "^7.4.1",
     "p-retry": "^6.2.0",
@@ -798,6 +800,9 @@ var IDE_MIGRATION_CONFIGS = {
     workflowsPath: null,
     commandsPath: "commands",
     fileExtension: ".mdc",
+    // For rules
+    workflowsExtension: ".md",
+    // For workflows/commands
     generateFrontmatter: (opts) => {
       const lines = ["---"];
       if (opts.description) {
@@ -1000,7 +1005,14 @@ var MigrateIdeService = class {
       const stat = await fs4.stat(filepath);
       if (!stat.isFile()) continue;
       const content = await fs4.readFile(filepath, "utf-8");
-      const { data: frontmatter } = matter(content);
+      let frontmatter = {};
+      try {
+        const { data } = matter(content);
+        frontmatter = data;
+      } catch (e) {
+        console.warn(`\u26A0\uFE0F  Skipping ${file}: Invalid YAML frontmatter`);
+        continue;
+      }
       const name = path.basename(file, ".md");
       const trigger = this.extractTrigger(frontmatter);
       const alwaysApply = this.isAlwaysTrigger(trigger);
@@ -1105,21 +1117,24 @@ ${reference}
    */
   getTargetPath(config, item) {
     let contentPath = null;
+    let extension = config.fileExtension;
     switch (item.type) {
       case "rules":
         contentPath = config.rulesPath;
         break;
       case "workflows":
         contentPath = config.workflowsPath ?? config.commandsPath;
+        extension = config.workflowsExtension ?? config.fileExtension;
         break;
       case "commands":
         contentPath = config.commandsPath;
+        extension = config.workflowsExtension ?? config.fileExtension;
         break;
     }
     if (!contentPath) {
       return null;
     }
-    const filename = `${item.name}${config.fileExtension}`;
+    const filename = `${item.name}${extension}`;
     return path.join(this.projectPath, config.basePath, contentPath, filename);
   }
   // Helper methods
@@ -2349,7 +2364,15 @@ var ContextScannerService = class {
   async parseContextItem(filepath, ide, type) {
     const content = await fs5.readFile(filepath, "utf-8");
     const stat = await fs5.stat(filepath);
-    const { data: frontmatter, content: bodyContent } = matter2(content);
+    let frontmatter = {};
+    let bodyContent = content;
+    try {
+      const parsed = matter2(content);
+      frontmatter = parsed.data;
+      bodyContent = parsed.content;
+    } catch (e) {
+      console.warn(`\u26A0\uFE0F  Invalid YAML frontmatter in ${filepath}, skipping frontmatter parsing`);
+    }
     const config = IDE_CONFIGS[ide];
     const description = frontmatter[config.frontmatterSchema.descriptionField];
     let globs;
@@ -3366,9 +3389,9 @@ var IdeDetectionService = class {
   /**
    * Check if a path exists
    */
-  async pathExists(path8) {
+  async pathExists(path9) {
     try {
-      await fs7.access(path8);
+      await fs7.access(path9);
       return true;
     } catch {
       return false;
@@ -4563,15 +4586,19 @@ var LlmProxyService = class {
     }
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
+    let buffer = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        const chunk = decoder.decode(value, { stream: true });
-        const lines = chunk.split("\n").filter((line) => line.trim() !== "");
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
         for (const line of lines) {
-          if (line.startsWith("data: ")) {
-            const data = line.slice(6);
+          const trimmedLine = line.trim();
+          if (!trimmedLine) continue;
+          if (trimmedLine.startsWith("data: ")) {
+            const data = trimmedLine.slice(6);
             if (data === "[DONE]") {
               return;
             }
@@ -4586,6 +4613,22 @@ var LlmProxyService = class {
           }
         }
       }
+      if (buffer.trim()) {
+        const trimmedLine = buffer.trim();
+        if (trimmedLine.startsWith("data: ")) {
+          const data = trimmedLine.slice(6);
+          if (data !== "[DONE]") {
+            try {
+              const parsed = JSON.parse(data);
+              const content = parsed.choices[0]?.delta?.content;
+              if (content) {
+                yield content;
+              }
+            } catch (e) {
+            }
+          }
+        }
+      }
     } finally {
       reader.releaseLock();
     }
@@ -5068,8 +5111,469 @@ var ChatApp = ({ service, initialModel }) => {
   ), /* @__PURE__ */ React25.createElement(Box16, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React25.createElement(Text17, { dimColor: true }, footer)));
 };
 
+// src/server/web-chat-server.ts
+import http from "http";
+import fs8 from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+
+// src/server/session.ts
+import crypto from "crypto";
+var SESSION_PREFIX = "wc_";
+var DEFAULT_TTL_MINUTES = 30;
+var SessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  cleanupInterval = null;
+  constructor() {
+    this.startCleanup();
+  }
+  /**
+   * Generate a new session token
+   */
+  generateToken() {
+    const randomBytes = crypto.randomBytes(16).toString("hex");
+    return `${SESSION_PREFIX}${randomBytes}`;
+  }
+  /**
+   * Create a new session
+   */
+  createSession(config) {
+    const token = this.generateToken();
+    const now = /* @__PURE__ */ new Date();
+    const ttlMinutes = config.ttlMinutes ?? DEFAULT_TTL_MINUTES;
+    const session = {
+      token,
+      accessKey: config.accessKey,
+      apiUrl: config.apiUrl,
+      createdAt: now,
+      expiresAt: new Date(now.getTime() + ttlMinutes * 60 * 1e3),
+      lastActivity: now
+    };
+    this.sessions.set(token, session);
+    return session;
+  }
+  /**
+   * Validate a session token and return session if valid
+   * Also extends the session TTL on successful validation
+   */
+  validateSession(token) {
+    if (!token || !token.startsWith(SESSION_PREFIX)) {
+      return null;
+    }
+    const session = this.sessions.get(token);
+    if (!session) {
+      return null;
+    }
+    if (/* @__PURE__ */ new Date() > session.expiresAt) {
+      this.sessions.delete(token);
+      return null;
+    }
+    session.lastActivity = /* @__PURE__ */ new Date();
+    session.expiresAt = new Date(
+      session.lastActivity.getTime() + DEFAULT_TTL_MINUTES * 60 * 1e3
+    );
+    return session;
+  }
+  /**
+   * Get session without extending TTL
+   */
+  getSession(token) {
+    if (!token || !token.startsWith(SESSION_PREFIX)) {
+      return null;
+    }
+    const session = this.sessions.get(token);
+    if (!session) {
+      return null;
+    }
+    if (/* @__PURE__ */ new Date() > session.expiresAt) {
+      this.sessions.delete(token);
+      return null;
+    }
+    return session;
+  }
+  /**
+   * Invalidate/delete a session
+   */
+  invalidateSession(token) {
+    this.sessions.delete(token);
+  }
+  /**
+   * Get remaining TTL in seconds
+   */
+  getTimeToLive(token) {
+    const session = this.getSession(token);
+    if (!session) {
+      return 0;
+    }
+    const remaining = session.expiresAt.getTime() - Date.now();
+    return Math.max(0, Math.floor(remaining / 1e3));
+  }
+  /**
+   * Start periodic cleanup of expired sessions
+   */
+  startCleanup() {
+    this.cleanupInterval = setInterval(() => {
+      const now = /* @__PURE__ */ new Date();
+      for (const [token, session] of this.sessions.entries()) {
+        if (now > session.expiresAt) {
+          this.sessions.delete(token);
+        }
+      }
+    }, 5 * 60 * 1e3);
+    this.cleanupInterval.unref();
+  }
+  /**
+   * Stop cleanup interval (call when shutting down)
+   */
+  stopCleanup() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+  }
+  /**
+   * Clear all sessions (for shutdown)
+   */
+  clearAll() {
+    this.sessions.clear();
+    this.stopCleanup();
+  }
+  /**
+   * Get active session count (for debugging)
+   */
+  getActiveSessionCount() {
+    return this.sessions.size;
+  }
+};
+
+// src/server/web-chat-server.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path4.dirname(__filename);
+var MIME_TYPES = {
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon"
+};
+async function findAvailablePort(startPort, endPort) {
+  for (let port = startPort; port <= endPort; port++) {
+    try {
+      await new Promise((resolve4, reject) => {
+        const server = http.createServer();
+        server.listen(port, "127.0.0.1");
+        server.once("listening", () => {
+          server.close(() => resolve4());
+        });
+        server.once("error", reject);
+      });
+      return port;
+    } catch {
+      continue;
+    }
+  }
+  throw new Error(`No available port found in range ${startPort}-${endPort}`);
+}
+async function parseJsonBody(req) {
+  return new Promise((resolve4, reject) => {
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk.toString();
+    });
+    req.on("end", () => {
+      try {
+        resolve4(body ? JSON.parse(body) : {});
+      } catch (e) {
+        reject(new Error("Invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+function sendJson(res, statusCode, data) {
+  res.writeHead(statusCode, {
+    "Content-Type": "application/json",
+    "Access-Control-Allow-Origin": "*",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Access-Control-Allow-Headers": "Content-Type, X-Session-Token"
+  });
+  res.end(JSON.stringify(data));
+}
+function sendError(res, statusCode, code, message) {
+  sendJson(res, statusCode, {
+    success: false,
+    error: { code, message }
+  });
+}
+function getSessionToken(req) {
+  const headerToken = req.headers["x-session-token"];
+  if (headerToken && typeof headerToken === "string") {
+    return headerToken;
+  }
+  const url = new URL(req.url || "/", `http://${req.headers.host}`);
+  return url.searchParams.get("session");
+}
+function createWebChatServer(options) {
+  const { config } = options;
+  const host = options.host ?? "127.0.0.1";
+  let port = options.port ?? 0;
+  const sessionManager = new SessionManager();
+  let server = null;
+  let session = null;
+  const staticDir = path4.join(__dirname, "web-chat");
+  async function serveStaticFile(res, filePath) {
+    const fullPath = path4.join(staticDir, filePath);
+    if (!fullPath.startsWith(staticDir)) {
+      sendError(res, 403, "ERR-WC-006", "Forbidden");
+      return;
+    }
+    try {
+      const stat = await fs8.promises.stat(fullPath);
+      if (!stat.isFile()) {
+        sendError(res, 404, "ERR-WC-007", "Not found");
+        return;
+      }
+      const ext = path4.extname(fullPath);
+      const contentType = MIME_TYPES[ext] || "application/octet-stream";
+      const content = await fs8.promises.readFile(fullPath);
+      res.writeHead(200, { "Content-Type": contentType });
+      res.end(content);
+    } catch (error) {
+      if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        sendError(res, 404, "ERR-WC-007", "Not found");
+      } else {
+        sendError(res, 500, "ERR-WC-008", "Internal server error");
+      }
+    }
+  }
+  async function handleApi(req, res, pathname) {
+    if (req.method === "OPTIONS") {
+      res.writeHead(204, {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, X-Session-Token"
+      });
+      res.end();
+      return;
+    }
+    if (pathname === "/health") {
+      sendJson(res, 200, { status: "ok" });
+      return;
+    }
+    const token = getSessionToken(req);
+    const validSession = token ? sessionManager.validateSession(token) : null;
+    if (!validSession) {
+      sendError(
+        res,
+        401,
+        "ERR-WC-001",
+        "Session expired. Please run 'jai1 chat --web' again."
+      );
+      return;
+    }
+    const llmService = new LlmProxyService({
+      accessKey: validSession.accessKey,
+      apiUrl: validSession.apiUrl
+    });
+    if (pathname === "/api/session" && req.method === "GET") {
+      try {
+        const models = await llmService.getModelsWithUsage();
+        const allowedModels = models.filter((m) => m.allowed).map((m) => m.id);
+        sendJson(res, 200, {
+          success: true,
+          data: {
+            expiresAt: validSession.expiresAt.toISOString(),
+            models: allowedModels
+          }
+        });
+      } catch (error) {
+        sendError(res, 502, "ERR-WC-004", "Failed to connect to LLM service.");
+      }
+      return;
+    }
+    if (pathname === "/api/models" && req.method === "GET") {
+      try {
+        const models = await llmService.getModelsWithUsage();
+        sendJson(res, 200, {
+          success: true,
+          data: models.filter((m) => m.allowed)
+        });
+      } catch (error) {
+        sendError(res, 502, "ERR-WC-004", "Failed to connect to LLM service.");
+      }
+      return;
+    }
+    if (pathname === "/api/stats" && req.method === "GET") {
+      try {
+        const [limits, usage] = await Promise.all([
+          llmService.getLimits(),
+          llmService.getUsage(1)
+          // Today only
+        ]);
+        const today = (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", { timeZone: "Asia/Ho_Chi_Minh" });
+        const modelStats = {};
+        const allowedModels = limits.effectiveAllowedModels || [];
+        const rateLimits = limits.effectiveRateLimits || {};
+        allowedModels.forEach((modelId) => {
+          const limit = rateLimits[modelId] || rateLimits[modelId.toLowerCase()] || 0;
+          const usageRecord = (usage.data || []).find(
+            (u) => (u.model === modelId || u.model.toLowerCase() === modelId.toLowerCase()) && u.date === today
+          );
+          const used = usageRecord?.count || 0;
+          modelStats[modelId] = {
+            limit,
+            used,
+            remaining: Math.max(0, limit - used)
+          };
+        });
+        sendJson(res, 200, {
+          success: true,
+          data: {
+            date: today,
+            models: modelStats
+          }
+        });
+      } catch (error) {
+        sendError(res, 502, "ERR-WC-004", "Failed to connect to LLM service.");
+      }
+      return;
+    }
+    if (pathname === "/api/chat" && req.method === "POST") {
+      try {
+        const body = await parseJsonBody(req);
+        if (!body.message || !body.model) {
+          sendError(res, 400, "ERR-WC-009", "Missing message or model");
+          return;
+        }
+        const messages = [];
+        if (body.systemPrompt) {
+          messages.push({ role: "system", content: body.systemPrompt });
+        }
+        messages.push(
+          ...(body.history || []).map((m) => ({
+            role: m.role,
+            content: m.content
+          })),
+          { role: "user", content: body.message }
+        );
+        res.writeHead(200, {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          Connection: "keep-alive",
+          "Access-Control-Allow-Origin": "*"
+        });
+        try {
+          for await (const chunk of llmService.chatStream(
+            messages,
+            body.model
+          )) {
+            res.write(
+              `data: ${JSON.stringify({ type: "chunk", content: chunk })}
+
+`
+            );
+          }
+          res.write(`data: ${JSON.stringify({ type: "done" })}
+
+`);
+        } catch (streamError) {
+          const errorMessage = streamError instanceof Error ? streamError.message : "Unknown error";
+          if (errorMessage.includes("not allowed")) {
+            res.write(
+              `data: ${JSON.stringify({ type: "error", code: "ERR-WC-002", message: "You don't have access to this model." })}
+
+`
+            );
+          } else if (errorMessage.includes("rate limit")) {
+            res.write(
+              `data: ${JSON.stringify({ type: "error", code: "ERR-WC-003", message: "Rate limit exceeded. Please wait." })}
+
+`
+            );
+          } else {
+            res.write(
+              `data: ${JSON.stringify({ type: "error", code: "ERR-WC-004", message: errorMessage })}
+
+`
+            );
+          }
+        }
+        res.end();
+      } catch (error) {
+        sendError(res, 500, "ERR-WC-008", "Internal server error");
+      }
+      return;
+    }
+    sendError(res, 404, "ERR-WC-010", "API endpoint not found");
+  }
+  async function handleRequest(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    try {
+      if (pathname.startsWith("/api/") || pathname === "/health") {
+        await handleApi(req, res, pathname);
+        return;
+      }
+      let filePath = pathname === "/" ? "/index.html" : pathname;
+      filePath = filePath.replace(/^\//, "");
+      await serveStaticFile(res, filePath);
+    } catch (error) {
+      console.error("[WebChatServer] Error:", error);
+      sendError(res, 500, "ERR-WC-008", "Internal server error");
+    }
+  }
+  return {
+    async start() {
+      if (!port || port === 0) {
+        port = await findAvailablePort(54321, 54399);
+      }
+      session = sessionManager.createSession({
+        accessKey: config.accessKey,
+        apiUrl: config.apiUrl
+      });
+      server = http.createServer(handleRequest);
+      return new Promise((resolve4, reject) => {
+        server.listen(port, host, () => {
+          console.log(`
+\u{1F310} Web Chat server started at http://${host}:${port}`);
+          console.log(`\u{1F4CB} Session token: ${session.token.slice(0, 12)}...`);
+          console.log(`\u23F0 Session expires in 30 minutes
+`);
+          resolve4({
+            port,
+            sessionToken: session.token
+          });
+        });
+        server.once("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            reject(new Error(`Port ${port} is already in use.`));
+          } else {
+            reject(err);
+          }
+        });
+      });
+    },
+    async stop() {
+      if (server) {
+        return new Promise((resolve4) => {
+          server.close(() => {
+            sessionManager.clearAll();
+            console.log("\n\u{1F44B} Web Chat server stopped");
+            resolve4();
+          });
+        });
+      }
+    },
+    getUrl() {
+      return `http://${host}:${port}/?session=${session?.token || ""}`;
+    }
+  };
+}
+
 // src/commands/chat.ts
-async function handleChatCommand(options) {
+async function handleTerminalChat(options) {
   const configService = new ConfigService();
   const config = await configService.load();
   if (!config) {
@@ -5090,8 +5594,58 @@ async function handleChatCommand(options) {
   await waitUntilExit();
   clear();
 }
+async function handleWebChat(options) {
+  const configService = new ConfigService();
+  const config = await configService.load();
+  if (!config) {
+    throw new ValidationError('Not initialized. Run "jai1 auth" first.');
+  }
+  const port = options.port ? parseInt(options.port, 10) : void 0;
+  const server = createWebChatServer({
+    config,
+    port
+  });
+  try {
+    const { port: actualPort, sessionToken } = await server.start();
+    const url = server.getUrl();
+    if (!options.noOpen) {
+      const { default: open } = await import("open");
+      await open(url);
+      console.log("\u{1F310} Browser opened with chat interface");
+    } else {
+      console.log(`
+\u{1F4CB} Open this URL in your browser:
+   ${url}
+`);
+    }
+    console.log("Press Ctrl+C to stop the server\n");
+    await new Promise((resolve4) => {
+      process.on("SIGINT", async () => {
+        console.log("\n\n\u{1F6D1} Shutting down...");
+        await server.stop();
+        resolve4();
+      });
+      process.on("SIGTERM", async () => {
+        await server.stop();
+        resolve4();
+      });
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Port")) {
+      throw new ValidationError(error.message + " Try specifying a different port with --port.");
+    }
+    throw error;
+  }
+}
+async function handleChatCommand(options) {
+  if (options.web) {
+    await handleWebChat(options);
+  } else {
+    await handleTerminalChat(options);
+  }
+}
 function createChatCommand() {
-  const cmd = new Command12("chat").description("Interactive AI chat with Jai1 LLM Proxy").option("--model <model>", "Initial model to use (e.g., gpt-4o, claude-3-opus)").action(async (options) => {
+  const cmd = new Command12("chat").description("Interactive AI chat with Jai1 LLM Proxy").option("--model <model>", "Initial model to use (e.g., gpt-4o, claude-3-opus)").option("--web", "Open chat in web browser instead of terminal").option("--port <port>", "Port for web server (default: auto-find available port)").option("--no-open", "Don't auto-open browser (web mode only)").action(async (options) => {
     await handleChatCommand(options);
   });
   return cmd;
@@ -5239,8 +5793,8 @@ function createStatsCommand() {
 import { Command as Command15 } from "commander";
 
 // src/services/translation.service.ts
-import { promises as fs8 } from "fs";
-import path4 from "path";
+import { promises as fs9 } from "fs";
+import path5 from "path";
 import pLimit from "p-limit";
 import pRetry from "p-retry";
 var TRANSLATABLE_EXTS = [".md", ".txt", ".json", ".yaml", ".yml"];
@@ -5258,7 +5812,7 @@ var TranslationService = class {
    */
   async detectInputType(input4) {
     try {
-      const stat = await fs8.stat(input4);
+      const stat = await fs9.stat(input4);
       if (stat.isDirectory()) return "folder";
       if (stat.isFile()) return "file";
     } catch {
@@ -5295,13 +5849,13 @@ var TranslationService = class {
    */
   async translateFile(filePath) {
     try {
-      const content = await fs8.readFile(filePath, "utf-8");
-      const ext = path4.extname(filePath).toLowerCase();
+      const content = await fs9.readFile(filePath, "utf-8");
+      const ext = path5.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 fs8.writeFile(outputPath, translatedContent, "utf-8");
+        await fs9.writeFile(outputPath, translatedContent, "utf-8");
       }
       return {
         inputPath: filePath,
@@ -5356,27 +5910,27 @@ var TranslationService = class {
     if (this.options.output) {
       return this.options.output;
     }
-    const ext = path4.extname(inputPath);
-    const base = path4.basename(inputPath, ext);
-    const dir = path4.dirname(inputPath);
+    const ext = path5.extname(inputPath);
+    const base = path5.basename(inputPath, ext);
+    const dir = path5.dirname(inputPath);
     const lang = this.options.to;
-    return path4.join(dir, `${base}.${lang}${ext}`);
+    return path5.join(dir, `${base}.${lang}${ext}`);
   }
   /**
    * Discover translatable files in folder recursively
    */
   async discoverFiles(folderPath) {
-    const entries = await fs8.readdir(folderPath, { withFileTypes: true });
+    const entries = await fs9.readdir(folderPath, { withFileTypes: true });
     const files = [];
     for (const entry of entries) {
-      const fullPath = path4.join(folderPath, entry.name);
+      const fullPath = path5.join(folderPath, entry.name);
       if (entry.isDirectory()) {
         if (!entry.name.startsWith(".") && entry.name !== "node_modules") {
           const subFiles = await this.discoverFiles(fullPath);
           files.push(...subFiles);
         }
       } else if (entry.isFile()) {
-        const ext = path4.extname(entry.name).toLowerCase();
+        const ext = path5.extname(entry.name).toLowerCase();
         if (TRANSLATABLE_EXTS.includes(ext)) {
           if (!this.isTranslatedFile(entry.name)) {
             files.push(fullPath);
@@ -5881,7 +6435,7 @@ import { Command as Command34 } from "commander";
 import { Command as Command21 } from "commander";
 
 // src/services/utils.service.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 import bcrypt from "bcryptjs";
 import { readFile } from "fs/promises";
 var UtilsService = class {
@@ -5905,7 +6459,7 @@ var UtilsService = class {
     if (charset.length === 0) {
       throw new Error("At least one character type must be enabled");
     }
-    const randomBytes = crypto.randomBytes(length);
+    const randomBytes = crypto2.randomBytes(length);
     let password = "";
     for (let i = 0; i < length; i++) {
       const randomIndex = randomBytes[i] % charset.length;
@@ -5917,7 +6471,7 @@ var UtilsService = class {
    * Generate UUID v4
    */
   generateUuid(options) {
-    let uuid = crypto.randomUUID();
+    let uuid = crypto2.randomUUID();
     if (options?.uppercase) {
       uuid = uuid.toUpperCase();
     }
@@ -5933,7 +6487,7 @@ var UtilsService = class {
     if (algorithm === "bcrypt") {
       throw new Error("Use hashBcrypt for bcrypt algorithm");
     }
-    const hash = crypto.createHash(algorithm);
+    const hash = crypto2.createHash(algorithm);
     hash.update(input4);
     return hash.digest("hex");
   }
@@ -6021,7 +6575,7 @@ var UtilsService = class {
     const headerB64 = this.base64Encode(JSON.stringify(finalHeader), true);
     const payloadB64 = this.base64Encode(JSON.stringify(payload), true);
     const signatureInput = `${headerB64}.${payloadB64}`;
-    const signature = crypto.createHmac("sha256", secret).update(signatureInput).digest("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    const signature = crypto2.createHmac("sha256", secret).update(signatureInput).digest("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
     return `${headerB64}.${payloadB64}.${signature}`;
   }
   /**
@@ -7928,8 +8482,8 @@ var HttpView = () => {
 import React37, { useState as useState24 } from "react";
 import { Box as Box27, Text as Text28, useInput as useInput22 } from "ink";
 import TextInput14 from "ink-text-input";
-import * as fs9 from "fs";
-import * as path5 from "path";
+import * as fs10 from "fs";
+import * as path6 from "path";
 var MarkdownView = () => {
   const [filePath, setFilePath] = useState24("");
   const [content, setContent] = useState24("");
@@ -7949,12 +8503,12 @@ var MarkdownView = () => {
     }
     try {
       setError("");
-      const resolvedPath = path5.resolve(filePath);
-      if (!fs9.existsSync(resolvedPath)) {
+      const resolvedPath = path6.resolve(filePath);
+      if (!fs10.existsSync(resolvedPath)) {
         setError(`File not found: ${resolvedPath}`);
         return;
       }
-      let fileContent = fs9.readFileSync(resolvedPath, "utf-8");
+      let fileContent = fs10.readFileSync(resolvedPath, "utf-8");
       fileContent = fileContent.replace(/```mermaid\n([\s\S]*?)```/g, (match, code) => {
         return `
 \u{1F3A8} **Mermaid Diagram**
@@ -8235,8 +8789,8 @@ import { Command as Command35 } from "commander";
 import { checkbox as checkbox3, confirm as confirm5 } from "@inquirer/prompts";
 
 // src/services/deps.service.ts
-import { promises as fs10 } from "fs";
-import path6 from "path";
+import { promises as fs11 } from "fs";
+import path7 from "path";
 import { execSync } from "child_process";
 import pLimit2 from "p-limit";
 var DepsService = class {
@@ -8245,9 +8799,9 @@ var DepsService = class {
    * Đọc package.json từ thư mục
    */
   async readPackageJson(cwd) {
-    const pkgPath = path6.join(cwd, "package.json");
+    const pkgPath = path7.join(cwd, "package.json");
     try {
-      const content = await fs10.readFile(pkgPath, "utf-8");
+      const content = await fs11.readFile(pkgPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       if (error.code === "ENOENT") {
@@ -8353,7 +8907,7 @@ var DepsService = class {
     ];
     for (const { file, pm } of lockFiles) {
       try {
-        await fs10.access(path6.join(cwd, file));
+        await fs11.access(path7.join(cwd, file));
         return pm;
       } catch {
       }
@@ -8637,7 +9191,7 @@ import { Command as Command40 } from "commander";
 import { Command as Command37 } from "commander";
 
 // src/services/starter-kit.service.ts
-import { promises as fs11 } from "fs";
+import { promises as fs12 } from "fs";
 import { join as join5 } from "path";
 import AdmZip from "adm-zip";
 var StarterKitService = class {
@@ -8686,16 +9240,16 @@ var StarterKitService = class {
     }
     if (onProgress) onProgress(30);
     const tmpDir = join5(process.env.TMPDIR || "/tmp", "jai1-kits");
-    await fs11.mkdir(tmpDir, { recursive: true });
+    await fs12.mkdir(tmpDir, { recursive: true });
     const tmpFile = join5(tmpDir, `${slug}.zip`);
     const buffer = await response.arrayBuffer();
-    await fs11.writeFile(tmpFile, Buffer.from(buffer));
+    await fs12.writeFile(tmpFile, Buffer.from(buffer));
     if (onProgress) onProgress(60);
     const zip = new AdmZip(tmpFile);
-    await fs11.mkdir(targetDir, { recursive: true });
+    await fs12.mkdir(targetDir, { recursive: true });
     zip.extractAllTo(targetDir, true);
     if (onProgress) onProgress(100);
-    await fs11.unlink(tmpFile);
+    await fs12.unlink(tmpFile);
   }
 };
 
@@ -8790,7 +9344,7 @@ Post-Init Commands:`);
 
 // src/commands/kit/create.ts
 import { Command as Command39 } from "commander";
-import { promises as fs12 } from "fs";
+import { promises as fs13 } from "fs";
 import { join as join6 } from "path";
 import { select as select2, input, checkbox as checkbox4 } from "@inquirer/prompts";
 import { execa as execa2 } from "execa";
@@ -8856,7 +9410,7 @@ function createKitCreateCommand() {
     }
     const targetDir = directory || join6(process.cwd(), options.name || slug);
     try {
-      await fs12.access(targetDir);
+      await fs13.access(targetDir);
       throw new Error(`Directory already exists: ${targetDir}`);
     } catch (error) {
       if (error.code !== "ENOENT") {
@@ -8974,7 +9528,7 @@ function createKitCreateCommand() {
 async function applyVariableSubstitution(dir, variables) {
   const files = await getAllFiles(dir);
   for (const file of files) {
-    let content = await fs12.readFile(file, "utf-8");
+    let content = await fs13.readFile(file, "utf-8");
     let modified = false;
     for (const [key, value] of Object.entries(variables)) {
       const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
@@ -8984,13 +9538,13 @@ async function applyVariableSubstitution(dir, variables) {
       }
     }
     if (modified) {
-      await fs12.writeFile(file, content, "utf-8");
+      await fs13.writeFile(file, content, "utf-8");
     }
   }
 }
 async function getAllFiles(dir) {
   const files = [];
-  const entries = await fs12.readdir(dir, { withFileTypes: true });
+  const entries = await fs13.readdir(dir, { withFileTypes: true });
   for (const entry of entries) {
     const fullPath = join6(dir, entry.name);
     if (entry.isDirectory()) {
@@ -9077,7 +9631,7 @@ function createRulesListCommand() {
 
 // src/commands/rules/init.ts
 import { Command as Command42 } from "commander";
-import { promises as fs13 } from "fs";
+import { promises as fs14 } from "fs";
 import { join as join7 } from "path";
 import { select as select3, confirm as confirm6 } from "@inquirer/prompts";
 function createRulesInitCommand() {
@@ -9163,7 +9717,7 @@ function createRulesInitCommand() {
       appliedAt: (/* @__PURE__ */ new Date()).toISOString(),
       customContext: "09-custom.mdc"
     };
-    await fs13.writeFile("jai1-rules.json", JSON.stringify(projectConfig, null, 2));
+    await fs14.writeFile("jai1-rules.json", JSON.stringify(projectConfig, null, 2));
     console.log("\u2713 Created jai1-rules.json");
     console.log("\n\u2705 Preset applied successfully!\n");
     console.log("Next steps:");
@@ -9174,10 +9728,10 @@ function createRulesInitCommand() {
 }
 async function applyCursorFormat(bundle) {
   const rulesDir = join7(process.cwd(), ".cursor", "rules");
-  await fs13.mkdir(rulesDir, { recursive: true });
+  await fs14.mkdir(rulesDir, { recursive: true });
   for (const [filename, content] of Object.entries(bundle.files)) {
     const filePath = join7(rulesDir, filename);
-    await fs13.writeFile(filePath, content, "utf-8");
+    await fs14.writeFile(filePath, content, "utf-8");
     console.log(`\u2713 Created .cursor/rules/${filename}`);
   }
 }
@@ -9204,13 +9758,13 @@ async function applyAgentsMdFormat(bundle) {
     }
   }
   const agentsMd = sections.join("\n");
-  await fs13.writeFile("AGENTS.md", agentsMd, "utf-8");
+  await fs14.writeFile("AGENTS.md", agentsMd, "utf-8");
   console.log("\u2713 Created AGENTS.md");
 }
 
 // src/commands/rules/apply.ts
 import { Command as Command43 } from "commander";
-import { promises as fs15 } from "fs";
+import { promises as fs16 } from "fs";
 import { join as join9 } from "path";
 import { select as select4, confirm as confirm7, checkbox as checkbox5 } from "@inquirer/prompts";
 
@@ -9571,7 +10125,7 @@ Follow all instructions and patterns defined in AGENTS.md above.
 };
 
 // src/services/backup.service.ts
-import { promises as fs14 } from "fs";
+import { promises as fs15 } from "fs";
 import { join as join8, dirname } from "path";
 var BackupService = class {
   backupDir = ".jai1/backups";
@@ -9602,16 +10156,16 @@ var BackupService = class {
           await this.backupSingleFile("GEMINI.md", backupPath, ideId, backedUpFiles);
           hasContent = true;
         } else {
-          const stats = await fs14.stat(rulesPath);
+          const stats = await fs15.stat(rulesPath);
           if (stats.isDirectory()) {
-            const files = await fs14.readdir(rulesPath);
+            const files = await fs15.readdir(rulesPath);
             for (const file of files) {
               if (file.endsWith(format.fileExtension)) {
                 const originalPath = join8(rulesPath, file);
                 const relativePath = join8(format.rulesPath, file);
                 const destPath = join8(backupPath, ideId, file);
-                await fs14.mkdir(dirname(destPath), { recursive: true });
-                await fs14.copyFile(originalPath, destPath);
+                await fs15.mkdir(dirname(destPath), { recursive: true });
+                await fs15.copyFile(originalPath, destPath);
                 backedUpFiles.push({
                   originalPath: relativePath,
                   backupPath: join8(ideId, file),
@@ -9635,8 +10189,8 @@ var BackupService = class {
       ides,
       files: backedUpFiles
     };
-    await fs14.mkdir(backupPath, { recursive: true });
-    await fs14.writeFile(
+    await fs15.mkdir(backupPath, { recursive: true });
+    await fs15.writeFile(
       join8(backupPath, "metadata.json"),
       JSON.stringify(metadata, null, 2),
       "utf-8"
@@ -9654,8 +10208,8 @@ var BackupService = class {
         return;
       }
       const destPath = join8(backupPath, ideId, filename);
-      await fs14.mkdir(dirname(destPath), { recursive: true });
-      await fs14.copyFile(originalPath, destPath);
+      await fs15.mkdir(dirname(destPath), { recursive: true });
+      await fs15.copyFile(originalPath, destPath);
       backedUpFiles.push({
         originalPath: filename,
         backupPath: join8(ideId, filename),
@@ -9669,15 +10223,15 @@ var BackupService = class {
    */
   async restoreBackup(backupPath) {
     const metadataPath = join8(backupPath, "metadata.json");
-    const metadataContent = await fs14.readFile(metadataPath, "utf-8");
+    const metadataContent = await fs15.readFile(metadataPath, "utf-8");
     const metadata = JSON.parse(metadataContent);
     console.log(`
 Restoring backup from ${metadata.timestamp}...`);
     for (const file of metadata.files) {
       const sourcePath = join8(backupPath, file.backupPath);
       const destPath = join8(process.cwd(), file.originalPath);
-      await fs14.mkdir(dirname(destPath), { recursive: true });
-      await fs14.copyFile(sourcePath, destPath);
+      await fs15.mkdir(dirname(destPath), { recursive: true });
+      await fs15.copyFile(sourcePath, destPath);
       console.log(`\u2713 Restored ${file.originalPath}`);
     }
     console.log("\n\u2705 Backup restored successfully!");
@@ -9692,13 +10246,13 @@ Restoring backup from ${metadata.timestamp}...`);
       if (!exists) {
         return [];
       }
-      const entries = await fs14.readdir(backupDirPath, { withFileTypes: true });
+      const entries = await fs15.readdir(backupDirPath, { withFileTypes: true });
       const backups = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
           const metadataPath = join8(backupDirPath, entry.name, "metadata.json");
           try {
-            const metadataContent = await fs14.readFile(metadataPath, "utf-8");
+            const metadataContent = await fs15.readFile(metadataPath, "utf-8");
             const metadata = JSON.parse(metadataContent);
             backups.push(metadata);
           } catch {
@@ -9745,9 +10299,9 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Check if a path exists
    */
-  async pathExists(path8) {
+  async pathExists(path9) {
     try {
-      await fs14.access(path8);
+      await fs15.access(path9);
       return true;
     } catch {
       return false;
@@ -9756,22 +10310,22 @@ Restoring backup from ${metadata.timestamp}...`);
   /**
    * Recursively delete a directory
    */
-  async deleteDirectory(path8) {
+  async deleteDirectory(path9) {
     try {
-      const exists = await this.pathExists(path8);
+      const exists = await this.pathExists(path9);
       if (!exists) {
         return;
       }
-      const entries = await fs14.readdir(path8, { withFileTypes: true });
+      const entries = await fs15.readdir(path9, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join8(path8, entry.name);
+        const fullPath = join8(path9, entry.name);
         if (entry.isDirectory()) {
           await this.deleteDirectory(fullPath);
         } else {
-          await fs14.unlink(fullPath);
+          await fs15.unlink(fullPath);
         }
       }
-      await fs14.rmdir(path8);
+      await fs15.rmdir(path9);
     } catch (error) {
     }
   }
@@ -9786,7 +10340,7 @@ Restoring backup from ${metadata.timestamp}...`);
    */
   async ensureBackupDir() {
     const backupDirPath = join8(process.cwd(), this.backupDir);
-    await fs14.mkdir(backupDirPath, { recursive: true });
+    await fs15.mkdir(backupDirPath, { recursive: true });
   }
 };
 
@@ -9944,19 +10498,19 @@ function createRulesApplyCommand() {
     console.log("\n\u{1F4DD} Applying preset...\n");
     const rulePresetDir = join9(process.cwd(), ".jai1", "rule-preset");
     try {
-      await fs15.rm(rulePresetDir, { recursive: true, force: true });
+      await fs16.rm(rulePresetDir, { recursive: true, force: true });
     } catch {
     }
-    await fs15.mkdir(rulePresetDir, { recursive: true });
-    await fs15.writeFile(
+    await fs16.mkdir(rulePresetDir, { recursive: true });
+    await fs16.writeFile(
       join9(rulePresetDir, "preset.json"),
       JSON.stringify(bundle.preset, null, 2),
       "utf-8"
     );
     for (const [filename, content] of Object.entries(bundle.files)) {
       const filePath = join9(rulePresetDir, filename);
-      await fs15.mkdir(join9(filePath, ".."), { recursive: true });
-      await fs15.writeFile(filePath, content, "utf-8");
+      await fs16.mkdir(join9(filePath, ".."), { recursive: true });
+      await fs16.writeFile(filePath, content, "utf-8");
     }
     console.log(`\u2713 Saved preset to .jai1/rule-preset/`);
     const allGeneratedFiles = [];
@@ -9965,8 +10519,8 @@ function createRulesApplyCommand() {
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
           const fullPath = join9(process.cwd(), file.path);
-          await fs15.mkdir(join9(fullPath, ".."), { recursive: true });
-          await fs15.writeFile(fullPath, file.content, "utf-8");
+          await fs16.mkdir(join9(fullPath, ".."), { recursive: true });
+          await fs16.writeFile(fullPath, file.content, "utf-8");
           console.log(`\u2713 [${ideId}] ${file.path}`);
           allGeneratedFiles.push({
             ide: ideId,
@@ -9994,7 +10548,7 @@ function createRulesApplyCommand() {
     };
     try {
       const existingConfigPath = join9(process.cwd(), "jai1-rules.json");
-      const existingConfigContent = await fs15.readFile(existingConfigPath, "utf-8");
+      const existingConfigContent = await fs16.readFile(existingConfigPath, "utf-8");
       const existingConfig = JSON.parse(existingConfigContent);
       if (existingConfig.backups && existingConfig.backups.length > 0) {
         projectConfig.backups = [
@@ -10005,7 +10559,7 @@ function createRulesApplyCommand() {
       }
     } catch {
     }
-    await fs15.writeFile(
+    await fs16.writeFile(
       join9(process.cwd(), "jai1-rules.json"),
       JSON.stringify(projectConfig, null, 2),
       "utf-8"
@@ -10110,7 +10664,7 @@ function formatTimestamp(timestamp) {
 
 // src/commands/rules/sync.ts
 import { Command as Command45 } from "commander";
-import { promises as fs16 } from "fs";
+import { promises as fs17 } from "fs";
 import { join as join11 } from "path";
 import { confirm as confirm9 } from "@inquirer/prompts";
 function createRulesSyncCommand() {
@@ -10118,7 +10672,7 @@ function createRulesSyncCommand() {
     const configPath = join11(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs16.readFile(configPath, "utf-8");
+      const configContent = await fs17.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -10201,11 +10755,11 @@ Detected ${detected.length} active IDE(s):
     const rulePresetDir = join11(process.cwd(), ".jai1", "rule-preset");
     const presetExists = await checkPathExists(rulePresetDir);
     if (presetExists) {
-      const files = await fs16.readdir(rulePresetDir);
+      const files = await fs17.readdir(rulePresetDir);
       for (const file of files) {
         if (file.endsWith(".mdc")) {
           const filePath = join11(rulePresetDir, file);
-          const content = await fs16.readFile(filePath, "utf-8");
+          const content = await fs17.readFile(filePath, "utf-8");
           bundle.files[file] = content;
         }
       }
@@ -10225,8 +10779,8 @@ Detected ${detected.length} active IDE(s):
         const files = generatorService.generateForIde(bundle, ideId);
         for (const file of files) {
           const fullPath = join11(process.cwd(), file.path);
-          await fs16.mkdir(join11(fullPath, ".."), { recursive: true });
-          await fs16.writeFile(fullPath, file.content, "utf-8");
+          await fs17.mkdir(join11(fullPath, ".."), { recursive: true });
+          await fs17.writeFile(fullPath, file.content, "utf-8");
         }
         console.log(`\u2713 ${format.name} - ${files.length} files regenerated`);
       } catch (error) {
@@ -10235,7 +10789,7 @@ Detected ${detected.length} active IDE(s):
     }
     if (JSON.stringify(projectConfig.ides) !== JSON.stringify(idesToSync)) {
       projectConfig.ides = idesToSync;
-      await fs16.writeFile(
+      await fs17.writeFile(
         join11(process.cwd(), "jai1-rules.json"),
         JSON.stringify(projectConfig, null, 2),
         "utf-8"
@@ -10251,7 +10805,7 @@ Detected ${detected.length} active IDE(s):
 }
 async function checkPathExists(absolutePath) {
   try {
-    await fs16.access(absolutePath);
+    await fs17.access(absolutePath);
     return true;
   } catch {
     return false;
@@ -10260,14 +10814,14 @@ async function checkPathExists(absolutePath) {
 
 // src/commands/rules/info.ts
 import { Command as Command46 } from "commander";
-import { promises as fs17 } from "fs";
+import { promises as fs18 } from "fs";
 import { join as join12 } from "path";
 function createRulesInfoCommand() {
   return new Command46("info").description("Show current preset information").option("--json", "Output as JSON").action(async (options) => {
     const configPath = join12(process.cwd(), "jai1-rules.json");
     let projectConfig;
     try {
-      const configContent = await fs17.readFile(configPath, "utf-8");
+      const configContent = await fs18.readFile(configPath, "utf-8");
       projectConfig = JSON.parse(configContent);
     } catch {
       throw new ValidationError(
@@ -10284,9 +10838,9 @@ function createRulesInfoCommand() {
     let presetMetadata = null;
     let presetFiles = [];
     try {
-      const presetContent = await fs17.readFile(presetJsonPath, "utf-8");
+      const presetContent = await fs18.readFile(presetJsonPath, "utf-8");
       presetMetadata = JSON.parse(presetContent);
-      const files = await fs17.readdir(rulePresetDir);
+      const files = await fs18.readdir(rulePresetDir);
       presetFiles = files.filter((f) => f.endsWith(".mdc"));
     } catch {
     }
@@ -10345,9 +10899,9 @@ Available Backups (${projectConfig.backups.length}):`);
     console.log('  \u2022 "jai1 rules apply" - Apply a different preset (replaces current)');
   });
 }
-async function checkPathExists2(path8) {
+async function checkPathExists2(path9) {
   try {
-    await fs17.access(join12(process.cwd(), path8));
+    await fs18.access(join12(process.cwd(), path9));
     return true;
   } catch {
     return false;
@@ -10778,8 +11332,8 @@ var RedmineApiClient = class {
     this.retryConfig = config.defaults.retry;
     this.concurrencyLimit = pLimit3(config.defaults.concurrency);
   }
-  async request(path8, options = {}) {
-    const url = `${this.baseUrl}${path8}`;
+  async request(path9, options = {}) {
+    const url = `${this.baseUrl}${path9}`;
     const headers = {
       "X-Redmine-API-Key": this.apiAccessToken,
       "Content-Type": "application/json",
@@ -10840,8 +11394,8 @@ var RedmineApiClient = class {
     if (include && include.length > 0) {
       params.append("include", include.join(","));
     }
-    const path8 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
-    return this.request(path8);
+    const path9 = `/issues/${issueId}.json${params.toString() ? `?${params.toString()}` : ""}`;
+    return this.request(path9);
   }
   async getIssues(projectId, options = {}) {
     const params = new URLSearchParams();
@@ -10861,8 +11415,8 @@ var RedmineApiClient = class {
     if (options.updatedSince) {
       params.append("updated_on", `>=${options.updatedSince}`);
     }
-    const path8 = `/issues.json?${params.toString()}`;
-    return this.request(path8);
+    const path9 = `/issues.json?${params.toString()}`;
+    return this.request(path9);
   }
   async getAllIssues(projectId, options = {}) {
     const pageSize = options.pageSize || 100;
@@ -11166,7 +11720,15 @@ function parseMarkdownContent(content) {
       rawContent: content
     };
   }
-  const { data: frontmatter, content: body } = matter3(content);
+  let frontmatter = {};
+  let body = content;
+  try {
+    const parsed = matter3(content);
+    frontmatter = parsed.data;
+    body = parsed.content;
+  } catch (e) {
+    console.warn(`\u26A0\uFE0F  Invalid YAML frontmatter, skipping frontmatter parsing`);
+  }
   const comments = extractCommentsSection(body);
   const mainContent = removeCommentsSection(body);
   return {
@@ -11538,7 +12100,7 @@ async function handleSyncProject(options) {
 
 // src/commands/framework/info.ts
 import { Command as Command53 } from "commander";
-import { promises as fs18 } from "fs";
+import { promises as fs19 } from "fs";
 import { join as join14 } from "path";
 import { homedir as homedir5 } from "os";
 function createInfoCommand() {
@@ -11590,7 +12152,7 @@ function maskKey3(key) {
 async function getProjectStatus2() {
   const projectJai1 = join14(process.cwd(), ".jai1");
   try {
-    await fs18.access(projectJai1);
+    await fs19.access(projectJai1);
     return { exists: true, version: "Synced" };
   } catch {
     return { exists: false };
@@ -11780,8 +12342,8 @@ function createClearBackupsCommand() {
 // src/commands/vscode/index.ts
 import { Command as Command56 } from "commander";
 import { checkbox as checkbox7, confirm as confirm14, select as select7 } from "@inquirer/prompts";
-import fs19 from "fs/promises";
-import path7 from "path";
+import fs20 from "fs/promises";
+import path8 from "path";
 import { existsSync as existsSync3 } from "fs";
 var PERFORMANCE_GROUPS2 = {
   telemetry: {
@@ -12001,8 +12563,8 @@ async function selectGroupsToApply2(action) {
   }
 }
 async function applyGroups2(groupKeys, action) {
-  const vscodeDir = path7.join(process.cwd(), ".vscode");
-  const settingsPath = path7.join(vscodeDir, "settings.json");
+  const vscodeDir = path8.join(process.cwd(), ".vscode");
+  const settingsPath = path8.join(vscodeDir, "settings.json");
   const invalidGroups = groupKeys.filter((key) => !PERFORMANCE_GROUPS2[key]);
   if (invalidGroups.length > 0) {
     console.log(`
@@ -12011,13 +12573,13 @@ async function applyGroups2(groupKeys, action) {
     return;
   }
   if (!existsSync3(vscodeDir)) {
-    await fs19.mkdir(vscodeDir, { recursive: true });
+    await fs20.mkdir(vscodeDir, { recursive: true });
     console.log("\u{1F4C1} \u0110\xE3 t\u1EA1o th\u01B0 m\u1EE5c .vscode/");
   }
   let currentSettings = {};
   if (existsSync3(settingsPath)) {
     try {
-      const content = await fs19.readFile(settingsPath, "utf-8");
+      const content = await fs20.readFile(settingsPath, "utf-8");
       currentSettings = JSON.parse(content);
       console.log("\u{1F4C4} \u0110\xE3 \u0111\u1ECDc c\xE0i \u0111\u1EB7t hi\u1EC7n t\u1EA1i t\u1EEB settings.json");
     } catch {
@@ -12057,14 +12619,14 @@ async function applyGroups2(groupKeys, action) {
       }
     }
   }
-  await fs19.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
+  await fs20.writeFile(settingsPath, JSON.stringify(newSettings, null, 2));
   console.log(`
 \u2705 \u0110\xE3 c\u1EADp nh\u1EADt c\xE0i \u0111\u1EB7t VSCode t\u1EA1i: ${settingsPath}`);
   console.log("\u{1F4A1} M\u1EB9o: Kh\u1EDFi \u0111\u1ED9ng l\u1EA1i VSCode \u0111\u1EC3 \xE1p d\u1EE5ng c\xE1c thay \u0111\u1ED5i.");
 }
 async function resetSettings2(groupKeys) {
-  const vscodeDir = path7.join(process.cwd(), ".vscode");
-  const settingsPath = path7.join(vscodeDir, "settings.json");
+  const vscodeDir = path8.join(process.cwd(), ".vscode");
+  const settingsPath = path8.join(vscodeDir, "settings.json");
   if (!existsSync3(settingsPath)) {
     console.log("\n\u26A0\uFE0F  Kh\xF4ng t\xECm th\u1EA5y file settings.json");
     return;
@@ -12078,7 +12640,7 @@ async function resetSettings2(groupKeys) {
     return;
   }
   if (groupKeys.length === 0) {
-    await fs19.unlink(settingsPath);
+    await fs20.unlink(settingsPath);
     console.log("\n\u2705 \u0110\xE3 x\xF3a file settings.json");
   } else {
     await applyGroups2(groupKeys, "disable");