dw-kit 1.0.0 → 1.0.2

package/README.md

@@ -1,183 +1,139 @@
-# dw-kit
+# dw-kit
 
-> Bộ workflow toolkit cho dev team sử dụng Claude Code Agent — từ requirements đến dashboard.
+> An AI development workflow toolkit for teams using agentic IDEs (Claude Code, Cursor) — from idea to review-ready commits.
 
-**v1.0** · `npm install -g dw-kit` · [Docs](docs/README.md) · [Cheatsheet](docs/cheatsheet.md) · [Migration v0.3→v1](scripts/migrate-v03-to-v1.sh)
+**v1.0** · `npm install -g dw-kit` · [Docs](docs/README.md) · [Get started](docs/get-started.md) · [Cheatsheet](docs/cheatsheet.md)
 
 ---
 
-## Toolkit Này Làm Gì?
+## What is dw-kit?
 
-Thay vì để Claude tự do code, dw-kit tạo ra **rails có cấu trúc**:
+dw-kit helps your team run AI-assisted development with a **repeatable workflow** and clear checkpoints:
 
 ```
-Research  →  Plan  →  Execute (TDD)  →  Review  →  Commit
+Initialize → Understand → Plan → Execute (TDD) → Verify → Close
 ```
 
-Với đầy đủ hỗ trợ cho các roles trong team: BA · TL · Dev · QC · PM.
+```mermaid
+%%{init: {'flowchart': {'nodeSpacing': 10, 'rankSpacing': 18}}}%%
+flowchart LR
+  classDef extra fill:#f3f4f6,stroke:#9ca3af,stroke-width:1px,color:#111;
 
----
+  D["Init + Understand"] --> P["Plan (approve)"]
+  P -->|approved| E["Execute (TDD)"]
+  P -->|revise| P
 
-## Quick Start
+  E --> V["Verify (gates)"]
+  V -->|sign-off| C["Close (handoff + archive)"]
+  V -->|"revise (fix)"| E
 
-### Option A — npm (recommended)
+  subgraph Extra["Depth=thorough"]
+    R[Req] --> Est[Est] --> AR[Arch] --> P
+    P -.-> TP[Test] -.-> E
+    E -.-> DU[Docs] --> LW[Log] -.-> C
+  end
 
-```bash
-npm install -g dw-kit
+  class R,Est,AR,TP,DU,LW extra
 ```
 
-Then in your project directory:
+## Workflow overview
 
-```bash
-dw init
-```
+`dw` runs a 6-phase process (all phases for `standard` and `thorough`):
 
-Interactive wizard asks 3 questions (project, depth, language) and auto-selects roles by depth. Or use presets:
+Initialize → Understand → Plan (stops for approval) → Execute (TDD; 1 commit per subtask) → Verify (quality gates + review sign-off) → Close (handoff + archive when done).
 
-```bash
-dw init --preset small-team     # skip wizard
-dw init --preset solo-quick     # solo dev, minimal ceremony
-dw init --preset enterprise     # full team, all features
-```
-
-Zero-install (one-time use):
-
-```bash
-npx dw-kit init
-```
+### 6 phases (full workflow)
+- **Initialize**: clarify task scope and set up the workspace + task docs.
+- **Understand**: survey the codebase, dependencies, patterns, and test coverage (no implementation).
+- **Plan**: design the solution and subtasks; **pause for your approval**.
+- **Execute**: implement using **TDD**; each subtask produces a commit.
+- **Verify**: run quality gates + review sign-off to ensure correctness and safety.
+- **Close**: handoff notes, finalize progress, and archive when done.
 
-### Option B — Git submodule (legacy)
+It’s designed for collaboration (Dev / Tech Lead / QA / PM) and keeps work auditable via lightweight task docs.
 
-```bash
-git submodule add https://github.com/dv-workflow/dv-workflow.git .dw-module
-bash .dw-module/setup.sh
-```
-
-`setup.sh` là luồng legacy/fallback. Luồng khuyến nghị cho v1 là `npm install -g dw-kit` + `dw init`.
-
-### Start working
-
-Open Claude Code in your project directory:
-
-```
-/dw-task-init tên-feature
-```
+---
 
-### CLI Commands
+## Install
 
 ```bash
