dw-kit 1.0.1 → 1.0.2

package/.claude/rules/code-style.md

@@ -1,37 +1,37 @@
-# Code Style & Conventions
-
-## Nguyên tắc chung
-- Đặt tên biến/hàm rõ ràng, tự giải thích (self-documenting)
-- Ưu tiên đơn giản, dễ đọc hơn clever code
-- Mỗi function làm MỘT việc
-- Comments giải thích WHY, không phải WHAT
-- Xử lý errors ở đầu function (guard clauses / early return)
-
-## Naming Conventions
-- Variables/Functions: camelCase
-- Classes/Components: PascalCase
-- Constants: UPPER_SNAKE_CASE
-- Files: kebab-case hoặc theo convention của framework
-- Directories: kebab-case
-
-## File Organization
-- 1 component/class per file (trừ khi strongly related)
-- Group imports: external → internal → relative
-- Export ở cuối file hoặc inline (nhất quán trong project)
-
-## Error Handling
-- KHÔNG swallow errors (catch rỗng)
-- Log đủ context để debug (error message, input data, stack)
-- Dùng custom error types cho domain errors
-- Validate input ở boundary (API, form, external data)
-
-## Testing
-- Test file cùng tên với source: `foo.ts` → `foo.test.ts` hoặc `foo.spec.ts`
-- Mỗi test case kiểm tra MỘT behavior
-- Test name mô tả expected behavior: "should return error when input is empty"
-- Arrange → Act → Assert pattern
-- KHÔNG mock internal implementation details
-
-## NOTE
-Đây là quy tắc mặc định. Team tùy chỉnh theo stack cụ thể của dự án.
-Thêm framework-specific rules vào file này hoặc tạo file riêng trong `.claude/rules/`.
+# Code Style & Conventions
+
+## Nguyên tắc chung
+- Đặt tên biến/hàm rõ ràng, tự giải thích (self-documenting)
+- Ưu tiên đơn giản, dễ đọc hơn clever code
+- Mỗi function làm MỘT việc
+- Comments giải thích WHY, không phải WHAT
+- Xử lý errors ở đầu function (guard clauses / early return)
+
+## Naming Conventions
+- Variables/Functions: camelCase
+- Classes/Components: PascalCase
+- Constants: UPPER_SNAKE_CASE
+- Files: kebab-case hoặc theo convention của framework
+- Directories: kebab-case
+
+## File Organization
+- 1 component/class per file (trừ khi strongly related)
+- Group imports: external → internal → relative
+- Export ở cuối file hoặc inline (nhất quán trong project)
+
+## Error Handling
+- KHÔNG swallow errors (catch rỗng)
+- Log đủ context để debug (error message, input data, stack)
+- Dùng custom error types cho domain errors
+- Validate input ở boundary (API, form, external data)
+
+## Testing
+- Test file cùng tên với source: `foo.ts` → `foo.test.ts` hoặc `foo.spec.ts`
+- Mỗi test case kiểm tra MỘT behavior
+- Test name mô tả expected behavior: "should return error when input is empty"
+- Arrange → Act → Assert pattern
+- KHÔNG mock internal implementation details
+
+## NOTE
+Đây là quy tắc mặc định. Team tùy chỉnh theo stack cụ thể của dự án.
+Thêm framework-specific rules vào file này hoặc tạo file riêng trong `.claude/rules/`.

package/.claude/rules/commit-standards.md

