fuzzrunx 0.1.5 → 0.1.7

package/README.md

@@ -19,6 +19,7 @@ On install, FuzzRun auto-enables shell hooks and will print:
 
 If you want to skip auto-enable, set `FUZZRUN_SKIP_ENABLE=1` during install.
 If auto-enable didn't run (scripts disabled or local install), running any command with `fuzzrun` will attempt a one-time auto-enable unless `FUZZRUN_SKIP_ENABLE=1` is set.
+On uninstall, FuzzRun automatically removes its shell hooks.
 
 ### Bash/Zsh hook (auto-run on typos)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuzzrunx",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Auto-correct mistyped commands and subcommands and re-run them safely.",
   "bin": {
     "fuzzrun": "bin/fuzzrun.js"
@@ -9,6 +9,7 @@
   "license": "MIT",
   "scripts": {
     "start": "node bin/fuzzrun.js",
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/postinstall.js",
+    "postuninstall": "node scripts/postuninstall.js"
   }
 }

package/scripts/postinstall.js

@@ -1,17 +1,36 @@
 'use strict';
 
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
 const installer = require('../src/installer');
 
 const skip = process.env.FUZZRUN_SKIP_ENABLE === '1';
 
+function getStatePath() {
+  return path.join(os.homedir(), '.fuzzrun', 'state.json');
+}
+
+function writeState(next) {
+  const filePath = getStatePath();
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(next, null, 2), 'utf8');
+}
+
 if (skip) {
-  process.stdout.write('fuzzrun: auto-enable skipped\n');
+  process.stderr.write('fuzzrun: auto-enable skipped\n');
   process.exit(0);
 }
 
+const foregroundScripts =
+  process.env.npm_config_foreground_scripts === 'true' ||
+  process.env.npm_config_foreground_scripts === '1';
+
 try {
   installer.enable({});
-  process.stdout.write('FuzzRun is automatically enabled. Run "fuzzrun disable" to deactivate.\n');
+  process.stderr.write('FuzzRun is automatically enabled. Run "fuzzrun disable" to deactivate.\n');
+  writeState({ bannerShown: foregroundScripts, enableSucceeded: true });
 } catch (err) {
-  process.stdout.write(`fuzzrun: auto-enable failed: ${err.message}\n`);
+  process.stderr.write(`fuzzrun: auto-enable failed: ${err.message}\n`);
+  writeState({ bannerShown: false, enableSucceeded: false, lastError: err.message });
 }

package/scripts/postuninstall.js

@@ -0,0 +1,10 @@
+'use strict';
+
+const installer = require('../src/installer');
+
+try {
+  installer.disable();
+  process.stderr.write('FuzzRun hooks removed. Restart your terminal if needed.\n');
+} catch (err) {
+  process.stderr.write(`fuzzrun: postuninstall cleanup failed: ${err.message}\n`);
+}

package/src/cli.js

@@ -5,40 +5,41 @@
 
 const { spawnSync } = require('child_process');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
 const installer = require('./installer');