-dw init              # Setup wizard
-dw upgrade           # Update toolkit files (override-aware)
-dw upgrade --dry-run # Preview changes
-dw upgrade --check   # Check for updates only
-dw validate          # Validate config against schema
-dw doctor            # Check installation health
-dw migrate           # Migrate from v0.3 to v1
+npm install -g dw-kit
 ```
 
 ---
 
-## Depth System (thay thế Level 1/2/3)
+## Quick start
 
-| Depth | Dành cho | Workflow |
-|-------|----------|----------|
-| `quick` | Solo dev, hotfix, familiar code | Understand → Execute → Close |
-| `standard` | Team nhỏ, feature mới | Tất cả 6 phases |
-| `thorough` | Enterprise, API/DB/security changes | Full workflow + arch-review + test-plan |
+Setup dw in project directory:
 
-Cấu hình trong `.dw/config/dw.config.yml`:
-```yaml
-workflow:
-  default_depth: "standard"
+```bash
+dw init
 ```
 
-`default_depth` là baseline. Với task cụ thể, bạn có thể override sang `thorough` khi scope/risk tăng (API/DB/security), kể cả project nhỏ.
-
----
-
-## Kiến Trúc v1 (4 Layers)
+Then in **Claude Code CLI**, run the full workflow:
 
 ```
-Layer 0: core/            ← Portable methodology (platform-agnostic)
-Layer 1: .claude/         ← Claude Code execution (agents, hooks, skills)
-Layer 2: config/claude:   ← Model-specific features (extended thinking, MCP)
-Layer 3: adapters/overrides/ ← Team customizations (never overwritten by upgrade)
+/dw-flow your-task-or-anythings
 ```
 
 ---
 
-## Cấu Trúc Sau Khi Setup
+Discover other skills:
 
 ```
-dự-án-của-bạn/
-├── .dw-module/                 ← toolkit (git submodule, read-only)
-├── core/                         ← portable methodology
-│   ├── WORKFLOW.md               ← 6-phase workflow
-│   ├── THINKING.md               ← thinking framework
-│   ├── QUALITY.md                ← 4-layer quality strategy
-│   └── ROLES.md                  ← team role definitions
-├── config/
-│   ├── dw.config.yml             ← config (~45 lines)
-│   ├── config.schema.json        ← validation schema
-│   └── presets/                  ← solo-quick, small-team, enterprise
-├── adapters/
-│   ├── claude-cli/overrides/     ← team customizations (upgrade-safe)
-│   ├── claude-cli/extensions/    ← net-new team skills
-│   └── generic/AGENT.md          ← for Cursor/Windsurf/Copilot
-├── .claude/                      ← skills, agents, rules, hooks
-├── .dw/                          ← tasks, docs, metrics, reports
-└── scripts/
-    ├── upgrade.sh                ← upgrade toolkit (--dry-run)
-    └── migrate-v03-to-v1.sh      ← migration từ v0.3
-```
-
----
-
-## Skills Có Sẵn
+/dw-prompt
+/dw-thinking
+...
 
-Xem [docs/cheatsheet.md](docs/cheatsheet.md) để có bảng tham chiếu nhanh.
+```
 
 ---
 
-## Migrating từ v0.3
+## CLI commands
 
 ```bash