@@ -1,37 +1,37 @@
-# Commit Standards
-
-## Format
-```
-<type>(<scope>): <mô tả tiếng Việt hoặc tiếng Anh>
-
-[Body - chi tiết thay đổi, lý do]
-[Blank line]
-[Footer - breaking changes, references]
-
-Co-Authored-By: Claude <noreply@anthropic.com>
-```
-
-## Types
-| Type | Khi nào dùng |
-|------|-------------|
-| `feat` | Tính năng mới |
-| `fix` | Sửa lỗi |
-| `refactor` | Tái cấu trúc, không thay đổi behavior |
-| `test` | Thêm/sửa tests |
-| `docs` | Tài liệu, comments |
-| `chore` | Build, config, dependencies |
-| `style` | Format, whitespace (không thay đổi logic) |
-| `perf` | Cải thiện performance |
-
-## Quy tắc
-- Mỗi commit = 1 subtask hoặc 1 đơn vị logic hoàn chỉnh
-- Mô tả ngắn <= 72 ký tự
-- Dùng thì hiện tại: "thêm", "sửa", "cập nhật" (không phải "đã thêm")
-- KHÔNG commit files chứa secrets (.env, credentials, tokens)
-- KHÔNG commit console.log/debugger còn sót
-
-## Branch Naming
-```
-<type>/<task-name>
-```
-Ví dụ: `feat/user-auth`, `fix/login-redirect`, `refactor/api-structure`
+# Commit Standards
+
+## Format
+```
+<type>(<scope>): <mô tả tiếng Việt hoặc tiếng Anh>
+
+[Body - chi tiết thay đổi, lý do]
+[Blank line]
+[Footer - breaking changes, references]
+
+Co-Authored-By: Claude <noreply@anthropic.com>
+```
+
+## Types
+| Type | Khi nào dùng |
+|------|-------------|
+| `feat` | Tính năng mới |
+| `fix` | Sửa lỗi |
+| `refactor` | Tái cấu trúc, không thay đổi behavior |
+| `test` | Thêm/sửa tests |
+| `docs` | Tài liệu, comments |
+| `chore` | Build, config, dependencies |
+| `style` | Format, whitespace (không thay đổi logic) |
+| `perf` | Cải thiện performance |
+
+## Quy tắc
+- Mỗi commit = 1 subtask hoặc 1 đơn vị logic hoàn chỉnh
+- Mô tả ngắn <= 72 ký tự
+- Dùng thì hiện tại: "thêm", "sửa", "cập nhật" (không phải "đã thêm")
+- KHÔNG commit files chứa secrets (.env, credentials, tokens)
+- KHÔNG commit console.log/debugger còn sót
+
+## Branch Naming
+```
+<type>/<task-name>
+```
+Ví dụ: `feat/user-auth`, `fix/login-redirect`, `refactor/api-structure`

package/.claude/settings.json

@@ -52,7 +52,7 @@
         "hooks": [
           {
             "type": "prompt",
-            "prompt": "Trước khi kết thúc, kiểm tra: (1) Có uncommitted changes quan trọng không? (2) Task đang làm dở chưa cập nhật progress? (3) Có blocker nào chưa ghi lại? Nếu có vấn đề, trả về {\"decision\": \"block\", \"reason\": \"[mô tả]\"}. Nếu OK, trả về {\"decision\": \"allow\"}."
+            "prompt": "Session context: $ARGUMENTS\n\nIf stop_hook_active is true in the context above, reply ONLY: {\"decision\":\"allow\"} to prevent infinite loops.\n\nOtherwise check: any uncommitted important changes? any in-progress task with outdated progress file? any unrecorded blockers?\n\nReply with ONLY valid JSON, no other text:\n- {\"decision\":\"block\",\"reason\":\"<describe what needs attention>\"} if action needed\n- {\"decision\":\"allow\"} if all clear"
           }
         ]
       }

package/.claude/settings.local.json

@@ -6,7 +6,8 @@
       "WebFetch(domain:docs.anthropic.com)",
       "Bash(grep -rL \"^name:\" .claude/skills/dw-*/SKILL.md)",
       "Bash(grep -c '\\\\$ARGUMENTS\\\\|context: fork\\\\|allowed-tools' .dw/adapters/generic/AGENT.md)",
-      "Bash(grep [v1.0.0] CHANGELOG.md)"
+      "Bash(grep [v1.0.0] CHANGELOG.md)",
+      "Bash(node src/smoke-test.mjs)"
     ]
   }
 }

