vietnam-cli 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,98 @@
+# vietnam-cli
+
+Fix Vietnamese input method (Unikey, EVKey, etc.) for CLI tools like **Auggie CLI** and **Claude Code**.
+
+## Problem
+
+Vietnamese IME (Input Method Editor) like Unikey or EVKey uses a technique where it sends a DEL character (`\x7F`) to delete the previous character, then inserts the new accented character.
+
+Some CLI tools incorrectly interpret `\x7F` as the "Delete" key (forward delete) instead of "Backspace" (backward delete), causing Vietnamese input to malfunction.
+
+## Installation
+
+```bash
+npm install -g vietnam-cli
+```
+
+## Usage
+
+### Apply patch to all supported tools
+```bash
+vietnam-cli patch
+```
+
+### Check patch status
+```bash
+vietnam-cli check
+```
+
+### Patch specific tool
+```bash
+vietnam-cli patch auggie    # Patch only Auggie CLI
+vietnam-cli patch claude    # Patch only Claude Code
+```
+
+### Restore original files
+```bash
+vietnam-cli restore
+```
+
+### Show help
+```bash
+vietnam-cli help
+```
+
+## Supported Tools
+
+| Tool | Package | Status |
+|------|---------|--------|
+| Auggie CLI | `@augmentcode/auggie` | ✅ Supported |
+| Claude Code | `@anthropic-ai/claude-code` | ✅ Supported |
+
+## How It Works
+
+The patch modifies the key parsing code in the CLI tools:
+
+**Before (broken):**
+```javascript
+else if(e==="\x7F"||e==="\x1B\x7F")n.name="delete"
+```
+
+**After (fixed):**
+```javascript
+else if(e==="\x7F"||e==="\x1B\x7F")n.name="backspace"
+```
+
+This change makes the `\x7F` character behave as backspace, which is what Vietnamese IME expects.
+
+## Important Notes
+
+⚠️ **After updating the CLI tools** (e.g., `npm update -g @augmentcode/auggie`), you need to **re-apply the patch**:
+
+```bash
+vietnam-cli patch
+```
+
+## Programmatic Usage
+
+```javascript
+const { patch, check, restore } = require('vietnam-cli');
+
+// Apply patch
+await patch('auggie');
+
+// Check status
+await check('all');
+
+// Restore original
+await restore('auggie');
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Issues and PRs are welcome at [GitHub](https://github.com/user/vietnam-cli).
+

package/bin/cli.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+
+/**
+ * Vietnamese IME Patch CLI
+ * Fix Vietnamese input (Unikey/EVKey) for CLI tools
+ */
+
+const { patch, check, restore, findTargets } = require('../src/index.js');
+
+const args = process.argv.slice(2);
+const command = args[0] || 'help';
+const target = args[1] || 'all';
+
+const HELP_TEXT = `
+Vietnamese IME Patch - Fix Vietnamese input for CLI tools
+==========================================================
+
+Usage: vietnam-cli <command> [target]
+
+Commands:
+  patch [target]    Apply Vietnamese IME fix (default: all)
+  check [target]    Check if patch is applied
+  restore [target]  Restore original files from backup
+  list              List all supported targets and their status
+  help              Show this help message
+
+Targets:
+  all               All supported CLI tools (default)
+  auggie            Auggie CLI (@augmentcode/auggie)
+  claude            Claude Code CLI (@anthropic-ai/claude-code)
+
+Examples:
+  vietnam-cli patch              # Patch all supported tools
+  vietnam-cli patch auggie       # Patch only auggie-cli
+  vietnam-cli check              # Check patch status
+  vietnam-cli restore auggie     # Restore auggie to original
+
+What this fixes:
+  Vietnamese IME (Unikey, EVKey, etc.) sends DEL character (\\x7F) to delete
+  the previous character before inserting accented characters. Some CLI tools
+  incorrectly treat \\x7F as "delete" (forward delete) instead of "backspace".
+  This patch fixes that behavior.
+
+`;
+
+async function main() {
+    switch (command) {
+        case 'patch':
+            console.log('🔧 Applying Vietnamese IME patch...\n');
+            await patch(target);
+            break;
+            
+        case 'check':
+            console.log('🔍 Checking Vietnamese IME patch status...\n');
+            await check(target);
+            break;
+            
+        case 'restore':
+            console.log('↩️  Restoring original files...\n');
+            await restore(target);
+            break;
+            
+        case 'list':
+            console.log('📋 Supported targets:\n');
+            await findTargets();
+            break;
+            
+        case 'help':
+        case '--help':
+        case '-h':
+            console.log(HELP_TEXT);
+            break;
+            
+        default:
+            console.error(`Unknown command: ${command}`);
+            console.log(HELP_TEXT);
+            process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+});
+

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "vietnam-cli",
+  "version": "1.0.0",
+  "description": "Fix Vietnamese IME input (Unikey/EVKey) for CLI tools like auggie-cli and claude-code",
+  "main": "src/index.js",
+  "bin": {
+    "vietnam-cli": "bin/cli.js"
+  },
+  "scripts": {
+    "test": "node bin/cli.js check",
+    "patch": "node bin/cli.js patch",
+    "check": "node bin/cli.js check",
+    "restore": "node bin/cli.js restore",
+    "prepublishOnly": "node scripts/prepare-publish.js",
+    "postpublish": "node scripts/restore-readme.js"
+  },
+  "keywords": [
+    "vietnamese",
+    "ime",
+    "unikey",
+    "evkey",
+    "telex",
+    "vni",
+    "auggie",
+    "claude-code",
+    "input-method",
+    "keyboard",
+    "patch",
+    "fix",
+    "tieng-viet"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/user/vietnam-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/user/vietnam-cli/issues"
+  },
+  "homepage": "https://github.com/user/vietnam-cli#readme",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}
+

package/src/index.js

@@ -0,0 +1,218 @@
+/**
+ * Vietnamese IME Patch
+ * Fix Vietnamese input (Unikey/EVKey) for CLI tools
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Patch configurations for different CLI tools
+const PATCH_CONFIGS = {
+    auggie: {
+        name: 'Auggie CLI',
+        package: '@augmentcode/auggie',
+        file: 'augment.mjs',
+        patterns: [
+            {
+                original: 'else if(e==="\\x7F"||e==="\\x1B\\x7F")n.name="delete"',
+                patched: 'else if(e==="\\x7F"||e==="\\x1B\\x7F")n.name="backspace"',
+                description: 'Map \\x7F to backspace instead of delete'
+            }
+        ]
+    },
+    claude: {
+        name: 'Claude Code CLI',
+        package: '@anthropic-ai/claude-code',
+        file: 'cli.mjs',
+        patterns: [
+            {
+                original: 'else if(e==="\\x7F"||e==="\\x1B\\x7F")n.name="delete"',
+                patched: 'else if(e==="\\x7F"||e==="\\x1B\\x7F")n.name="backspace"',
+                description: 'Map \\x7F to backspace instead of delete'
+            }
+        ]
+    }
+};
+
+/**
+ * Get npm global root path
+ */
+function getNpmGlobalRoot() {
+    try {
+        return execSync('npm root -g', { encoding: 'utf8' }).trim();
+    } catch (e) {
+        return null;
+    }
+}
+
+/**
+ * Find installation path for a package
+ */
+function findPackagePath(packageName, fileName) {
+    const possibleRoots = [
+        getNpmGlobalRoot(),
+        path.join(process.env.APPDATA || '', 'npm', 'node_modules'),
+        path.join(process.env.NVM_HOME || '', 'nodejs', 'node_modules'),
+        'C:\\nvm4w\\nodejs\\node_modules',
+        '/usr/local/lib/node_modules',
+        '/usr/lib/node_modules',
+        path.join(process.env.HOME || '', '.nvm', 'versions', 'node', process.version, 'lib', 'node_modules'),
+    ].filter(Boolean);
+
+    for (const root of possibleRoots) {
+        const filePath = path.join(root, packageName, fileName);
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+
+/**
+ * Check patch status for a target
+ */
+function checkPatchStatus(targetKey) {
+    const config = PATCH_CONFIGS[targetKey];
+    if (!config) {
+        return { found: false, error: `Unknown target: ${targetKey}` };
+    }
+
+    const filePath = findPackagePath(config.package, config.file);
+    if (!filePath) {
+        return { found: false, installed: false, name: config.name };
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    
+    for (const pattern of config.patterns) {
+        if (content.includes(pattern.patched)) {
+            return { found: true, installed: true, patched: true, path: filePath, name: config.name };
+        }
+        if (content.includes(pattern.original)) {
+            return { found: true, installed: true, patched: false, path: filePath, name: config.name };
+        }
+    }
+
+    return { found: true, installed: true, patched: 'unknown', path: filePath, name: config.name };
+}
+
+/**
+ * Apply patch to a target
+ */
+function applyPatch(targetKey) {
+    const config = PATCH_CONFIGS[targetKey];
+    const status = checkPatchStatus(targetKey);
+
+    if (!status.installed) {
+        console.log(`⚠️  ${config.name}: Not installed`);
+        return false;
+    }
+
+    if (status.patched === true) {
+        console.log(`✅ ${config.name}: Already patched`);
+        return true;
+    }
+
+    let content = fs.readFileSync(status.path, 'utf8');
+    
+    // Create backup
+    const backupPath = status.path + '.backup';
+    if (!fs.existsSync(backupPath)) {
+        fs.writeFileSync(backupPath, content);
+        console.log(`📦 Created backup: ${backupPath}`);
+    }
+
+    // Apply patches
+    let patchedCount = 0;
+    for (const pattern of config.patterns) {
+        if (content.includes(pattern.original)) {
+            content = content.replace(pattern.original, pattern.patched);
+            patchedCount++;
+        }
+    }
+
+    if (patchedCount > 0) {
+        fs.writeFileSync(status.path, content);
+        console.log(`✅ ${config.name}: Patched successfully (${patchedCount} changes)`);
+        return true;
+    } else {
+        console.log(`⚠️  ${config.name}: Could not find patterns to patch`);
+        return false;
+    }
+}
+
+/**
+ * Restore original file from backup
+ */
+function restoreBackup(targetKey) {
+    const config = PATCH_CONFIGS[targetKey];
+    const status = checkPatchStatus(targetKey);
+
+    if (!status.installed) {
+        console.log(`⚠️  ${config.name}: Not installed`);
+        return false;
+    }
+
+    const backupPath = status.path + '.backup';
+    if (fs.existsSync(backupPath)) {
+        fs.copyFileSync(backupPath, status.path);
+        console.log(`✅ ${config.name}: Restored from backup`);
+        return true;
+    } else {
+        console.log(`⚠️  ${config.name}: No backup found`);
+        return false;
+    }
+}
+
+// Export functions
+module.exports = {
+    async patch(target = 'all') {
+        const targets = target === 'all' ? Object.keys(PATCH_CONFIGS) : [target];
+        for (const t of targets) {
+            applyPatch(t);
+        }
+    },
+
+    async check(target = 'all') {
+        const targets = target === 'all' ? Object.keys(PATCH_CONFIGS) : [target];
+        for (const t of targets) {
+            const status = checkPatchStatus(t);
+            if (!status.installed) {
+                console.log(`⬚ ${status.name}: Not installed`);
+            } else if (status.patched === true) {
+                console.log(`✅ ${status.name}: Patched`);
+            } else if (status.patched === false) {
+                console.log(`❌ ${status.name}: Not patched`);
+            } else {
+                console.log(`⚠️  ${status.name}: Unknown status`);
+            }
+        }
+    },
+
+    async restore(target = 'all') {
+        const targets = target === 'all' ? Object.keys(PATCH_CONFIGS) : [target];
+        for (const t of targets) {
+            restoreBackup(t);
+        }
+    },
+
+    async findTargets() {
+        for (const [key, config] of Object.entries(PATCH_CONFIGS)) {
+            const status = checkPatchStatus(key);
+            const statusIcon = !status.installed ? '⬚' : status.patched ? '✅' : '❌';
+            const statusText = !status.installed ? 'not installed' : status.patched ? 'patched' : 'not patched';
+            console.log(`  ${statusIcon} ${key.padEnd(10)} ${config.name} (${statusText})`);
+            if (status.path) {
+                console.log(`              Path: ${status.path}`);
+            }
+        }
+    },
+
+    PATCH_CONFIGS,
+    checkPatchStatus,
+    applyPatch,
+    restoreBackup,
+    findPackagePath
+};
+