dw-kit 1.0.1 → 1.1.0

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/init.mjs

@@ -276,7 +276,7 @@ function createRuntimeDirs(projectDir) {
 
 function updateGitignore(projectDir) {
   const gitignorePath = join(projectDir, '.gitignore');
-  const entriesToAdd = ['.dw/metrics/', '.dw/reports/', 'CLAUDE.local.md'];
+  const entriesToAdd = ['CLAUDE.local.md', '.claude/settings.local.json'];
 
   if (existsSync(gitignorePath)) {
     const content = readFileSync(gitignorePath, 'utf-8');

package/src/commands/prompt.mjs

@@ -0,0 +1,112 @@
+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';
+import { detectPlatform } from '../lib/platform.mjs';
+
+export async function promptCommand(opts) {
+  header('dw-kit Prompt Builder');
+
+  const adapter = detectPlatform(process.cwd());
+
+  // 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)');
+  }
+}

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');

package/.claude/settings.local.json

@@ -1,12 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "WebFetch(domain:alexop.dev)",
-      "WebFetch(domain:github.com)",
-      "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)"
-    ]
-  }
-}