package/.claude/skills/dw-prompt/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: dw-prompt
+description: "Improve a vague task description into a clear, actionable prompt. Uses git log + recent dw tasks for project context. Output is concise — human dev will refine further."
+argument-hint: "[task description] [--vi]"
+---
+
+# Prompt Builder
+
+Input: **$ARGUMENTS**
+
+## Bước 0 — Parse options
+
+- Nếu `$ARGUMENTS` chứa `--vi`: output bằng **tiếng Việt**, bỏ flag `--vi` ra khỏi description
+- Mặc định: output bằng **tiếng Anh**
+
+## Bước 1 — Lấy context từ git log
+
+Extract 1–2 keywords chính từ description (bỏ qua stop words: fix, add, feat, the, a, in, of).
+
+Chạy **cả hai** để có context tốt nhất:
+
+```bash
+# Tìm commits liên quan theo keyword
+git log --oneline --no-merges --all --grep="<keyword1>" -15
+git log --oneline --no-merges --all --grep="<keyword2>" -15
+
+# Fallback: 30 commits gần nhất
+git log --oneline --no-merges -30
+```
+
+Dùng kết quả để nhận ra: module names, naming conventions, commit style của project.
+
+## Bước 2 — Lấy context từ dw tasks gần đây
+
+Đọc danh sách task đang/đã làm:
+
+```bash
+ls .dw/tasks/
+```
+
+Nếu có task liên quan đến keyword → đọc file `*-progress.md` để hiểu thêm context (scope, decisions, findings).
+
+## Bước 3 — Improve prompt
+
+**Nếu $ARGUMENTS rỗng (sau khi bỏ flags):** hỏi ngắn "Describe your task:" trước.
+
+**Rules:**
+- **1–2 dòng tối đa** — human dev sẽ tự sửa thêm
+- Giữ: **what** + **scope** (nếu rõ từ context) + **outcome** (nếu rõ)
+- Active voice, present tense: "Fix...", "Add...", "Refactor..."
+- Không bullet points, không markdown headers trong output
+- Match naming conventions từ git log nếu nhận ra được
+
+## Output format
+
+```
+─── Improved prompt ──────────────────────
+<1–2 line improved prompt>
+──────────────────────────────────────────
+```
+
+Không thêm gì khác ngoài block trên.

package/CLAUDE.md

@@ -42,6 +42,7 @@ Không chắc scope → dùng `standard`. Assess dựa trên facts (file count,
 
 | Skill | Mô tả | Depth |
 |-------|--------|-------|
+| `/dw-prompt [desc]` | Build structured prompt (autocomplete + wizard) | all |
 | `/dw-task-init [name]` | Khởi tạo task docs | all |
 | `/dw-research [name]` | Khảo sát codebase | all |
 | `/dw-plan [name]` | Lập kế hoạch (DỪNG chờ approve) | standard+ |

package/README.md

@@ -19,15 +19,15 @@ Initialize → Understand → Plan → Execute (TDD) → Verify → Close
 flowchart LR
   classDef extra fill:#f3f4f6,stroke:#9ca3af,stroke-width:1px,color:#111;
 
-  D[Init + Understand] --> P[Plan (approve)]
-  P -->|approved| E[Execute (TDD)]
+  D["Init + Understand"] --> P["Plan (approve)"]
+  P -->|approved| E["Execute (TDD)"]
   P -->|revise| P
 
-  E --> V[Verify (gates)]
-  V -->|sign-off| C[Close (handoff + archive)]
-  V -->|revise (fix)| E
+  E --> V["Verify (gates)"]
+  V -->|sign-off| C["Close (handoff + archive)"]
+  V -->|"revise (fix)"| E
 
-  subgraph Extra[Depth=thorough]
+  subgraph Extra["Depth=thorough"]
     R[Req] --> Est[Est] --> AR[Arch] --> P
     P -.-> TP[Test] -.-> E
     E -.-> DU[Docs] --> LW[Log] -.-> C
@@ -36,6 +36,12 @@ flowchart LR
   class R,Est,AR,TP,DU,LW extra
 ```
 
+## Workflow overview
+
+`dw` runs a 6-phase process (all phases for `standard` and `thorough`):
+
+Initialize → Understand → Plan (stops for approval) → Execute (TDD; 1 commit per subtask) → Verify (quality gates + review sign-off) → Close (handoff + archive when done).
+
 ### 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).
@@ -58,24 +64,28 @@ npm install -g dw-kit
 
 ## Quick start
 
-From your project directory:
+Setup dw in project directory:
 
 ```bash
 dw init
 ```
 
-Then in **Claude Code** (Update for Cursor/Antigravity/... in the next version):
+Then in **Claude Code CLI**, run the full workflow:
 
 ```
-/dw-flow new-feature
+/dw-flow your-task-or-anythings
 ```
 
-## Workflow overview
+---
 
-`dw` runs a 6-phase process (all phases for `standard` and `thorough`):
+Discover other skills:
 
-Initialize → Understand → Plan (stops for approval) → Execute (TDD; 1 commit per subtask) → Verify (quality gates + review sign-off) → Close (handoff + archive when done).
+```
+/dw-prompt
+/dw-thinking
+...
 
+```
 
 ---
 
@@ -88,8 +98,13 @@ 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)
 ```
 
+`dw claude-vn-fix` patches the local Claude CLI bundle to fix Vietnamese IME input (DEL char `\x7f` issue). Includes auto-backup and rollback.
+
 ---
 
 ## Depth system

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dw-kit",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "AI development workflow toolkit — structured, quality-assured, team-ready. From requirements to dashboard.",
   "type": "module",
   "bin": {
@@ -46,6 +46,7 @@
     "ajv": "^8.18.0",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
+    "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1"
   }
 }

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
@@ -55,5 +61,32 @@ export function run(argv) {
       await doctorCommand();
     });
 
