vibe-cokit 1.5.1 → 1.6.1

package/dist/cli.js

@@ -10,6 +10,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __require = import.meta.require;
 
 // node_modules/cac/dist/index.mjs
 import { EventEmitter } from "events";
@@ -937,8 +938,8 @@ var stubFalse_default = stubFalse;
 var freeExports = typeof exports_isBuffer == "object" && exports_isBuffer && !exports_isBuffer.nodeType && exports_isBuffer;
 var freeModule = freeExports && typeof module_isBuffer == "object" && module_isBuffer && !module_isBuffer.nodeType && module_isBuffer;
 var moduleExports = freeModule && freeModule.exports === freeExports;
-var Buffer = moduleExports ? _root_default.Buffer : undefined;
-var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;
+var Buffer2 = moduleExports ? _root_default.Buffer : undefined;
+var nativeIsBuffer = Buffer2 ? Buffer2.isBuffer : undefined;
 var isBuffer = nativeIsBuffer || stubFalse_default;
 var isBuffer_default = isBuffer;
 
@@ -2663,7 +2664,321 @@ vibe-cokit v${version}`);
 }
 
 // src/commands/doctor.ts
-import { join as join5 } from "path";
+import { join as join6 } from "path";
+
+// src/utils/keyboard.ts
+import { homedir as homedir2, platform } from "os";
+import { join as join5, dirname, basename } from "path";
+import { readdir as readdir2, stat as stat2, cp as cp2, readFile, writeFile } from "fs/promises";
+var PATCH_MARKER = "/* Vietnamese IME fix */";
+var DEL_CHAR = "\x7F";
+function detectFileType(filePath) {
+  if (filePath.includes("/claude/versions/") || filePath.includes("\\claude\\versions\\")) {
+    return "binary";
+  }
+  return "js";
+}
+async function findCliJs() {
+  const home = homedir2();
+  const isWin = platform() === "win32";
+  const nativePath = join5(home, ".local", "share", "claude", "versions");
+  try {
+    const s = await stat2(nativePath);
+    if (s.isDirectory()) {
+      const entries = await readdir2(nativePath);
+      const versions = entries.filter((e) => /^\d+\.\d+\.\d+$/.test(e));
+      versions.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }));
+      for (const ver of versions) {
+        const binPath = join5(nativePath, ver);
+        try {
+          const bs = await stat2(binPath);
+          if (bs.isFile())
+            return binPath;
+        } catch {}
+      }
+    }
+  } catch {}
+  const searchDirs = isWin ? [
+    join5(process.env.LOCALAPPDATA ?? "", "npm-cache", "_npx"),
+    join5(process.env.APPDATA ?? "", "npm", "node_modules")
+  ] : [
+    join5(home, ".npm", "_npx"),
+    join5(home, ".nvm", "versions", "node"),
+    "/usr/local/lib/node_modules",
+    "/opt/homebrew/lib/node_modules"
+  ];
+  for (const dir of searchDirs) {
+    try {
+      const s = await stat2(dir);
+      if (!s.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const found = await findCliJsRecursive(dir, 0, 5);
+    if (found)
+      return found;
+  }
+  throw new Error(`Kh\xF4ng t\xECm th\u1EA5y Claude Code.
+` + "C\xE0i \u0111\u1EB7t tr\u01B0\u1EDBc: npm install -g @anthropic-ai/claude-code");
+}
+async function findCliJsRecursive(dir, depth, maxDepth) {
+  if (depth >= maxDepth)
+    return null;
+  try {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory())
+        continue;
+      const fullPath = join5(dir, entry.name);
+      if (entry.name === "@anthropic-ai") {
+        const cliJs = join5(fullPath, "claude-code", "cli.js");
+        try {
+          const s = await stat2(cliJs);
+          if (s.isFile())
+            return cliJs;
+        } catch {}
+        continue;
+      }
+      if (entry.name === "node_modules" && depth > 0)
+        continue;
+      const found = await findCliJsRecursive(fullPath, depth + 1, maxDepth);
+      if (found)
+        return found;
+    }
+  } catch {}
+  return null;
+}
+async function readContent(filePath, fileType) {
+  if (fileType === "binary") {
+    const buf = await readFile(filePath);
+    return buf.toString("latin1");
+  }
+  return Bun.file(filePath).text();
+}
+async function writeContent(filePath, content, fileType) {
+  if (fileType === "binary") {
+    const bytes = Buffer.from(content, "latin1");
+    await writeFile(filePath, bytes);
+  } else {
+    await Bun.write(filePath, content);
+  }
+}
+function getBugPattern(fileType) {
+  if (fileType === "binary") {
+    return '.includes("\\x7F")';
+  }
+  return `.includes("${DEL_CHAR}")`;
+}
+function findBugBlock(content, fileType = "js") {
+  const pattern = getBugPattern(fileType);
+  let searchFrom = 0;
+  while (true) {
+    const idx = content.indexOf(pattern, searchFrom);
+    if (idx === -1) {
+      throw new Error(`Kh\xF4ng t\xECm th\u1EA5y bug pattern .includes("\\x7f").
+` + "Claude Code c\xF3 th\u1EC3 \u0111\xE3 \u0111\u01B0\u1EE3c Anthropic fix.");
+    }
+    const searchStart = Math.max(0, idx - 150);
+    const blockStart = content.lastIndexOf("if(", idx);
+    if (blockStart === -1 || blockStart < searchStart) {
+      searchFrom = idx + 1;
+      continue;
+    }
+    let depth = 0;
+    let blockEnd = idx;
+    const slice = content.slice(blockStart, blockStart + 800);
+    for (let i = 0;i < slice.length; i++) {
+      if (slice[i] === "{")
+        depth++;
+      else if (slice[i] === "}") {
+        depth--;
+        if (depth === 0) {
+          blockEnd = blockStart + i + 1;
+          break;
+        }
+      }
+    }
+    if (depth !== 0) {
+      searchFrom = idx + 1;
+      continue;
+    }
+    const block = content.slice(blockStart, blockEnd);
+    if (fileType === "binary" && !block.includes("deleteTokenBefore")) {
+      searchFrom = idx + 1;
+      continue;
+    }
+    return { start: blockStart, end: blockEnd, block };
+  }
+}
+function extractVariables(block) {
+  const normalized = block.replaceAll(DEL_CHAR, "\\x7f");
+  const m1 = normalized.match(/let ([\w$]+)=\(\w+\.match\(\/\\x7f\/g\)\|\|\[\]\)\.length[,;]([\w$]+)=([\w$]+)[;,]/);
+  if (!m1)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c bi\u1EBFn count/state");
+  const state = m1[2];
+  const curState = m1[3];
+  const stateEsc = state.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const m2 = block.match(new RegExp(`([\\w$]+)\\(${stateEsc}\\.text\\);([\\w$]+)\\(${stateEsc}\\.offset\\)`));
+  if (!m2)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c update functions");
+  const m3 = block.match(/([\w$]+)\.includes\("/);
+  if (!m3)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c input variable");
+  return {
+    input: m3[1],
+    state,
+    curState,
+    updateText: m2[1],
+    updateOffset: m2[2]
+  };
+}
+function generateFix(vars) {
+  const v = vars;
+  return `${PATCH_MARKER}` + `if(${v.input}.includes("\\x7f")){` + `let _n=(${v.input}.match(/\\x7f/g)||[]).length,` + `_vn=${v.input}.replace(/\\x7f/g,""),` + `${v.state}=${v.curState};` + `for(let _i=0;_i<_n;_i++)${v.state}=${v.state}.backspace();` + `for(const _c of _vn)${v.state}=${v.state}.insert(_c);` + `if(!${v.curState}.equals(${v.state})){` + `if(${v.curState}.text!==${v.state}.text)` + `${v.updateText}(${v.state}.text);` + `${v.updateOffset}(${v.state}.offset)` + `}return;}`;
+}
+function generateBinaryFix(block, vars) {
+  const v = vars;
+  const counterMatch = block.match(/let ([\w$]+)=\(/);
+  const counter = counterMatch?.[1] ?? "XH";
+  let fix = `if(!FH.backspace&&!FH.delete&&${v.input}.includes("\\x7F")){` + `let ${counter}=(${v.input}.match(/\\x7f/g)||[]).length,` + `${v.state}=${v.curState};` + `while(${counter}--)${v.state}=${v.state}.backspace();` + `for(c of ${v.input}.replace(/\\x7f/g,""))${v.state}=${v.state}.insert(c);` + `if(!${v.curState}.equals(${v.state})){` + `if(${v.curState}.text!==${v.state}.text)` + `${v.updateText}(${v.state}.text);` + `${v.updateOffset}(${v.state}.offset)` + `}return}`;
+  const diff = block.length - fix.length;
+  if (diff > 0) {
+    fix = fix.slice(0, -1) + " ".repeat(diff) + "}";
+  } else if (diff < 0) {
+    throw new Error(`Fix code qu\xE1 d\xE0i (${-diff} bytes). Kh\xF4ng th\u1EC3 patch binary.`);
+  }
+  return fix;
+}
+async function patchCliJs(filePath) {
+  const fileType = detectFileType(filePath);
+  try {
+    await stat2(filePath);
+  } catch {
+    return { success: false, message: `File kh\xF4ng t\u1ED3n t\u1EA1i: ${filePath}` };
+  }
+  const content = await readContent(filePath, fileType);
+  if (content.includes(PATCH_MARKER)) {
+    return { success: false, message: "\u0110\xE3 patch tr\u01B0\u1EDBc \u0111\xF3" };
+  }
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupDir = fileType === "binary" ? "/tmp" : dirname(filePath);
+  const backupPath = join5(backupDir, `${basename(filePath)}.backup-${timestamp}`);
+  await cp2(filePath, backupPath);
+  try {
+    const bugPattern = getBugPattern(fileType);
+    let patched = content;
+    if (fileType === "binary") {
+      let patchCount = 0;
+      while (patchCount < 10) {
+        try {
+          const { start, end, block } = findBugBlock(patched, fileType);
+          const vars = extractBinaryVariables(block);
+          const fix = generateBinaryFix(block, vars);
+          patched = patched.slice(0, start) + fix + patched.slice(end);
+          patchCount++;
+        } catch {
+          break;
+        }
+      }
+      if (patchCount === 0) {
+        throw new Error("Kh\xF4ng t\xECm th\u1EA5y bug block");
+      }
+    } else {
+      const { start, end, block } = findBugBlock(content, fileType);
+      const vars = extractVariables(block);
+      const fix = generateFix(vars);
+      patched = content.slice(0, start) + fix + content.slice(end);
+    }
+    if (fileType === "binary" && patched.length !== content.length) {
+      throw new Error(`Binary patch size mismatch: ${patched.length} vs ${content.length}`);
+    }
+    await writeContent(filePath, patched, fileType);
+    const verify = await readContent(filePath, fileType);
+    if (fileType === "binary") {
+      let searchPos = 0;
+      while (true) {
+        const pos = verify.indexOf(bugPattern, searchPos);
+        if (pos === -1)
+          break;
+        const vicinity = verify.slice(Math.max(0, pos - 100), pos + 300);
+        if (vicinity.includes("deleteTokenBefore")) {
+          throw new Error("Verify failed: unpatched bug block still present after binary patch");
+        }
+        searchPos = pos + 1;
+      }
+    } else {
+      if (!verify.includes(PATCH_MARKER)) {
+        throw new Error("Verify failed: patch marker not found after write");
+      }
+    }
+    return { success: true, message: "Patch th\xE0nh c\xF4ng", backupPath };
+  } catch (err) {
+    try {
+      await cp2(backupPath, filePath);
+      const { unlink } = await import("fs/promises");
+      await unlink(backupPath);
+    } catch {}
+    return {
+      success: false,
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function extractBinaryVariables(block) {
+  const m1 = block.match(/let ([\w$]+)=\(([\w$]+)\.match\(\/\\x7f\/g\)\|\|\[\]\)\.length,([\w$]+)=([\w$]+)[;,]/);
+  if (!m1)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c bi\u1EBFn count/state (binary)");
+  const input = m1[2];
+  const state = m1[3];
+  const curState = m1[4];
+  const stateEsc = state.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const m2 = block.match(new RegExp(`([\\w$]+)\\(${stateEsc}\\.text\\);([\\w$]+)\\(${stateEsc}\\.offset\\)`));
+  if (!m2)
+    throw new Error("Kh\xF4ng tr\xEDch xu\u1EA5t \u0111\u01B0\u1EE3c update functions (binary)");
+  return {
+    input,
+    state,
+    curState,
+    updateText: m2[1],
+    updateOffset: m2[2]
+  };
+}
+async function checkKeyboardStatus() {
+  try {
+    const cliJsPath = await findCliJs();
+    const fileType = detectFileType(cliJsPath);
+    const content = await readContent(cliJsPath, fileType);
+    const bugPattern = getBugPattern(fileType);
+    let patched;
+    let hasBug;
+    if (fileType === "binary") {
+      let hasUnpatchedBlock = false;
+      let searchPos = 0;
+      while (true) {
+        const pos = content.indexOf(bugPattern, searchPos);
+        if (pos === -1)
+          break;
+        const vicinity = content.slice(Math.max(0, pos - 100), pos + 300);
+        if (vicinity.includes("deleteTokenBefore")) {
+          hasUnpatchedBlock = true;
+          break;
+        }
+        searchPos = pos + 1;
+      }
+      hasBug = hasUnpatchedBlock;
+      patched = content.includes(bugPattern) && !hasUnpatchedBlock;
+    } else {
+      patched = content.includes(PATCH_MARKER);
+      hasBug = content.includes(bugPattern) && !patched;
+    }
+    return { cliJsFound: true, cliJsPath, isPatched: patched, hasBug, isBinary: fileType === "binary" };
+  } catch {
+    return { cliJsFound: false, cliJsPath: null, isPatched: false, hasBug: false, isBinary: false };
+  }
+}
+
+// src/commands/doctor.ts
 async function doctorCommand() {
   console.log(`
 vibe-cokit doctor