-
-const MAX_DISTANCE = Number.isFinite(Number(process.env.FUZZRUN_MAX_DISTANCE))
-  ? Math.max(1, Number(process.env.FUZZRUN_MAX_DISTANCE))
-  : 1;
-
-const DEFAULT_PRIORITY_BASES = [
-  'git',
-  'npm',
-  'yarn',
-  'pnpm',
-  'node',
-  'python',
-  'python3',
-  'pip',
-  'pip3',
-  'docker',
-  'kubectl',
-  'gh',
-  'go',
-  'cargo',
-  'dotnet',
-  'java',
-  'mvn',
-  'gradle'
-];
-const ENV_PRIORITY_BASES = (process.env.FUZZRUN_PREFER_BASES || '')
-  .split(',')
-  .map((value) => normalizeToken(value).trim())
-  .filter(Boolean);
-const PRIORITY_BASES = new Set([...DEFAULT_PRIORITY_BASES, ...ENV_PRIORITY_BASES]);
-
-const DANGEROUS_BASE = new Set(['rm', 'mv', 'dd', 'shutdown', 'reboot', 'halt', 'poweroff']);
+
+const MAX_DISTANCE = Number.isFinite(Number(process.env.FUZZRUN_MAX_DISTANCE))
+  ? Math.max(1, Number(process.env.FUZZRUN_MAX_DISTANCE))
+  : 1;
+
+const DEFAULT_PRIORITY_BASES = [
+  'git',
+  'npm',
+  'yarn',
+  'pnpm',
+  'node',
+  'python',
+  'python3',
+  'pip',
+  'pip3',
+  'docker',
+  'kubectl',
+  'gh',
+  'go',
+  'cargo',
+  'dotnet',
+  'java',
+  'mvn',
+  'gradle'
+];
+const ENV_PRIORITY_BASES = (process.env.FUZZRUN_PREFER_BASES || '')
+  .split(',')
+  .map((value) => normalizeToken(value).trim())
+  .filter(Boolean);
+const PRIORITY_BASES = new Set([...DEFAULT_PRIORITY_BASES, ...ENV_PRIORITY_BASES]);
+
+const DANGEROUS_BASE = new Set(['rm', 'mv', 'dd', 'shutdown', 'reboot', 'halt', 'poweroff']);
 
 const COMMON_SUBCOMMANDS = {
   git: [
@@ -174,31 +175,31 @@ const COMMON_SUBCOMMANDS = {
     'drain',
     'uncordon'
   ],
-  gh: ['auth', 'repo', 'issue', 'pr', 'gist', 'alias', 'api', 'search', 'run', 'workflow', 'status', 'label']
-};
-
-const SAFE_SUBCOMMAND_BASES = new Set(Object.keys(COMMON_SUBCOMMANDS));
-const ALLOW_ANY_SUBCOMMANDS = process.env.FUZZRUN_ALLOW_ANY_SUBCOMMANDS === '1';
-const SCRIPT_BASES = new Set(['npm', 'yarn', 'pnpm']);
-const RISKY_ARG_PATTERNS = [
-  /^-f$/,
-  /^-rf$/,
-  /^-fr$/,
-  /^--force$/i,
-  /^--hard$/i,
-  /^--delete$/i,
-  /^--purge$/i,
-  /^--no-preserve-root$/i
-];
-const SCRIPT_ERROR_PATTERNS = [
-  /missing script/i,
-  /unknown script/i,
-  /script.*not found/i,
-  /couldn'?t find.*script/i,
-  /command ".*" not found/i
-];
-const GIT_PATHSPEC_PATTERN = /pathspec .* did not match/i;
-
+  gh: ['auth', 'repo', 'issue', 'pr', 'gist', 'alias', 'api', 'search', 'run', 'workflow', 'status', 'label']
+};
+
+const SAFE_SUBCOMMAND_BASES = new Set(Object.keys(COMMON_SUBCOMMANDS));
+const ALLOW_ANY_SUBCOMMANDS = process.env.FUZZRUN_ALLOW_ANY_SUBCOMMANDS === '1';
+const SCRIPT_BASES = new Set(['npm', 'yarn', 'pnpm']);
+const RISKY_ARG_PATTERNS = [
+  /^-f$/,
+  /^-rf$/,
+  /^-fr$/,
+  /^--force$/i,
+  /^--hard$/i,
+  /^--delete$/i,
+  /^--purge$/i,
+  /^--no-preserve-root$/i
+];
+const SCRIPT_ERROR_PATTERNS = [
+  /missing script/i,
+  /unknown script/i,
+  /script.*not found/i,
+  /couldn'?t find.*script/i,
+  /command ".*" not found/i
+];
+const GIT_PATHSPEC_PATTERN = /pathspec .* did not match/i;
+
 const suggestionPatterns = [
   /The most similar command is\s+([^\s]+)/i,
   /The most similar commands are:\s*\n\s*([^\s]+)/i,
@@ -207,58 +208,87 @@ const suggestionPatterns = [
   /Perhaps you meant\s+['"]?([A-Za-z0-9:_-]+)['"]?\??/i
 ];
 
-function normalizeToken(value) {
-  return String(value || '').toLowerCase();
+function getStatePath() {
+  return path.join(os.homedir(), '.fuzzrun', 'state.json');
 }
 
-function commandKey(command) {
-  const base = path.basename(String(command || ''));
-  const ext = path.extname(base);
-  return normalizeToken(ext ? base.slice(0, -ext.length) : base);
+function readState() {
+  try {
+    const raw = fs.readFileSync(getStatePath(), 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    return null;
+  }
 }
 
-function isInteractiveCommand(command, args) {
-  const key = commandKey(command);
-  if (INTERACTIVE_BASES.has(key)) return true;
-  const subcommand = args && args.length ? normalizeToken(args[0]) : '';
-  if (subcommand && INTERACTIVE_SUBCOMMANDS[key] && INTERACTIVE_SUBCOMMANDS[key].has(subcommand)) {
-    return true;
+function writeState(next) {
+  try {
+    const filePath = getStatePath();
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(next, null, 2), 'utf8');
+  } catch (err) {
+    // Best-effort only.
   }
-  return false;
 }
 
-function damerauLevenshtein(a, b, maxDistance = 2) {
-  const aNorm = normalizeToken(a);
-  const bNorm = normalizeToken(b);
-  if (aNorm === bNorm) return 0;
-  if (Math.abs(aNorm.length - bNorm.length) > maxDistance) {
-    return maxDistance + 1;
-  }
-  const dp = Array.from({ length: aNorm.length + 1 }, () => new Array(bNorm.length + 1).fill(0));
-  for (let i = 0; i <= aNorm.length; i += 1) dp[i][0] = i;
-  for (let j = 0; j <= bNorm.length; j += 1) dp[0][j] = j;
-  for (let i = 1; i <= aNorm.length; i += 1) {
-    let rowMin = maxDistance + 1;
-    for (let j = 1; j <= bNorm.length; j += 1) {
-      const cost = aNorm[i - 1] === bNorm[j - 1] ? 0 : 1;
-      let value = Math.min(
-        dp[i - 1][j] + 1,
-        dp[i][j - 1] + 1,
-        dp[i - 1][j - 1] + cost
-      );
-      if (i > 1 && j > 1 && aNorm[i - 1] === bNorm[j - 2] && aNorm[i - 2] === bNorm[j - 1]) {
-        value = Math.min(value, dp[i - 2][j - 2] + 1);
-      }
-      dp[i][j] = value;
-      if (value < rowMin) rowMin = value;
-    }
-    if (rowMin > maxDistance) {
-      return maxDistance + 1;
-    }
+function updateState(patch) {
+  const state = readState() || {};
+  const next = { ...state, ...patch };
+  writeState(next);
+  return next;
+}
+
+function showInstallBannerOnce() {
+  const state = readState() || {};
+  if (state.bannerShown || state.disabled) return;
+  const message =
+    state.enableSucceeded === false
+      ? 'FuzzRun auto-enable failed during install. Run "fuzzrun enable" to activate.\n'
+      : 'FuzzRun is automatically enabled. Run "fuzzrun disable" to deactivate.\n';
+  process.stderr.write(message);
+  state.bannerShown = true;
+  if (typeof state.enableSucceeded === 'undefined') {
+    state.enableSucceeded = true;
   }
-  return dp[aNorm.length][bNorm.length];
+  writeState(state);
+}
+
+function normalizeToken(value) {
+  return String(value || '').toLowerCase();
 }
 
+function damerauLevenshtein(a, b, maxDistance = 2) {
+  const aNorm = normalizeToken(a);
+  const bNorm = normalizeToken(b);
+  if (aNorm === bNorm) return 0;
+  if (Math.abs(aNorm.length - bNorm.length) > maxDistance) {
+    return maxDistance + 1;
+  }
+  const dp = Array.from({ length: aNorm.length + 1 }, () => new Array(bNorm.length + 1).fill(0));
+  for (let i = 0; i <= aNorm.length; i += 1) dp[i][0] = i;
+  for (let j = 0; j <= bNorm.length; j += 1) dp[0][j] = j;
+  for (let i = 1; i <= aNorm.length; i += 1) {
+    let rowMin = maxDistance + 1;
+    for (let j = 1; j <= bNorm.length; j += 1) {
+      const cost = aNorm[i - 1] === bNorm[j - 1] ? 0 : 1;
+      let value = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+      if (i > 1 && j > 1 && aNorm[i - 1] === bNorm[j - 2] && aNorm[i - 2] === bNorm[j - 1]) {
+        value = Math.min(value, dp[i - 2][j - 2] + 1);
+      }
+      dp[i][j] = value;
+      if (value < rowMin) rowMin = value;
+    }
+    if (rowMin > maxDistance) {
+      return maxDistance + 1;
+    }
+  }
+  return dp[aNorm.length][bNorm.length];
+}
+
 function collectPathCommands() {
   const names = new Set();
   const pathEntries = (process.env.PATH || '').split(path.delimiter).filter(Boolean);
@@ -291,103 +321,46 @@ function collectPathCommands() {
   return names;
 }
 
-const PATH_COMMANDS = collectPathCommands();
-const RESOLVE_CACHE = new Map();
-const PATHEXT = (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
-  .split(';')
-  .map((value) => value.toLowerCase())
-  .filter(Boolean);
-const INTERACTIVE_BASES = new Set(
-  (process.env.FUZZRUN_INTERACTIVE_BASES || 'npm,npx,yarn,pnpm')
-    .split(',')
-    .map((value) => normalizeToken(value).trim())
-    .filter(Boolean)
-);
-const INTERACTIVE_SUBCOMMANDS = {
-  npm: new Set(['publish', 'login', 'adduser']),
-  yarn: new Set(['publish', 'login']),
-  pnpm: new Set(['publish', 'login'])
-};
-
-function looksLikePath(value) {
-  if (!value) return false;
-  return value.includes('/') || value.includes('\\') || value.includes(':');
-}
-
-function resolveCommand(command) {
-  if (!command || looksLikePath(command)) return command;
-  if (RESOLVE_CACHE.has(command)) return RESOLVE_CACHE.get(command);
-
-  let resolved = null;
-  if (process.platform === 'win32') {
-    const result = spawnSync('where', [command], { encoding: 'utf8' });
-    if (result.status === 0) {
-      const lines = String(result.stdout || '')
-        .split(/\r?\n/)
-        .map((value) => value.trim())
-        .filter(Boolean);
-      const preferred = lines.find((line) => PATHEXT.includes(path.extname(line).toLowerCase()));
-      resolved = preferred || lines[0] || null;
-      if (resolved && !path.extname(resolved)) {
-        for (const ext of PATHEXT) {
-          const candidate = `${resolved}${ext.toLowerCase()}`;
-          if (fs.existsSync(candidate)) {
-            resolved = candidate;
-            break;
-          }
-        }
-      }
-    }
-  } else {
-    const result = spawnSync('which', [command], { encoding: 'utf8' });
-    if (result.status === 0) {
-      const line = String(result.stdout || '').trim();
-      if (line) resolved = line;
-    }
-  }
-
-  RESOLVE_CACHE.set(command, resolved || command);
-  return resolved || command;
-}
-
-function normalizePowerShellGetPrefix(command) {
-  if (!command) return command;
-  const lowered = normalizeToken(command);
-  if (!lowered.startsWith('get-')) return command;
-  if (PATH_COMMANDS.has(command) || PATH_COMMANDS.has(lowered)) return command;
-  const stripped = command.slice(4);
-  if (!stripped) return command;
-  if (PATH_COMMANDS.has(stripped)) return stripped;
-  const match = findBestMatch(PATH_COMMANDS, stripped, MAX_DISTANCE);
-  if (match) return stripped;
-  return command;
-}
-
-function findBestMatch(candidates, target, maxDistance = MAX_DISTANCE) {
-  if (!candidates || !target) return null;
-  let best = null;
-  let bestDistance = maxDistance + 1;
-  let ties = [];
-  for (const candidate of candidates || []) {
-    const dist = damerauLevenshtein(candidate, target, maxDistance);
-    if (dist < bestDistance) {
-      best = candidate;
-      bestDistance = dist;
-      ties = [candidate];
-    } else if (dist === bestDistance) {
-      ties.push(candidate);
-    }
-  }
-  if (!best || bestDistance > maxDistance) return null;
-  if (ties.length > 1) {
-    const preferred = ties.filter((value) => PRIORITY_BASES.has(normalizeToken(value)));
-    if (preferred.length === 1) {
-      return { match: preferred[0], distance: bestDistance };
-    }
-    return null;
-  }
-  return { match: best, distance: bestDistance };
-}
+const PATH_COMMANDS = collectPathCommands();
+
+function normalizePowerShellGetPrefix(command) {
+  if (!command) return command;
+  const lowered = normalizeToken(command);
+  if (!lowered.startsWith('get-')) return command;
+  if (PATH_COMMANDS.has(command) || PATH_COMMANDS.has(lowered)) return command;
+  const stripped = command.slice(4);
+  if (!stripped) return command;
+  if (PATH_COMMANDS.has(stripped)) return stripped;
+  const match = findBestMatch(PATH_COMMANDS, stripped, MAX_DISTANCE);
+  if (match) return stripped;
+  return command;
+}
+
+function findBestMatch(candidates, target, maxDistance = MAX_DISTANCE) {
+  if (!candidates || !target) return null;
+  let best = null;
+  let bestDistance = maxDistance + 1;
+  let ties = [];
+  for (const candidate of candidates || []) {
+    const dist = damerauLevenshtein(candidate, target, maxDistance);
+    if (dist < bestDistance) {
+      best = candidate;
+      bestDistance = dist;
+      ties = [candidate];
+    } else if (dist === bestDistance) {
+      ties.push(candidate);
+    }
+  }
+  if (!best || bestDistance > maxDistance) return null;
+  if (ties.length > 1) {
+    const preferred = ties.filter((value) => PRIORITY_BASES.has(normalizeToken(value)));
+    if (preferred.length === 1) {
+      return { match: preferred[0], distance: bestDistance };
+    }
+    return null;
+  }
+  return { match: best, distance: bestDistance };
+}
 
 function parseSuggestion(text) {
   for (const pattern of suggestionPatterns) {
@@ -399,151 +372,134 @@ function parseSuggestion(text) {
   return null;
 }
 
-function run(cmd, args) {
-  const interactive = isInteractiveCommand(cmd, args);
-  const result = spawnSync(cmd, args, {
-    encoding: 'utf8',
-    stdio: interactive ? 'inherit' : ['inherit', 'pipe', 'pipe']
-  });
-  if (result.error && result.error.code === 'ENOENT') {
-    const resolved = resolveCommand(cmd);
-    if (resolved && resolved !== cmd) {
-      const retryInteractive = isInteractiveCommand(resolved, args);
-      const retry = spawnSync(resolved, args, {
-        encoding: 'utf8',
-        stdio: retryInteractive ? 'inherit' : ['inherit', 'pipe', 'pipe']
-      });
-      return {
-        code: typeof retry.status === 'number' ? retry.status : retry.error ? 1 : 0,
-        stdout: retryInteractive ? '' : retry.stdout || '',
-        stderr: retryInteractive ? '' : retry.stderr || '',
-        error: retry.error
-      };
-    }
-  }
-  return {
-    code: typeof result.status === 'number' ? result.status : result.error ? 1 : 0,
-    stdout: interactive ? '' : result.stdout || '',
-    stderr: interactive ? '' : result.stderr || '',
-    error: result.error
-  };
-}
+function run(cmd, args) {
+  const result = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    stdio: ['inherit', 'pipe', 'pipe']
+  });
+  return {
+    code: typeof result.status === 'number' ? result.status : result.error ? 1 : 0,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    error: result.error
+  };
+}
+
+function logFix(from, to) {
+  process.stderr.write(`fuzzrun: auto-correcting "${from}" -> "${to}"\n`);
+}
+
+function hasRiskyArgs(args) {
+  return args.some((arg) => RISKY_ARG_PATTERNS.some((pattern) => pattern.test(arg)));
+}
+
+function tryBaseCorrection(command, args) {
+  if (hasRiskyArgs(args)) return null;
+  const suggestion = findBestMatch(PATH_COMMANDS, command, MAX_DISTANCE);
+  if (suggestion && !DANGEROUS_BASE.has(suggestion.match) && suggestion.match !== command) {
+    logFix(command, suggestion.match);
+    return {
+      command: suggestion.match,
+      args,
+      result: run(suggestion.match, args)
+    };
+  }
+  return null;
+}
+
+function trySubcommandCorrection(command, args, combinedOutput) {
+  if (!SAFE_SUBCOMMAND_BASES.has(command) && !ALLOW_ANY_SUBCOMMANDS) return null;
+  if (!args.length) return null;
+  const attemptedSub = args[0];
+  if (attemptedSub.startsWith('-')) return null;
+  if (hasRiskyArgs(args)) return null;
+  const fromOutput = parseSuggestion(combinedOutput);
+  const candidates = COMMON_SUBCOMMANDS[command] || [];
+  const fromDict = findBestMatch(candidates, attemptedSub, MAX_DISTANCE);
+  const outputDistance = fromOutput
+    ? damerauLevenshtein(fromOutput, attemptedSub, MAX_DISTANCE)
+    : MAX_DISTANCE + 1;
+  const choice = outputDistance <= MAX_DISTANCE ? fromOutput : fromDict ? fromDict.match : null;
+
+  if (choice && choice !== attemptedSub && damerauLevenshtein(choice, attemptedSub, MAX_DISTANCE) <= MAX_DISTANCE) {
+    logFix(`${command} ${attemptedSub}`, `${command} ${choice}`);
+    return run(command, [choice, ...args.slice(1)]);
+  }
+  return null;
+}
+
+function findPackageJson(startDir) {
+  let current = startDir;
+  while (current && current !== path.dirname(current)) {
+    const candidate = path.join(current, 'package.json');
+    if (fs.existsSync(candidate)) return candidate;
+    current = path.dirname(current);
+  }
+  return null;
+}
+
+function getPackageScripts(cwd) {
+  const pkgPath = findPackageJson(cwd);
+  if (!pkgPath) return [];
+  try {
+    const raw = fs.readFileSync(pkgPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Object.keys(parsed.scripts || {});
+  } catch (err) {
+    return [];
+  }
+}
+
+function isScriptError(output) {
+  return SCRIPT_ERROR_PATTERNS.some((pattern) => pattern.test(output));
+}
+
+function tryScriptCorrection(command, args, combinedOutput) {
+  if (!SCRIPT_BASES.has(command)) return null;
+  if (args.length < 2) return null;
+  if (args[0] !== 'run') return null;
+  const scriptName = args[1];
+  if (!scriptName || scriptName.startsWith('-')) return null;
+  if (!isScriptError(combinedOutput)) return null;
+  if (hasRiskyArgs(args)) return null;
+
+  const scripts = getPackageScripts(process.cwd());
+  const match = findBestMatch(scripts, scriptName, MAX_DISTANCE);
+  if (match) {
+    logFix(`${command} run ${scriptName}`, `${command} run ${match.match}`);
+    return run(command, ['run', match.match, ...args.slice(2)]);
+  }
+  return null;
+}
+
+function getGitBranches() {
+  const result = spawnSync('git', ['branch', '--format=%(refname:short)'], { encoding: 'utf8' });
+  if (result.status !== 0) return [];
+  return (result.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function tryGitBranchCorrection(command, args, combinedOutput) {
+  if (command !== 'git') return null;
+  if (args.length < 2) return null;
+  const subcommand = args[0];
+  if (subcommand !== 'checkout' && subcommand !== 'switch') return null;
+  const branch = args[1];
+  if (!branch || branch.startsWith('-')) return null;
+  if (!GIT_PATHSPEC_PATTERN.test(combinedOutput)) return null;
+  if (hasRiskyArgs(args)) return null;
+
+  const branches = getGitBranches();
+  const match = findBestMatch(branches, branch, MAX_DISTANCE);
+  if (match) {
+    logFix(`${command} ${subcommand} ${branch}`, `${command} ${subcommand} ${match.match}`);
+    return run(command, [subcommand, match.match, ...args.slice(2)]);
+  }
+  return null;
+}
 
-function logFix(from, to) {
-  process.stderr.write(`fuzzrun: auto-correcting "${from}" -> "${to}"\n`);
-}
-
-function hasRiskyArgs(args) {
-  return args.some((arg) => RISKY_ARG_PATTERNS.some((pattern) => pattern.test(arg)));
-}
-
-function tryBaseCorrection(command, args) {
-  if (hasRiskyArgs(args)) return null;
-  const suggestion = findBestMatch(PATH_COMMANDS, command, MAX_DISTANCE);
-  if (suggestion && !DANGEROUS_BASE.has(suggestion.match) && suggestion.match !== command) {
-    logFix(command, suggestion.match);
-    return {
-      command: suggestion.match,
-      args,
-      result: run(suggestion.match, args)
-    };
-  }
-  return null;
-}
-
-function trySubcommandCorrection(command, args, combinedOutput) {
-  if (!SAFE_SUBCOMMAND_BASES.has(command) && !ALLOW_ANY_SUBCOMMANDS) return null;
-  if (!args.length) return null;
-  const attemptedSub = args[0];
-  if (attemptedSub.startsWith('-')) return null;
-  if (hasRiskyArgs(args)) return null;
-  const fromOutput = parseSuggestion(combinedOutput);
-  const candidates = COMMON_SUBCOMMANDS[command] || [];
-  const fromDict = findBestMatch(candidates, attemptedSub, MAX_DISTANCE);
-  const outputDistance = fromOutput
-    ? damerauLevenshtein(fromOutput, attemptedSub, MAX_DISTANCE)
-    : MAX_DISTANCE + 1;
-  const choice = outputDistance <= MAX_DISTANCE ? fromOutput : fromDict ? fromDict.match : null;
-
-  if (choice && choice !== attemptedSub && damerauLevenshtein(choice, attemptedSub, MAX_DISTANCE) <= MAX_DISTANCE) {
-    logFix(`${command} ${attemptedSub}`, `${command} ${choice}`);
-    return run(command, [choice, ...args.slice(1)]);
-  }
-  return null;
-}
-
-function findPackageJson(startDir) {
-  let current = startDir;
-  while (current && current !== path.dirname(current)) {
-    const candidate = path.join(current, 'package.json');
-    if (fs.existsSync(candidate)) return candidate;
-    current = path.dirname(current);
-  }
-  return null;
-}
-
-function getPackageScripts(cwd) {
-  const pkgPath = findPackageJson(cwd);
-  if (!pkgPath) return [];
-  try {
-    const raw = fs.readFileSync(pkgPath, 'utf8');
-    const parsed = JSON.parse(raw);
-    return Object.keys(parsed.scripts || {});
-  } catch (err) {
-    return [];
-  }
-}
-
-function isScriptError(output) {
-  return SCRIPT_ERROR_PATTERNS.some((pattern) => pattern.test(output));
-}
-
-function tryScriptCorrection(command, args, combinedOutput) {
-  if (!SCRIPT_BASES.has(command)) return null;
-  if (args.length < 2) return null;
-  if (args[0] !== 'run') return null;
-  const scriptName = args[1];
-  if (!scriptName || scriptName.startsWith('-')) return null;
-  if (!isScriptError(combinedOutput)) return null;
-  if (hasRiskyArgs(args)) return null;
-
-  const scripts = getPackageScripts(process.cwd());
-  const match = findBestMatch(scripts, scriptName, MAX_DISTANCE);
-  if (match) {
-    logFix(`${command} run ${scriptName}`, `${command} run ${match.match}`);
-    return run(command, ['run', match.match, ...args.slice(2)]);
-  }
-  return null;
-}
-
-function getGitBranches() {
-  const result = spawnSync('git', ['branch', '--format=%(refname:short)'], { encoding: 'utf8' });
-  if (result.status !== 0) return [];
-  return (result.stdout || '')
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter(Boolean);
-}
-
-function tryGitBranchCorrection(command, args, combinedOutput) {
-  if (command !== 'git') return null;
-  if (args.length < 2) return null;
-  const subcommand = args[0];
-  if (subcommand !== 'checkout' && subcommand !== 'switch') return null;
-  const branch = args[1];
-  if (!branch || branch.startsWith('-')) return null;
-  if (!GIT_PATHSPEC_PATTERN.test(combinedOutput)) return null;
-  if (hasRiskyArgs(args)) return null;
-
-  const branches = getGitBranches();
-  const match = findBestMatch(branches, branch, MAX_DISTANCE);
-  if (match) {
-    logFix(`${command} ${subcommand} ${branch}`, `${command} ${subcommand} ${match.match}`);
-    return run(command, [subcommand, match.match, ...args.slice(2)]);
-  }
-  return null;
-}
-
 function main() {
   const argv = process.argv.slice(2);
   if (!argv.length) {
@@ -551,116 +507,121 @@ function main() {
     process.exit(1);
   }
 
+  showInstallBannerOnce();
+
   const action = argv[0];
   if (action === 'enable') {
     const results = installer.enable({});
     const updated = results.some((item) => item.updated);
     process.stdout.write(updated ? 'FuzzRun enabled. Restart your shell to apply changes.\n' : 'FuzzRun already enabled.\n');
+    updateState({ disabled: false, enableSucceeded: true });
     process.exit(0);
   }
   if (action === 'disable') {
     const results = installer.disable();
     const updated = results.some((item) => item.updated);
     process.stdout.write(updated ? 'FuzzRun disabled. Restart your shell to apply changes.\n' : 'FuzzRun already disabled.\n');
+    updateState({ disabled: true });
     process.exit(0);
   }
   if (action === 'status') {
-    const results = installer.status();
-    for (const item of results) {
-      process.stdout.write(`${item.enabled ? 'enabled' : 'disabled'}: ${item.path}\n`);
-    }
-    process.exit(0);
-  }
-
-  if (process.env.FUZZRUN_SKIP_ENABLE !== '1') {
+    const results = installer.status();
+    for (const item of results) {
+      process.stdout.write(`${item.enabled ? 'enabled' : 'disabled'}: ${item.path}\n`);
+    }
+    process.exit(0);
+  }
+
+  const state = readState() || {};
+  if (!state.disabled && process.env.FUZZRUN_SKIP_ENABLE !== '1') {
     try {
       const status = installer.status();
       const anyEnabled = status.some((item) => item.enabled);
       if (!anyEnabled) {
         const results = installer.enable({});
         const updated = results.some((item) => item.updated);
-        if (updated) {
-          process.stdout.write('FuzzRun auto-enabled. Restart your shell to apply changes.\n');
-        }
-      }
-    } catch (err) {
-      process.stderr.write(`fuzzrun: auto-enable failed: ${err.message}\n`);
-    }
-  }
-
-  let baseCommand = argv[0];
-  const rest = argv.slice(1);
-  baseCommand = normalizePowerShellGetPrefix(baseCommand);
-  const firstRun = run(baseCommand, rest);
-
-  if (firstRun.error && firstRun.error.code === 'ENOENT') {
-    const corrected = tryBaseCorrection(baseCommand, rest);
-    if (corrected) {
-      const { result } = corrected;
-      if (result.code !== 0) {
-        const combinedOutput = `${result.stderr}\n${result.stdout}`;
-        const correctedSub = trySubcommandCorrection(corrected.command, corrected.args, combinedOutput);
-        if (correctedSub) {
-          process.stdout.write(correctedSub.stdout);
-          process.stderr.write(correctedSub.stderr);
-          process.exit(correctedSub.code);
-        }
-        const correctedScript = tryScriptCorrection(corrected.command, corrected.args, combinedOutput);
-        if (correctedScript) {
-          process.stdout.write(correctedScript.stdout);
-          process.stderr.write(correctedScript.stderr);
-          process.exit(correctedScript.code);
-        }
-        const correctedBranch = tryGitBranchCorrection(corrected.command, corrected.args, combinedOutput);
-        if (correctedBranch) {
-          process.stdout.write(correctedBranch.stdout);
-          process.stderr.write(correctedBranch.stderr);
-          process.exit(correctedBranch.code);
-        }
-      }
-      process.stdout.write(result.stdout);
-      process.stderr.write(result.stderr);
-      process.exit(result.code);
-    }
-    process.stderr.write(firstRun.error.message ? `${firstRun.error.message}\n` : `fuzzrun: command not found: ${baseCommand}\n`);
-    process.exit(firstRun.code);
-  }
+        if (updated) {
+          process.stdout.write('FuzzRun auto-enabled. Restart your shell to apply changes.\n');
+        }
+      }
+    } catch (err) {
+      process.stderr.write(`fuzzrun: auto-enable failed: ${err.message}\n`);
+    }
+  }
 
-  if (firstRun.code === 0) {
-    process.stdout.write(firstRun.stdout);
-    process.stderr.write(firstRun.stderr);
-    process.exit(0);
-  }
-
-  const combinedOutput = `${firstRun.stderr}\n${firstRun.stdout}`;
-  const correctedSub = trySubcommandCorrection(baseCommand, rest, combinedOutput);
-  if (correctedSub) {
-    process.stdout.write(correctedSub.stdout);
-    process.stderr.write(correctedSub.stderr);
-    process.exit(correctedSub.code);
-  }
-
-  const correctedScript = tryScriptCorrection(baseCommand, rest, combinedOutput);
-  if (correctedScript) {
-    process.stdout.write(correctedScript.stdout);
-    process.stderr.write(correctedScript.stderr);
-    process.exit(correctedScript.code);
-  }
-
-  const correctedBranch = tryGitBranchCorrection(baseCommand, rest, combinedOutput);
-  if (correctedBranch) {
-    process.stdout.write(correctedBranch.stdout);
-    process.stderr.write(correctedBranch.stderr);
-    process.exit(correctedBranch.code);
-  }
-
-  process.stdout.write(firstRun.stdout);
-  process.stderr.write(firstRun.stderr);
-  process.exit(firstRun.code);
-}
+  let baseCommand = argv[0];
+  const rest = argv.slice(1);
+  baseCommand = normalizePowerShellGetPrefix(baseCommand);
+  const firstRun = run(baseCommand, rest);
 
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main };
+  if (firstRun.error && firstRun.error.code === 'ENOENT') {
+    const corrected = tryBaseCorrection(baseCommand, rest);
+    if (corrected) {
+      const { result } = corrected;
+      if (result.code !== 0) {
+        const combinedOutput = `${result.stderr}\n${result.stdout}`;
+        const correctedSub = trySubcommandCorrection(corrected.command, corrected.args, combinedOutput);
+        if (correctedSub) {
+          process.stdout.write(correctedSub.stdout);
+          process.stderr.write(correctedSub.stderr);
+          process.exit(correctedSub.code);
+        }
+        const correctedScript = tryScriptCorrection(corrected.command, corrected.args, combinedOutput);
+        if (correctedScript) {
+          process.stdout.write(correctedScript.stdout);
+          process.stderr.write(correctedScript.stderr);
+          process.exit(correctedScript.code);
+        }
+        const correctedBranch = tryGitBranchCorrection(corrected.command, corrected.args, combinedOutput);
+        if (correctedBranch) {
+          process.stdout.write(correctedBranch.stdout);
+          process.stderr.write(correctedBranch.stderr);
+          process.exit(correctedBranch.code);
+        }
+      }
+      process.stdout.write(result.stdout);
+      process.stderr.write(result.stderr);
+      process.exit(result.code);
+    }
+    process.stderr.write(firstRun.error.message ? `${firstRun.error.message}\n` : `fuzzrun: command not found: ${baseCommand}\n`);
+    process.exit(firstRun.code);
+  }
+
+  if (firstRun.code === 0) {
+    process.stdout.write(firstRun.stdout);
+    process.stderr.write(firstRun.stderr);
+    process.exit(0);
+  }
+
+  const combinedOutput = `${firstRun.stderr}\n${firstRun.stdout}`;
+  const correctedSub = trySubcommandCorrection(baseCommand, rest, combinedOutput);
+  if (correctedSub) {
+    process.stdout.write(correctedSub.stdout);
+    process.stderr.write(correctedSub.stderr);
+    process.exit(correctedSub.code);
+  }
+
+  const correctedScript = tryScriptCorrection(baseCommand, rest, combinedOutput);
+  if (correctedScript) {
+    process.stdout.write(correctedScript.stdout);
+    process.stderr.write(correctedScript.stderr);
+    process.exit(correctedScript.code);
+  }
+
+  const correctedBranch = tryGitBranchCorrection(baseCommand, rest, combinedOutput);
+  if (correctedBranch) {
+    process.stdout.write(correctedBranch.stdout);
+    process.stderr.write(correctedBranch.stderr);
+    process.exit(correctedBranch.code);
+  }
+
+  process.stdout.write(firstRun.stdout);
+  process.stderr.write(firstRun.stderr);
+  process.exit(firstRun.code);
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { main };