+  program
+    .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 { 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, '\\$&');
+}

package/src/commands/prompt.mjs

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { load as yamlLoad } from 'js-yaml';
+import { header, info, ok, warn, err, log } from '../lib/ui.mjs';
+import { copyToClipboard } from '../lib/clipboard.mjs';
+import { getSuggestions, isVague, expandTemplate } from '../lib/prompt-suggest.mjs';
+
+export async function promptCommand(opts) {
+  header('dw-kit Prompt Builder');
+
+  const adapter = readAdapter();
+
+  // Non-interactive mode: --text <text>
+  if (opts.text !== undefined) {
+    if (!opts.text.trim()) {
+      err('--text cannot be empty.');
+      process.exit(1);
+    }
+    const result = await buildPrompt(opts.text, { interactive: false });
+    outputResult(result, adapter);
+    return;
+  }
+
+  // Interactive mode
+  const result = await buildPrompt('', { interactive: true });
+  outputResult(result, adapter);
+}
+
+async function buildPrompt(initialText, { interactive }) {
+  let description = initialText;
+
+  if (interactive) {
+    description = await runAutocompleteStep();
+    if (!description.trim()) {
+      err('No description provided.');
+      process.exit(1);
+    }
+  }
+
+  let area = '';
+  let outcome = '';
+
+  if (isVague(description)) {
+    if (interactive) {
+      info('Description seems short — a couple of quick questions (Enter to skip):');
+      ({ area, outcome } = await runWizardStep());
+    }
+    // In non-interactive mode: expand with just the description (no wizard data)
+  }
+
+  return expandTemplate(description, { area, outcome });
+}
+
+async function runAutocompleteStep() {
+  const { AutoComplete } = await import('enquirer');
+  const suggestions = getSuggestions(process.cwd());
+
+  const prompt = new AutoComplete({
+    name: 'description',
+    message: 'Describe your task:',
+    limit: 7,
+    choices: suggestions.length ? suggestions : ['(no suggestions — type your task)'],
+    suggest(typed, choices) {
+      const lower = typed.toLowerCase();
+      const filtered = choices.filter((c) => c.message.toLowerCase().includes(lower));
+      // Always offer the raw typed text as first selectable option
+      if (typed && !filtered.find((c) => c.message === typed)) {
+        return [{ message: typed, value: typed }, ...filtered];
+      }
+      return filtered.length ? filtered : [{ message: typed || '(empty)', value: typed }];
+    },
+  });
+
+  return prompt.run();
+}
+
+async function runWizardStep() {
+  const { Input } = await import('enquirer');
+
+  const area = await new Input({
+    name: 'area',
+    message: 'Which area/files? (e.g. auth middleware, src/login/)',
+    initial: '',
+  }).run().catch(() => '');
+
+  const outcome = await new Input({
+    name: 'outcome',
+    message: 'Expected outcome? (e.g. user redirected to /dashboard)',
+    initial: '',
+  }).run().catch(() => '');
+
+  return { area, outcome };
+}
+
+function outputResult(text, adapter) {
+  log('');
+  log('─── Result ───────────────────────────────────────────');
+  log(text);
+  log('──────────────────────────────────────────────────────');
+  log('');
+
+  const shouldCopy = adapter === 'claude-cli' || adapter === 'cursor';
+  if (shouldCopy) {
+    const copied = copyToClipboard(text);
+    if (copied) {
+      ok('Copied to clipboard. Paste into Claude CLI or your IDE.');
+    } else {
+      warn('Clipboard copy failed. Copy the text above manually.');
+    }
+  } else {
+    // generic adapter: just output to stdout
+    info('(generic adapter — copy the text above manually)');
+  }
+}
+
+function readAdapter() {
+  const configPath = join(process.cwd(), '.dw', 'config', 'dw.config.yml');
+  if (!existsSync(configPath)) return 'claude-cli';
+  try {
+    const config = yamlLoad(readFileSync(configPath, 'utf-8'));
+    return config?.adapter || 'claude-cli';
+  } catch {
+    return 'claude-cli';
+  }
+}

package/src/lib/clipboard.mjs

