fuzzrunx 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuzzrunx",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Auto-correct mistyped commands and subcommands and re-run them safely.",
   "bin": {
     "fuzzrun": "bin/fuzzrun.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/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,41 +208,79 @@ 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 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;
+function readState() {
+  try {
+    const raw = fs.readFileSync(getStatePath(), 'utf8');
+    return JSON.parse(raw);
+  } catch (err) {
+    return null;
   }
-  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 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 dp[aNorm.length][bNorm.length];
 }
+
+function showInstallBannerOnce() {
+  const state = readState() || {};
+  if (state.bannerShown) 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;
+  }
+  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();
@@ -275,33 +314,46 @@ function collectPathCommands() {
   return names;
 }
 
-const PATH_COMMANDS = collectPathCommands();
-
-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) {
@@ -326,121 +378,121 @@ function run(cmd, args) {
   };
 }
 
-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) {
@@ -448,115 +500,118 @@ function main() {
     process.exit(1);
   }
 
-  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');
-    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');
-    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') {
-    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`);
-    }
-  }
+  showInstallBannerOnce();
 
-  const baseCommand = argv[0];
-  const rest = argv.slice(1);
-  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);
-  }
+  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');
+    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');
+    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 (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 (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`);
+    }
+  }
 
-if (require.main === module) {
-  main();
-}
-
-module.exports = { main };
+  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 (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 };

package/src/installer.js

@@ -58,15 +58,64 @@ function buildPowerShellSnippet(binPath) {
   const lines = [
     MARKER_START,
     `$fuzzrun = "${binPath}"`,
+    '$global:FuzzRunLastLine = $null',
+    'if (Get-Module -ListAvailable -Name PSReadLine) {',
+    '    try {',
+    '        Import-Module PSReadLine -ErrorAction SilentlyContinue | Out-Null',
+    '        Set-PSReadLineKeyHandler -Key Enter -ScriptBlock {',
+    '            param($key, $arg)',
+    '            $line = $null',
+    '            $cursor = $null',
+    '            [Microsoft.PowerShell.PSConsoleReadLine]::GetBufferState([ref]$line, [ref]$cursor)',
+    '            $global:FuzzRunLastLine = $line',
+    '            [Microsoft.PowerShell.PSConsoleReadLine]::AcceptLine()',
+    '        }',
+    '    } catch {}',
+    '}',
     'function global:fuzzrun { node $fuzzrun @args }',
     '$ExecutionContext.InvokeCommand.CommandNotFoundAction = {',
     '    param($commandName, $eventArgs)',
-    '    fuzzrun $commandName @($eventArgs.Arguments)',
+    '    $cmd = $commandName',
+    '    $fzArgs = @($eventArgs.Arguments)',
+    '    $line = $global:FuzzRunLastLine',
+    '    $global:FuzzRunLastLine = $null',
+    '    if (-not $line -and $eventArgs.CommandLine) {',
+    '        $line = $eventArgs.CommandLine',
+    '    }',
+    '    if (-not $line -and $eventArgs.CommandScriptBlock) {',
+    '        $line = $eventArgs.CommandScriptBlock.ToString()',
+    '    }',
+    '    if (-not $line) {',
+    '        $history = Get-History -Count 1 -ErrorAction SilentlyContinue',
+    '        if ($history) { $line = $history.CommandLine }',
+    '    }',
+    '    $argv = @()',
+    '    if ($line) {',
+    '        $tokens = [System.Management.Automation.PSParser]::Tokenize($line, [ref]$null)',
+    "        foreach ($token in $tokens) {",
+    "            if ($token.Type -in @('Command','CommandArgument','CommandParameter','String','Number')) {",
+    '                $argv += $token.Content',
+    '            }',
+    '        }',
+    '    }',
+    '    if ($argv.Count -gt 0) {',
+    '        $cmd = $argv[0]',
+    '    }',
+    '    if ($argv.Count -gt 1) {',
+    '        $fzArgs = $argv[1..($argv.Count - 1)]',
+    '    }',
+    '    $eventArgs.CommandScriptBlock = { fuzzrun $cmd @fzArgs }.GetNewClosure()',
+    '    $eventArgs.StopSearch = $true',
     '}'
   ];
-  for (const base of WRAP_BASES) {
-    lines.push(`function global:${base} { fuzzrun ${base} @args }`);
-  }
+  lines.push(`$__fuzzrunBases = @(${WRAP_BASES.map((base) => `'${base}'`).join(', ')})`);
+  lines.push('foreach ($base in $__fuzzrunBases) {');
+  lines.push('    $resolved = Get-Command $base -ErrorAction SilentlyContinue | Where-Object { $_.CommandType -eq "Application" } | Select-Object -First 1');
+  lines.push('    if ($resolved) {');
+  lines.push('        $cmdName = $base');
+  lines.push('        Set-Item -Path ("Function:$cmdName") -Value { fuzzrun $cmdName @args }.GetNewClosure()');
+  lines.push('    }');
+  lines.push('}');
   lines.push(MARKER_END, '');
   return lines.join('\n');
 }