@@ -2687,7 +3002,7 @@ vibe-cokit doctor
     issues++;
   }
   for (const folder of CONFIG_FOLDERS) {
-    const path = join5(CLAUDE_DIR, folder);
+    const path = join6(CLAUDE_DIR, folder);
     if (await dirExists(path)) {
       console.log(`  \u2713 ~/.claude/${folder}/`);
     } else {
@@ -2701,7 +3016,7 @@ vibe-cokit doctor
     console.log(`  \u2717 ~/.claude/skills/ missing \u2014 run \`vk skills\``);
     issues++;
   }
-  const settingsPath = join5(CLAUDE_DIR, "settings.json");
+  const settingsPath = join6(CLAUDE_DIR, "settings.json");
   if (await fileExists(settingsPath)) {
     console.log(`  \u2713 ~/.claude/settings.json`);
   } else {
@@ -2713,7 +3028,20 @@ vibe-cokit doctor
   const skillsVersion = await getSkillsVersion();
   console.log(`  Config version:  ${configVersion ? configVersion.slice(0, 10) : "not installed"}`);
   console.log(`  Skills version:  ${skillsVersion ? skillsVersion.slice(0, 10) : "not installed"}`);
-  const claudeMdExists = await fileExists(join5(process.cwd(), "CLAUDE.md"));
+  const kbStatus = await checkKeyboardStatus();
+  if (kbStatus.cliJsFound) {
+    if (kbStatus.isPatched) {
+      console.log(`  \u2713 Vietnamese IME fix: applied`);
+    } else if (kbStatus.hasBug) {
+      console.log(`  \u2717 Vietnamese IME fix: not applied \u2014 run \`vk doctor --fix\``);
+      issues++;
+    } else {
+      console.log(`  \u2713 Vietnamese IME: no bug detected`);
+    }
+  } else {
+    console.log(`  \u26A0 Claude Code CLI: not found`);
+  }
+  const claudeMdExists = await fileExists(join6(process.cwd(), "CLAUDE.md"));
   console.log(`  Project CLAUDE.md: ${claudeMdExists ? "found" : "not found"}`);
   console.log();
   if (issues === 0) {
@@ -2726,7 +3054,7 @@ vibe-cokit doctor
 }
 
 // src/commands/doctor-fix.ts
-import { join as join6 } from "path";
+import { join as join7 } from "path";
 async function doctorFixCommand() {
   console.log(`
 vibe-cokit doctor fix
@@ -2741,12 +3069,12 @@ vibe-cokit doctor fix
     process.exit(1);
   }
   let fixed = 0;
-  const folderChecks = await Promise.all(CONFIG_FOLDERS.map((f) => dirExists(join6(CLAUDE_DIR, f))));
+  const folderChecks = await Promise.all(CONFIG_FOLDERS.map((f) => dirExists(join7(CLAUDE_DIR, f))));
   const configMissing = !await dirExists(CLAUDE_DIR) || some_default(folderChecks, (exists) => !exists) || !await getCurrentVersion();
-  const claudeMdPath = join6(process.cwd(), "CLAUDE.md");
+  const claudeMdPath = join7(process.cwd(), "CLAUDE.md");
   const claudeMdMissing = !await fileExists(claudeMdPath);
   if (configMissing || claudeMdMissing) {
-    const tmpDir = join6(TEMP_DIR, crypto.randomUUID());
+    const tmpDir = join7(TEMP_DIR, crypto.randomUUID());
     try {
       await cloneRepo(tmpDir);
       if (configMissing) {
@@ -2779,7 +3107,7 @@ vibe-cokit doctor fix
   const skillsMissing = !await dirExists(SKILLS_DIR) || !await getSkillsVersion();
   if (skillsMissing) {
     log("Skills missing \u2014 installing...");
-    const tmpDir = join6(TEMP_DIR, crypto.randomUUID());
+    const tmpDir = join7(TEMP_DIR, crypto.randomUUID());
     try {
       await cloneRepo(tmpDir, SKILLS_REPO);
       await copySkillFolders(tmpDir);
@@ -2795,6 +3123,30 @@ vibe-cokit doctor fix
   } else {
     log("Skills: OK");
   }
+  const kbStatus = await checkKeyboardStatus();
+  if (kbStatus.cliJsFound && kbStatus.hasBug && !kbStatus.isPatched) {
+    log("Vietnamese IME fix missing \u2014 patching...");
+    try {
+      const result = await patchCliJs(kbStatus.cliJsPath);
+      if (result.success) {
+        log(`Vietnamese IME fix applied`);
+        if (result.backupPath) {
+          log(`Backup: ${result.backupPath}`);
+        }
+        fixed++;
+      } else {
+        console.error(`  \u2717 Keyboard fix failed: ${result.message}`);
+      }
+    } catch (err) {
+      console.error(`  \u2717 Keyboard fix failed: ${getErrorMsg(err)}`);
+    }
+  } else if (kbStatus.cliJsFound && kbStatus.isPatched) {
+    log("Vietnamese IME fix: OK");
+  } else if (kbStatus.cliJsFound && !kbStatus.hasBug) {
+    log("Vietnamese IME: no bug detected");
+  } else {
+    log("Claude Code CLI: not found (skip keyboard fix)");
+  }
   console.log();
   if (fixed > 0) {
     console.log(`  \u2713 Fixed ${plural(fixed, "issue")}!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibe-cokit",
-  "version": "1.5.1",
+  "version": "1.6.1",
   "description": "A toolkit for interacting with Claude Code",
   "module": "index.ts",
   "type": "module",