@@ -0,0 +1,24 @@
+import { spawnSync } from 'node:child_process';
+import { platform } from 'node:process';
+
+/**
+ * Copy text to system clipboard.
+ * @returns {boolean} true if succeeded
+ */
+export function copyToClipboard(text) {
+  const candidates = platform === 'win32'
+    ? [['clip']]
+    : platform === 'darwin'
+      ? [['pbcopy']]
+      : [['wl-copy'], ['xclip', '-selection', 'clipboard'], ['xsel', '--clipboard', '--input']];
+
+  for (const [cmd, ...args] of candidates) {
+    try {
+      const result = spawnSync(cmd, args, { input: text, encoding: 'utf-8' });
+      if (result.status === 0) return true;
+    } catch {
+      // Try next candidate.
+    }
+  }
+  return false;
+}

package/src/lib/prompt-suggest.mjs

@@ -0,0 +1,84 @@
+import { execSync } from 'node:child_process';
+
+const TEMPLATE_SUGGESTIONS = [
+  'fix: ',
+  'fix authentication redirect after login',
+  'fix null pointer / undefined error in ',
+  'fix performance issue in ',
+  'feat: add ',
+  'feat: implement ',
+  'feat: support ',
+  'refactor: simplify ',
+  'refactor: extract ',
+  'refactor: rename ',
+  'perf: optimize ',
+  'perf: reduce load time of ',
+  'chore: update dependencies',
+  'docs: update README',
+  'test: add tests for ',
+];
+
+// Common verbs to detect whether a description has intent
+const INTENT_VERBS = [
+  'fix', 'add', 'update', 'remove', 'delete', 'create', 'implement', 'refactor',
+  'rename', 'move', 'improve', 'optimize', 'support', 'extract', 'migrate',
+  'replace', 'upgrade', 'enable', 'disable', 'integrate', 'patch',
+];
+
+function getTemplateSuggestions() {
+  return [...TEMPLATE_SUGGESTIONS];
+}
+
+export function getGitSuggestions(cwd) {
+  try {
+    const out = execSync('git log --oneline -50 --no-merges', {
+      cwd,
+      encoding: 'utf-8',
+      timeout: 3000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    return out
+      .trim()
+      .split('\n')
+      .filter(Boolean)
+      .map((line) => line.replace(/^[a-f0-9]+ /, '').trim())  // strip hash
+      .filter((msg) => msg.length > 5)
+      .slice(0, 30);
+  } catch {
+    return [];
+  }
+}
+
+export function getSuggestions(cwd = process.cwd()) {
+  const git = getGitSuggestions(cwd);
+  const templates = getTemplateSuggestions();
+  // git log first (most relevant to this repo), then templates
+  const merged = [...git, ...templates];
+  // dedupe
+  return [...new Set(merged)].slice(0, 20);
+}
+
+/**
+ * Returns true if the description is likely too vague to give Claude good context.
+ */
+export function isVague(text) {
+  const trimmed = (text || '').trim();
+  if (trimmed.length < 50) return true;
+  const lower = trimmed.toLowerCase();
+  const hasVerb = INTENT_VERBS.some((v) => lower.startsWith(v) || lower.includes(` ${v} `));
+  return !hasVerb;
+}
+
+/**
+ * Expand a short description into a structured prompt.
+ * @param {string} text - core task description
+ * @param {{ area?: string, outcome?: string }} extras
+ * @returns {string}
+ */
+export function expandTemplate(text, { area = '', outcome = '' } = {}) {
+  const base = text.trim();
+  const parts = [base];
+  if (area) parts.push(`Scope: ${area.trim()}.`);
+  if (outcome) parts.push(`Expected: ${outcome.trim()}.`);
+  return parts.join('\n');
+}

package/src/lib/update-checker.mjs

@@ -0,0 +1,73 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+const REGISTRY_URL = 'https://registry.npmjs.org/dw-kit/latest';
+const CACHE_DIR = join(homedir(), '.dw-kit');
+const CACHE_FILE = join(CACHE_DIR, 'update-cache.json');
+
+function parseSemver(v) {
+  const parts = String(v).replace(/^v/, '').split('.').map(Number);
+  return { major: parts[0] || 0, minor: parts[1] || 0, patch: parts[2] || 0 };
+}
+
+function isNewer(latest, current) {
+  const l = parseSemver(latest);
+  const c = parseSemver(current);
+  if (l.major !== c.major) return l.major > c.major;
+  if (l.minor !== c.minor) return l.minor > c.minor;
+  return l.patch > c.patch;
+}
+
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(CACHE_FILE, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(data) {
+  try {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(CACHE_FILE, JSON.stringify(data), 'utf-8');
+  } catch {
+    // ignore write errors (permission, disk full, etc.)
+  }
+}
+
+async function fetchLatestVersion() {
+  const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(3000) });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  const data = await res.json();
+  return data.version;
+}
+
+/**
+ * Returns latest version string if an update is available (from cache), null otherwise.
+ * Never throws, never makes network calls.
+ */
+export function getUpdateNotice(currentVersion) {
+  if (process.env.DW_NO_UPDATE_CHECK) return null;
+  const cache = readCache();
+  if (!cache?.latest) return null;
+  return isNewer(cache.latest, currentVersion) ? cache.latest : null;
+}
+
+/**
+ * Fires off an async check against npm registry and updates the cache.
+ * Non-blocking — caller should NOT await this.
+ * Skips the check if cache is still fresh (< 24h).
+ */
+export function scheduleUpdateCheck(currentVersion) {
+  if (process.env.DW_NO_UPDATE_CHECK) return;
+
+  const cache = readCache();
+  const now = Date.now();
+  if (cache?.checkedAt && now - cache.checkedAt < CACHE_TTL_MS) return;
+
+  fetchLatestVersion()
+    .then((latest) => writeCache({ latest, checkedAt: now, current: currentVersion }))
+    .catch(() => {});
+}

package/src/smoke-test.mjs

@@ -11,6 +11,7 @@ import { mkdirSync, rmSync, existsSync, readFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { execSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { copyFileSync } from 'node:fs';
 
 const __dirname = resolve(fileURLToPath(import.meta.url), '..');
 const DW_BIN = resolve(__dirname, '..', 'bin', 'dw.mjs');
@@ -72,7 +73,7 @@ test('--version returns semver', () => {
 
 test('--help lists all commands', () => {
   const out = dw('--help', TEMP_BASE);
-  for (const cmd of ['init', 'upgrade', 'validate', 'doctor']) {
+  for (const cmd of ['init', 'upgrade', 'validate', 'doctor', 'prompt', 'claude-vn-fix']) {
     assert(out.includes(cmd), `Missing command: ${cmd}`);
   }
 });
@@ -262,6 +263,51 @@ test('doctor reports issues on empty project', () => {
   }
 });
 
+// ── Test: dw prompt ──────────────────────────────────────────────────────────
+console.log();
+console.log('▶ dw prompt');
+
+test('prompt --text outputs structured result', () => {
+  const out = dw('prompt --text "fix login redirect after OAuth in auth middleware"', TEMP_BASE);
+  assert(out.includes('fix login redirect'), 'Should include description in output');
+  assert(!out.includes('Description seems short'), 'Long description should skip wizard');
+});
+
+test('prompt --text with short input expands without error', () => {
+  const out = dw('prompt --text "fix login"', TEMP_BASE);
+  assert(out.includes('fix login'), 'Should include description in output');
+});
+
+test('prompt --text empty string exits with error', () => {
+  try {
+    dw('prompt --text ""', TEMP_BASE);
+    assert(false, 'Should have thrown');
+  } catch (e) {
+    assert(e.status === 1, 'Should exit with code 1');
+  }
+});
+
+test('prompt --help shows options', () => {
+  const out = dw('prompt --help', TEMP_BASE);
+  assert(out.includes('--text'), 'Missing --text option');
+});
+
+// ── Test: dw claude-vn-fix (fixture patch) ───────────────────────────────────
+console.log();
+console.log('▶ dw claude-vn-fix');
+
+test('claude-vn-fix patches known bug fixture', () => {
+  const dir = freshDir('claude-vn-fix-fixture');
+  const fixtureSrc = resolve(__dirname, '__fixtures__', 'claude-cli-bug-snippet.js');
+  const target = join(dir, 'cli.js');
+  copyFileSync(fixtureSrc, target);
+
+  const out = dw(`claude-vn-fix --path "${target}"`, dir);
+  assert(out.includes('Patch applied') || out.includes('Already patched'), 'Should apply patch');
+  const patched = readFileSync(target, 'utf-8');
+  assert(patched.includes('dw-kit Vietnamese IME fix'), 'Patch marker missing in output file');
+});
+
 // ── Test: dw upgrade ─────────────────────────────────────────────────────────
 console.log();
 console.log('▶ dw upgrade');