fuzzrunx 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fuzzrunx",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Auto-correct mistyped commands and subcommands and re-run them safely.",
   "bin": {
     "fuzzrun": "bin/fuzzrun.js"

package/src/cli.js

@@ -211,6 +211,22 @@ function normalizeToken(value) {
   return String(value || '').toLowerCase();
 }
 
+function commandKey(command) {
+  const base = path.basename(String(command || ''));
+  const ext = path.extname(base);
+  return normalizeToken(ext ? base.slice(0, -ext.length) : base);
+}
+
+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;
+  }
+  return false;
+}
+
 function damerauLevenshtein(a, b, maxDistance = 2) {
   const aNorm = normalizeToken(a);
   const bNorm = normalizeToken(b);
@@ -276,6 +292,76 @@ function collectPathCommands() {
 }
 
 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;
@@ -313,18 +399,35 @@ function parseSuggestion(text) {
   return null;
 }
 
-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 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 logFix(from, to) {
   process.stderr.write(`fuzzrun: auto-correcting "${from}" -> "${to}"\n`);
@@ -485,8 +588,9 @@ function main() {
     }
   }
 
-  const baseCommand = argv[0];
+  let baseCommand = argv[0];
   const rest = argv.slice(1);
+  baseCommand = normalizePowerShellGetPrefix(baseCommand);
   const firstRun = run(baseCommand, rest);
 
   if (firstRun.error && firstRun.error.code === 'ENOENT') {

package/src/installer.js

@@ -27,10 +27,21 @@ function getBinPath(packageRoot) {
 function getProfileTargets() {
   const home = os.homedir();
   if (process.platform === 'win32') {
-    return [
-      path.join(home, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1'),
-      path.join(home, 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1')
-    ];
+    const roots = new Set([path.join(home, 'Documents')]);
+    const oneDriveRoots = [
+      process.env.OneDrive,
+      process.env.OneDriveConsumer,
+      process.env.OneDriveCommercial
+    ].filter(Boolean);
+    for (const root of oneDriveRoots) {
+      roots.add(path.basename(root).toLowerCase() === 'documents' ? root : path.join(root, 'Documents'));
+    }
+    const targets = [];
+    for (const root of roots) {
+      targets.push(path.join(root, 'PowerShell', 'Microsoft.PowerShell_profile.ps1'));
+      targets.push(path.join(root, 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1'));
+    }
+    return [...new Set(targets)];
   }
   return [path.join(home, '.bashrc'), path.join(home, '.zshrc')];
 }
@@ -47,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');
 }