fuzzrunx 0.1.0 → 0.1.1

package/README.md

@@ -13,10 +13,15 @@ Install (npm):
 ```
 npm i -g fuzzrunx
 ```
-
-### Bash/Zsh hook (auto-run on typos)
-
-Add to your shell rc:
+
+On global install, FuzzRun auto-enables shell hooks and will print:
+`FuzzRun is automatically enabled. Run "fuzzrun disable" to deactivate.`
+
+If you want to skip auto-enable, set `FUZZRUN_SKIP_ENABLE=1` during install.
+
+### Bash/Zsh hook (auto-run on typos)
+
+Add to your shell rc:
 
 ```bash
 FUZZRUN_BIN="/absolute/path/to/bin/fuzzrun.js"
@@ -38,8 +43,13 @@ $ExecutionContext.InvokeCommand.CommandNotFoundAction = {
     param($commandName, $eventArgs)
     fuzzrun $commandName @($eventArgs.Arguments)
 }
-function global:git { fuzzrun git @args } # optional git wrapper
-```
+function global:git { fuzzrun git @args } # optional git wrapper
+```
+
+### Manage hooks
+- `fuzzrun enable` (add hooks to your shell profile)
+- `fuzzrun disable` (remove hooks)
+- `fuzzrun status` (show which profiles are enabled)
 
 ### How it works
 - Runs the command once; if it fails with "command not found" or "unknown subcommand", tries a one-edit-away fix or the CLI's own suggestion and re-runs automatically.

package/package.json

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

package/scripts/postinstall.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const installer = require('../src/installer');
+
+const skip = process.env.FUZZRUN_SKIP_ENABLE === '1';
+const isGlobal = process.env.npm_config_global === 'true' || process.env.npm_config_global === '1';
+
+if (skip || !isGlobal) {
+  process.stdout.write('fuzzrun: auto-enable skipped\n');
+  process.exit(0);
+}
+
+try {
+  installer.enable({});
+  process.stdout.write('FuzzRun is automatically enabled. Run "fuzzrun disable" to deactivate.\n');
+} catch (err) {
+  process.stdout.write(`fuzzrun: auto-enable failed: ${err.message}\n`);
+}

package/src/cli.js

@@ -6,6 +6,7 @@
 const { spawnSync } = require('child_process');
 const fs = require('fs');
 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))
@@ -444,12 +445,33 @@ function main() {
   const argv = process.argv.slice(2);
   if (!argv.length) {
     process.stderr.write('Usage: fuzzrun <command> [args...]\n');
-    process.exit(1);
-  }
-
-  const baseCommand = argv[0];
-  const rest = argv.slice(1);
-  const firstRun = run(baseCommand, rest);
+    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);
+  }
+
+  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);

package/src/installer.js

@@ -0,0 +1,138 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MARKER_START = '# >>> fuzzrun start';
+const MARKER_END = '# <<< fuzzrun end';
+
+const WRAP_BASES = ['git', 'npm', 'yarn', 'pnpm', 'pip', 'docker', 'kubectl', 'gh'];
+
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+const BLOCK_REGEX = new RegExp(`${escapeRegex(MARKER_START)}[\\s\\S]*?${escapeRegex(MARKER_END)}\\s*`, 'g');
+
+function getPackageRoot(explicitRoot) {
+  if (explicitRoot) return explicitRoot;
+  return path.resolve(__dirname, '..');
+}
+
+function getBinPath(packageRoot) {
+  return path.resolve(packageRoot, 'bin', 'fuzzrun.js');
+}
+
+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')
+    ];
+  }
+  return [path.join(home, '.bashrc'), path.join(home, '.zshrc')];
+}
+
+function ensureDir(filePath) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
+function stripBlock(content) {
+  return content.replace(BLOCK_REGEX, '').trimEnd();
+}
+
+function buildPowerShellSnippet(binPath) {
+  const lines = [
+    MARKER_START,
+    `$fuzzrun = "${binPath}"`,
+    'function global:fuzzrun { node $fuzzrun @args }',
+    '$ExecutionContext.InvokeCommand.CommandNotFoundAction = {',
+    '    param($commandName, $eventArgs)',
+    '    fuzzrun $commandName @($eventArgs.Arguments)',
+    '}'
+  ];
+  for (const base of WRAP_BASES) {
+    lines.push(`function global:${base} { fuzzrun ${base} @args }`);
+  }
+  lines.push(MARKER_END, '');
+  return lines.join('\n');
+}
+
+function buildUnixSnippet(binPath) {
+  const lines = [
+    MARKER_START,
+    `FUZZRUN_BIN="${binPath}"`,
+    'fuzzrun() { node "$FUZZRUN_BIN" "$@"; }',
+    'command_not_found_handle() { fuzzrun "$@"; }',
+    'command_not_found_handler() { fuzzrun "$@"; }'
+  ];
+  for (const base of WRAP_BASES) {
+    lines.push(`${base}() { fuzzrun ${base} "$@"; }`);
+  }
+  lines.push(MARKER_END, '');
+  return lines.join('\n');
+}
+
+function updateProfile(filePath, snippet) {
+  const exists = fs.existsSync(filePath);
+  const content = exists ? fs.readFileSync(filePath, 'utf8') : '';
+  const cleaned = stripBlock(content);
+  const spacer = cleaned.length ? '\n\n' : '';
+  const nextContent = `${cleaned}${spacer}${snippet}`;
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, nextContent, 'utf8');
+  return { updated: content !== nextContent, path: filePath };
+}
+
+function removeProfileSnippet(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return { updated: false, path: filePath };
+  }
+  const content = fs.readFileSync(filePath, 'utf8');
+  const cleaned = stripBlock(content);
+  if (cleaned === content) {
+    return { updated: false, path: filePath };
+  }
+  ensureDir(filePath);
+  fs.writeFileSync(filePath, cleaned ? `${cleaned}\n` : '', 'utf8');
+  return { updated: true, path: filePath };
+}
+
+function pickTargets() {
+  const targets = getProfileTargets();
+  const existing = targets.filter((target) => fs.existsSync(target));
+  if (existing.length) return existing;
+  return [targets[0]];
+}
+
+function enable({ packageRoot } = {}) {
+  const root = getPackageRoot(packageRoot);
+  const binPath = getBinPath(root);
+  const targets = pickTargets();
+  const snippet = process.platform === 'win32' ? buildPowerShellSnippet(binPath) : buildUnixSnippet(binPath);
+  return targets.map((target) => updateProfile(target, snippet));
+}
+
+function disable() {
+  const targets = getProfileTargets().filter((target) => fs.existsSync(target));
+  return targets.map((target) => removeProfileSnippet(target));
+}
+
+function status() {
+  const targets = getProfileTargets();
+  return targets.map((target) => {
+    if (!fs.existsSync(target)) {
+      return { path: target, enabled: false };
+    }
+    const content = fs.readFileSync(target, 'utf8');
+    return { path: target, enabled: content.includes(MARKER_START) && content.includes(MARKER_END) };
+  });
+}
+
+module.exports = {
+  enable,
+  disable,
+  status
+};