fix-claude-code-vietnamese 1.0.0

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "fix-claude-code-vietnamese",
+  "version": "1.0.0",
+  "description": "Fix Vietnamese IME compatibility issues in Claude Code.",
+  "bin": {
+    "fix-claude-code-vn": "./patch-cli-claude-code.js"
+  },
+  "keywords": [
+    "claude",
+    "vietnamese",
+    "ime",
+    "fix"
+  ],
+  "author": "0x0a0d",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0x0a0d/fix-claude-code-vietnamese"
+  },
+  "devDependencies": {
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "test": "vitest run"
+  }
+}

package/patch-cli-claude-code.js

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Original method stolen from this
+ * https://github.com/manhit96/claude-code-vietnamese-fix
+ * This patch fixes Vietnamese input method editors (IMEs) compatibility issues in Claude.
+ * By modifying `cli.js` code from this:
+ * ```js
+ * if (!S.equals(CA)) {
+ *     if (S.text !== CA.text) Q(CA.text);
+ *     T(CA.offset)
+ * }
+ * ct1(), lt1();
+ * return
+ * ```
+ * To this:
+ * ```js
+ * /* Vietnamese IME fix * /
+ * let _vn = n.replace(/\x7f/g, "");
+ * if (_vn.length > 0) {
+ *   for (const _c of _vn) CA = CA.insert(_c);
+ *   if (!S.equals(CA)) {
+ *     if (S.text !== CA.text) Q(CA.text);
+ *     T(CA.offset)
+ *   }
+ * }
+ * Oe1(), Me1();
+ * return
+ * ```
+ * Note: I have no idea how this works, just ported python logic to JS with make it better performance.
+ */
+
+const DORK = '/* Vietnamese IME fix */';
+
+function usage() {
+    console.log(`
+Usage:
+  fix-claude-code-vn [options]
+
+Options:
+  -f, --file <path>   Path to Claude's cli.js file
+  -h, --help          Show this help message
+
+Description:
+  This script patches Claude Code's cli.js to fix Vietnamese IME issues.
+  If no file is specified, it will try to find it automatically.
+    `);
+}
+
+function findClaudePath() {
+    // 1. Try which/where
+    try {
+        const cmd = os.platform() === 'win32' ? 'where claude' : 'which claude';
+        const binPath = execSync(cmd).toString().split('\n')[0].trim();
+        if (binPath) {
+            // On Unix, it might be a symlink, resolve it
+            let realPath = binPath;
+            if (os.platform() !== 'win32') {
+                try {
+                    realPath = execSync(`realpath "${binPath}"`).toString().trim();
+                } catch (e) { /* ignore */ }
+            }
+
+            if (realPath.endsWith('.js')) return realPath;
+            
+            // If it's a binary/shell script, try to find the node_modules
+            const dir = path.dirname(realPath);
+            const npmPath = path.join(dir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+            if (fs.existsSync(npmPath)) return npmPath;
+        }
+    } catch (e) { /* ignore */ }
+
+    // 2. Try npm root -g
+    try {
+        const npmRoot = execSync('npm root -g').toString().trim();
+        const cliPath = path.join(npmRoot, '@anthropic-ai', 'claude-code', 'cli.js');
+        if (fs.existsSync(cliPath)) return cliPath;
+    } catch (e) { /* ignore */ }
+
+    // 3. Common paths for Windows
+    if (os.platform() === 'win32') {
+        const commonPaths = [
+            path.join(process.env.APPDATA || '', 'npm', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'),
+            path.join(process.env.LOCALAPPDATA || '', 'npm', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js')
+        ];
+        
+        // nvm-windows
+        if (process.env.NVM_HOME) {
+            try {
+                const dirs = fs.readdirSync(process.env.NVM_HOME);
+                for (const d of dirs) {
+                    const p = path.join(process.env.NVM_HOME, d, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+                    if (fs.existsSync(p)) commonPaths.push(p);
+                }
+            } catch (e) { /* ignore */ }
+        }
+
+        for (const p of commonPaths) {
+            if (fs.existsSync(p)) return p;
+        }
+    }
+
+    return null;
+}
+
+function patchContent(fileContent) {
+    if (fileContent.includes(DORK)) {
+        return { success: true, alreadyPatched: true, content: fileContent };
+    }
+
+    // Pattern matching:
+    // match this: l.match(/\x7f/g)...if(!S.equals(CA)){if(S.text!==CA.text)Q(CA.text);T(CA.offset)}ct1(),lt1();return
+    // We use a regex that captures variable and function names dynamically.
+    const re = /((?<var0>[\w$]+)\.match\(\/\\x7f\/g\).*?)if\(!(?<var1>[\w$]+)\.equals\((?<var2>[\w$]+)\)\){if\(\k<var1>\.text!==\k<var2>\.text\)(?<func1>[\w$]+)\(\k<var2>\.text\);(?<func2>[\w$]+)\(\k<var2>\.offset\)}(?<remain>(?:[\w$]+\(\),?\s*)*;?\s*return)/;
+    
+    const newContent = fileContent.replace(re, (match, m0, var0, var1, var2, func1, func2, remain) => {
+        return `
+${DORK}
+${m0}
+let _vn = ${var0}.replace(/\\x7f/g, "");
+if (_vn.length > 0) {
+    for (const _c of _vn) ${var2} = ${var2}.insert(_c);
+    if (!${var1}.equals(${var2})) {
+        if (${var1}.text !== ${var2}.text) ${func1}(${var2}.text);
+        ${func2}(${var2}.offset);
+    }
+}
+${remain}
+`;
+    });
+
+    if (newContent === fileContent) {
+        return { success: false, content: fileContent };
+    }
+
+    return { success: true, alreadyPatched: false, content: newContent };
+}
+
+// Main execution
+if (require.main === module) {
+    let targetPath = null;
+    const args = process.argv.slice(2);
+
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '-f' || args[i] === '--file') {
+            targetPath = args[++i];
+        } else if (args[i] === '-h' || args[i] === '--help') {
+            usage();
+            process.exit(0);
+        }
+    }
+
+    if (!targetPath) {
+        targetPath = findClaudePath();
+    }
+
+    if (!targetPath || !fs.existsSync(targetPath)) {
+        console.error('Error: Could not find Claude Code cli.js.');
+        if (targetPath) console.error(`Path tried: ${targetPath}`);
+        usage();
+        process.exit(1);
+    }
+
+    console.log(`Target: ${targetPath}`);
+
+    if (!targetPath.endsWith('.js')) {
+        console.error('Error: Target file must be a .js file.');
+        process.exit(1);
+    }
+
+    const content = fs.readFileSync(targetPath, 'utf-8');
+    const result = patchContent(content);
+
+    if (result.alreadyPatched) {
+        console.log('Claude is already patched for Vietnamese IME.');
+        process.exit(0);
+    }
+
+    if (!result.success) {
+        console.error('Error: Failed to patch Claude. The code structure might have changed.');
+        process.exit(1);
+    }
+
+    fs.writeFileSync(targetPath, result.content, 'utf-8');
+    console.log('Success: Claude has been patched for Vietnamese IME.');
+}
+
+// Export for testing
+module.exports = { patchContent };

package/patch-cli-claude-code.test.js

@@ -0,0 +1,91 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { patchContent } from './patch-cli-claude-code.js';
+
+import { execSync } from 'child_process';
+
+const MIN_VERSION_TEST = '2.0.64';
+
+function getVersions(minVersion) {
+    const versionPaths = minVersion.split('.').map(Number);
+    if (versionPaths.length === 2) {
+        versionPaths.push(0);
+    } else if (versionPaths.length === 1) {
+        versionPaths.push(0, 0);
+    } else if (versionPaths.length > 3) {
+        throw new Error('Invalid version format');
+    }
+
+    try {
+        const output = execSync('npm view @anthropic-ai/claude-code versions --json').toString();
+        const allVersions = JSON.parse(output);
+        return allVersions.filter(v => {
+            // filter version >= 2.0.64
+            const parts = v.split('.').map(Number);
+            if (parts[0] > versionPaths[0]) return true;
+            if (parts[0] === versionPaths[0]) {
+                if (parts[1] > versionPaths[1]) return true;
+                if (parts[1] === versionPaths[1]) return parts[2] >= versionPaths[2];
+            }
+            return false;
+        });
+    } catch (e) {
+        console.error('Failed to fetch versions from npm, using fallback.');
+        return ['2.0.64', '2.1.12'];
+    }
+}
+
+const VERSIONS = getVersions(MIN_VERSION_TEST);
+
+const CACHE_DIR = path.join(process.cwd(), '.test-cache');
+
+async function downloadFile(url, dest) {
+    if (fs.existsSync(dest)) return;
+
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new Error(`Failed to download: ${response.statusCode}`));
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', (err) => {
+            fs.unlink(dest, () => reject(err));
+        });
+    });
+}
+
+describe('Claude Code Vietnamese Patch Test', () => {
+    beforeAll(async () => {
+        // download versions if not exists
+        for (const v of VERSIONS) {
+            const url = `https://unpkg.com/@anthropic-ai/claude-code@${v}/cli.js`;
+            const dest = path.join(CACHE_DIR, `cli-${v}.js`);
+            console.log(`Checking version ${v}...`);
+            await downloadFile(url, dest);
+        }
+    }, 60000); // 1 minute timeout for downloads
+
+    it.each(VERSIONS)('should successfully patch version %s', (v) => {
+        const filePath = path.join(CACHE_DIR, `cli-${v}.js`);
+        const content = fs.readFileSync(filePath, 'utf-8');
+
+        const result = patchContent(content);
+
+        expect(result.success, `Patch failed for version ${v}`).toBe(true);
+        expect(result.content).toContain('/* Vietnamese IME fix */');
+
+        // Verify code structure after patch
+        expect(result.content).toMatch(/let _vn = \w+\.replace\(\/\\x7f\/g, ""\);/);
+        expect(result.content).toContain('.insert(_c)');
+    });
+});