-dw migrate --dry-run   # preview changes
-dw migrate             # apply migration
+dw init                 # setup wizard / presets
+dw validate             # validate .dw/config/dw.config.yml
+dw doctor               # installation health check
+dw upgrade              # update toolkit files (override-aware)
+dw upgrade --check      # check for updates only
+dw upgrade --dry-run    # preview changes
+dw prompt               # build a well-structured task prompt (autocomplete + wizard)
+dw prompt --text "..."  # non-interactive: structure a description directly
+dw claude-vn-fix        # patch Claude CLI to fix Vietnamese IME (backup/restore)
 ```
 
-Or via bash (legacy):
+`dw claude-vn-fix` patches the local Claude CLI bundle to fix Vietnamese IME input (DEL char `\x7f` issue). Includes auto-backup and rollback.
 
-```bash
-bash scripts/migrate-v03-to-v1.sh --dry-run
-bash scripts/migrate-v03-to-v1.sh
-```
+---
 
-`scripts/upgrade.sh` và `scripts/migrate-v03-to-v1.sh` được giữ cho backward-compat; ưu tiên dùng `dw upgrade` và `dw migrate`.
+## Depth system
 
-Migration sẽ:
-- Map `level: 2` → `default_depth: standard`
-- Preserve customized skills vào `.dw/adapters/claude-cli/overrides/`
-- Backup old config, create new `.dw/config/dw.config.yml`
+Pick a default depth for your project, then override per task when risk increases.
 
----
+| Depth | Best for | Workflow |
+|-------|----------|----------|
+| `quick` | Solo dev, hotfix, familiar code | Understand → Execute → Close |
+| `standard` | Small teams, new features | Full 6 phases |
+| `thorough` | Risky changes (API/DB/security) | Full workflow + arch-review + test-plan |
 
-## Demo
+Configured in `.dw/config/dw.config.yml`:
 
-- [Demo A](examples/demo-A-bug-fix/) — Bug fix workflow (quick depth)
-- [Demo B](examples/demo-B-new-feature/) — Full team feature workflow (BA → PM)
+```yaml
+workflow:
+  default_depth: "standard"
+```
 
 ---
 
-## Tài Liệu
+## What gets added to your repo?
 
-| Tài liệu | Nội dung |
-|----------|---------|
-| [docs/README.md](docs/README.md) | Hướng dẫn đầy đủ, setup, tips |
-| [docs/cheatsheet.md](docs/cheatsheet.md) | Bảng tham chiếu nhanh tất cả skills |
-| [docs/custom-skills.md](docs/custom-skills.md) | Hướng dẫn tạo custom skills |
-| [CHANGELOG.md](CHANGELOG.md) | Lịch sử thay đổi |
+```
+.dw/        # methodology, config, adapters, task docs
+.claude/    # Claude Code: skills, hooks, agents, rules
+CLAUDE.md   # project context for the agent
+```
 
 ---
 
-> Maintainer: [huygdv](mailto:huygdv19@gmail.com)
+Maintainer: [huygdv](mailto:huygdv19@gmail.com)

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "dw-kit",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "AI development workflow toolkit — structured, quality-assured, team-ready. From requirements to dashboard.",
   "type": "module",
   "bin": {
-    "dw": "./bin/dw.mjs"
+    "dw": "bin/dw.mjs"
   },
   "files": [
     "bin/",
@@ -14,8 +14,7 @@
     ".dw/adapters/",
     "scripts/",
     ".claude/",
-    "CLAUDE.md",
-    "setup.sh"
+    "CLAUDE.md"
   ],
   "engines": {
     "node": ">=18"
@@ -40,13 +39,14 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dv-workflow/dv-workflow.git"
+    "url": "git+https://github.com/dv-workflow/dv-workflow.git"
   },
   "homepage": "https://github.com/dv-workflow/dv-workflow#readme",
   "dependencies": {
     "ajv": "^8.18.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1"
   }
 }

package/scripts/e2e-local-check.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/bin/bash
 # scripts/e2e-local-check.sh
 # End-to-end local publish check (pack -> install -> run CLI)
 
@@ -60,7 +60,6 @@ npx dw init --preset small-team
 npx dw validate
 npx dw doctor
 npx dw upgrade --check
-npx dw migrate --dry-run
 
 info "Step 6: Verify task-depth override guidance artifacts"
 grep -q "Task-Level Depth Override" ".dw/core/WORKFLOW.md"

package/src/__fixtures__/claude-cli-bug-snippet.js

@@ -0,0 +1,15 @@
+// Minimal fixture that contains the known Vietnamese IME bug pattern.
+// This is NOT the real Claude CLI; only used for testing the patcher logic.
+//
+// IMPORTANT: The comment below must contain both '@anthropic-ai' and 'claude-code'
+// to pass the bundle signature guard in patchCliJs(). Do not remove it.
+// @anthropic-ai/claude-code bundle stub
+
+function demo(INPUT) {
+  if(INPUT.includes("\x7f")){
+    let COUNT=(INPUT.match(/\x7f/g)||[]).length,STATE=CURSTATE;
+    UPDATETEXT(STATE.text);UPDATEOFFSET(STATE.offset)
+    return;
+  }
+}
+

package/src/cli.mjs

@@ -2,6 +2,8 @@ import { Command } from 'commander';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
+import chalk from 'chalk';
+import { getUpdateNotice, scheduleUpdateCheck } from './lib/update-checker.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -9,6 +11,10 @@ const require = createRequire(import.meta.url);
 const pkg = require(join(__dirname, '..', 'package.json'));
 
 export function run(argv) {
+  // Show cached update notice (non-blocking), then schedule fresh check in background
+  const latestVersion = getUpdateNotice(pkg.version);
+  scheduleUpdateCheck(pkg.version);
+
   const program = new Command();
 
   program
@@ -56,13 +62,31 @@ export function run(argv) {
     });
 
   program
-    .command('migrate')
-    .description('Migrate project from dw-kit v0.3 to v1')
-    .option('-n, --dry-run', 'Preview migration without applying')
+    .command('prompt')
+    .description('Build a well-structured task prompt with autocomplete + guided wizard')
+    .option('-t, --text <text>', 'Non-interactive: provide description directly')
+    .action(async (opts) => {
+      const { promptCommand } = await import('./commands/prompt.mjs');
+      await promptCommand(opts);
+    });
+
+  program
+    .command('claude-vn-fix')
+    .description('Patch Claude CLI to fix Vietnamese IME (local, with backup/restore)')
+    .option('--path <file>', 'Path to @anthropic-ai/claude-code/cli.js (optional; auto-detect if omitted)')
+    .option('--restore', 'Restore from latest backup')
+    .option('--dry-run', 'Show what would change without writing')
     .action(async (opts) => {
-      const { migrateCommand } = await import('./commands/migrate.mjs');
-      await migrateCommand(opts);
+      const { claudeVnFixCommand } = await import('./commands/claude-vn-fix.mjs');
+      await claudeVnFixCommand(opts);
     });
 
   program.parse(argv);
+
+  if (latestVersion) {
+    console.log();
+    console.log(chalk.yellow(`  ↑ Update available`) + `  v${pkg.version} → ` + chalk.green.bold(`v${latestVersion}`));
+    console.log(`    Run ` + chalk.cyan(`npm install -g dw-kit`) + ` to update`);
+    console.log();
+  }
 }

package/src/commands/claude-vn-fix.mjs

@@ -0,0 +1,267 @@
+import { existsSync, readFileSync, writeFileSync, copyFileSync, readdirSync, statSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import os from 'node:os';
+import { execSync } from 'node:child_process';
+import { header, info, ok, warn, err, log } from '../lib/ui.mjs';
+
+export const PATCH_MARKER = '/* dw-kit Vietnamese IME fix */';
+export const DEL_CHAR = '\x7f';
+
+export async function claudeVnFixCommand(opts) {
+  header('dw-kit Claude Vietnamese IME Fix');
+
+  const filePath = opts.path ? opts.path : findCliJs();
+  log(`Target file: ${filePath}`);
+
+  if (!existsSync(filePath)) {
+    err(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  if (opts.restore) {
+    info('Restoring from latest backup');
+    const restored = restoreLatestBackup(filePath, { dryRun: !!opts.dryRun });
+    if (!restored) process.exit(1);
+    ok('Restore complete. Restart Claude CLI.');
+    return;
+  }
+
+  info('Patching');
+  const result = patchCliJs(filePath, { dryRun: !!opts.dryRun });
+  if (!result.ok) {
+    err(result.message);
+    process.exit(1);
+  }
+  ok(result.message);
+  log('Restart Claude CLI for changes to take effect.');
+  warn('Note: This modifies a third-party installed file; you may need to re-run after Claude updates.');
+}
+
+export function findCliJs() {
+  // Strategy: check global npm root first, then common cache locations.
+  // This is intentionally conservative (no deep recursive scan of entire home).
+  const candidates = [];
+
+  // npm root -g
+  const npmRoot = tryNpmRootGlobal();
+  if (npmRoot) {
+    candidates.push(join(npmRoot, '@anthropic-ai', 'claude-code', 'cli.js'));
+  }
+
+  const home = os.homedir();
+  if (process.platform === 'win32') {
+    const appData = process.env.APPDATA || '';
+    const localAppData = process.env.LOCALAPPDATA || '';
+    if (appData) candidates.push(join(appData, 'npm', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js'));
+    if (localAppData) {
+      const npxBase = join(localAppData, 'npm-cache', '_npx');
+      const latest = findLatestNpxClaudeCli(npxBase);
+      if (latest) candidates.push(latest);
+    }
+  } else {
+    const npxLatest = findLatestNpxClaudeCli(join(home, '.npm', '_npx'));
+    if (npxLatest) candidates.push(npxLatest);
+    candidates.push('/usr/local/lib/node_modules/@anthropic-ai/claude-code/cli.js');
+    candidates.push('/opt/homebrew/lib/node_modules/@anthropic-ai/claude-code/cli.js');
+  }
+
+  for (const p of candidates) {
+    if (p && existsSync(p) && statSync(p).isFile()) return p;
+  }
+
+  throw new Error(
+    'Could not auto-detect @anthropic-ai/claude-code/cli.js.\n' +
+    'Provide it explicitly via: dw claude-vn-fix --path "<path-to-cli.js>"',
+  );
+}
+
+function tryNpmRootGlobal() {
+  try {
+    const out = execSync('npm root -g', { stdio: ['ignore', 'pipe', 'ignore'], encoding: 'utf-8', timeout: 5000 });
+    return out.trim();
+  } catch {
+    return null;
+  }
+}
+
+function safeMtime(p) {
+  try { return statSync(p).mtimeMs || 0; } catch { return 0; }
+}
+
+function findLatestNpxClaudeCli(npxBase) {
+  try {
+    if (!npxBase || !existsSync(npxBase)) return null;
+    const entries = readdirSync(npxBase, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => join(npxBase, e.name));
+    const sorted = entries
+      .map((d) => ({ d, t: safeMtime(d) }))
+      .sort((a, b) => b.t - a.t)
+      .map((x) => x.d);
+
+    for (const dir of sorted.slice(0, 50)) {
+      const p = join(dir, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+      if (existsSync(p)) return p;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function patchCliJs(filePath, { dryRun }) {
+  const content = readFileSync(filePath, 'utf-8');
+
+  // Guard: ensure this is actually a Claude CLI bundle before patching.
+  if (!content.includes('@anthropic-ai') || !content.includes('claude-code')) {
+    return { ok: false, message: 'File does not appear to be a Claude CLI bundle. Use --path to specify the correct file.' };
+  }
+
+  if (content.includes(PATCH_MARKER)) {
+    return { ok: true, message: 'Already patched (marker found).' };
+  }
+
+  const idx = findBugPatternIndex(content);
+  if (idx === -1) {
+    return { ok: false, message: 'Bug pattern not found (.includes("\\x7f")). Claude may already be fixed upstream.' };
+  }
+
+  const { start, end, block } = findIfBlock(content, idx);
+  const vars = extractVariables(block);
+  const fixCode = generateFix(vars);
+  const patched = content.slice(0, start) + fixCode + content.slice(end);
+
+  if (dryRun) {
+    log('DRY RUN: would create backup and patch file.');
+    log(`Detected vars: input=${vars.input}, state=${vars.state}, cur=${vars.curState}`);
+    return { ok: true, message: 'Dry run OK.' };
+  }
+
+  const backupPath = createBackup(filePath);
+  ok(`Backup created: ${backupPath}`);
+  try {
+    writeFileSync(filePath, patched, 'utf-8');
+    const verify = readFileSync(filePath, 'utf-8');
+    if (!verify.includes(PATCH_MARKER)) throw new Error('verify failed (marker missing after write)');
+    return { ok: true, message: `Patch applied. Backup: ${backupPath}` };
+  } catch (e) {
+    warn(`Patch failed: ${e.message}`);
+    warn('Rolling back from backup.');
+    try {
+      copyFileSync(backupPath, filePath);
+    } catch (rollbackErr) {
+      return { ok: false, message: `Patch failed AND rollback failed: ${rollbackErr.message}. Manual restore from: ${backupPath}` };
+    }
+    return { ok: false, message: `Patch failed and rolled back: ${e.message}` };
+  }
+}
+
+function findBugPatternIndex(content) {
+  // Claude builds may contain either:
+  // - literal escape sequence: ".includes(\"\\x7f\")"
+  // - actual DEL char 0x7f inside the string: ".includes(\"\")"
+  const literal = content.indexOf('.includes("\\x7f")');
+  if (literal !== -1) return literal;
+  return content.indexOf(`.includes("${DEL_CHAR}")`);
+}
+
+function createBackup(filePath) {
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const backupPath = `${filePath}.backup-${ts}`;
+  copyFileSync(filePath, backupPath);
+  return backupPath;
+}
+
+export function restoreLatestBackup(filePath, { dryRun }) {
+  const dir = dirname(filePath);
+  const base = filePath.split(/[\\/]/).pop();
+  const backups = readdirSync(dir)
+    .filter((f) => f.startsWith(`${base}.backup-`))
+    .map((f) => join(dir, f))
+    .map((p) => ({ p, t: safeMtime(p) }))
+    .sort((a, b) => b.t - a.t);
+
+  const latest = backups[0]?.p;
+  if (!latest) {
+    err('No backups found to restore.');
+    return false;
+  }
+
+  if (dryRun) {
+    log(`DRY RUN: would restore from ${latest}`);
+    return true;
+  }
+
+  copyFileSync(latest, filePath);
+  ok(`Restored from: ${latest}`);
+  return true;
+}
+
+function findIfBlock(content, idx) {
+  // Search backward from idx within a 500-char window to find the nearest if(
+  const windowStart = Math.max(0, idx - 500);
+  const searchSlice = content.slice(windowStart, idx);
+  const localOffset = searchSlice.lastIndexOf('if(');
+  if (localOffset === -1) throw new Error(`Could not find containing if(...) block near index ${idx}`);
+  const start = windowStart + localOffset;
+
+  let depth = 0;
+  let end = -1;
+  for (let i = start; i < content.length; i++) {
+    const c = content[i];
+    if (c === '{') depth++;
+    else if (c === '}') {
+      depth--;
+      if (depth === 0) { end = i + 1; break; }
+    }
+  }
+  if (end === -1) throw new Error('Could not find end of if block (brace mismatch)');
+  if (idx < start || idx > end) throw new Error('Bug pattern found outside expected if block');
+  return { start, end, block: content.slice(start, end) };
+}
+
+function extractVariables(block) {
+  // Normalize DEL char for regex matching
+  const normalized = block.replaceAll(DEL_CHAR, '\\x7f');
+
+  // Match: let COUNT=(INPUT.match(/\x7f/g)||[]).length,STATE=CURSTATE;
+  const m = normalized.match(/let ([\w$]+)=\(\w+\.match\(\/\\x7f\/g\)\|\|\[\]\)\.length[,;]([\w$]+)=([\w$]+)[;,]/);
+  if (!m) throw new Error('Could not extract variables (count/state/curState)');
+  const state = m[2];
+  const curState = m[3];
+
+  const m2 = block.match(new RegExp(`([\\w$]+)\\(${escapeRegex(state)}\\.text\\);([\\w$]+)\\(${escapeRegex(state)}\\.offset\\)`));
+  if (!m2) throw new Error('Could not extract update functions');
+
+  const m3 = block.match(/([\w$]+)\.includes\("/);
+  if (!m3) throw new Error('Could not extract input variable');
+
+  return {
+    input: m3[1],
+    state,
+    curState,
+    updateText: m2[1],
+    updateOffset: m2[2],
+  };
+}
+
+function generateFix(v) {
+  // This mirrors the known fix: backspace N times, then insert replacement text.
+  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 escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}