@chengyixu/filewatch 1.0.0 → 1.0.2

package/index.js

@@ -3,195 +3,172 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execSync } = require('child_process');
+const { spawn } = require('child_process');
 
-const VERSION = '1.0.0';
-const NAME = '@chengyixu/filewatch';
+// Usage
+const usage = `filewatch — watch files and run a command on changes
 
-// Parse CLI args
-const args = process.argv.slice(2);
+Usage:
+  filewatch [options] -- <command>
 
-if (args.includes('--help') || args.includes('-h')) {
-  console.log(`
-  ${NAME} v${VERSION}
-
-  Watch files/directories and run a command on change. (mini nodemon)
-
-  Usage:
-    filewatch [options] -- <command>
-    filewatch [options] <directory> -- <command>
-
-  Options:
-    --version, -v        Show version
-    --help, -h           Show this help
-    --dir, -d <path>     Directory or file to watch (default: .)
-    --ext, -e <exts>     Comma-separated extensions to watch (e.g. js,ts,json)
-    --ignore, -i <pat>   Ignore pattern (can repeat)
-    --debounce <ms>      Debounce delay in ms (default: 300)
-    --clear              Clear terminal before each run
-    --quiet, -q          Suppress startup message
-
-  Examples:
-    filewatch -- node server.js
-    filewatch -d src -e js,ts -- npm test
-    filewatch -d . -i node_modules -i .git -- make build
-    filewatch --debounce 500 --clear -- python main.py
-`);
-  process.exit(0);
-}
+Options:
+  -d, --dir <path>      Directory to watch (default: .)
+  -p, --pattern <glob>  File pattern to match (default: *.*)
+  -i, --ignore <dirs>   Comma-separated dirs to ignore (default: node_modules,.git)
+  -q, --quiet           Suppress startup message
+  -t, --throttle <ms>   Debounce in ms (default: 300)
+  -r, --restart         Kill and restart command on each change
+  -h, --help            Show this help
 
-if (args.includes('--version') || args.includes('-v')) {
-  // Filter out --version from args in case it's combined with other flags
-  const isVersionOnly = args.length === 1 || (args.length === 2 && (args.includes('--version') || args.includes('-v')));
-  if (isVersionOnly || args.indexOf('--version') === 0 || args.indexOf('-v') === 0) {
-    console.log(VERSION);
-    process.exit(0);
-  }
-}
+Examples:
+  filewatch -d src -- node test.js
+  filewatch -p '*.js' -i 'dist,coverage' -- npm test
+  filewatch -t 1000 -r -- make build`;
 
-// Parse structured args
-let watchDir = '.';
-let extensions = [];
-let ignorePatterns = [];
-let debounceMs = 300;
-let clearScreen = false;
+// Parse argv
+const args = process.argv.slice(2);
+let dir = '.';
+let pattern = '*.*';
+let ignore = ['node_modules', '.git', '.DS_Store'];
 let quiet = false;
-let cmdParts = null;
+let throttle = 300;
+let restart = false;
+let command = null;
 
 for (let i = 0; i < args.length; i++) {
-  const arg = args[i];
-  if (arg === '--') {
-    cmdParts = args.slice(i + 1);
-    break;
-  }
-  if (arg === '--dir' || arg === '-d') {
-    watchDir = args[++i];
-  } else if (arg === '--ext' || arg === '-e') {
-    extensions = args[++i].split(',').map(e => e.trim().replace(/^\./, ''));
-  } else if (arg === '--ignore' || arg === '-i') {
-    ignorePatterns.push(args[++i]);
-  } else if (arg === '--debounce') {
-    debounceMs = parseInt(args[++i], 10) || 300;
-  } else if (arg === '--clear') {
-    clearScreen = true;
-  } else if (arg === '--quiet' || arg === '-q') {
-    quiet = true;
-  } else if (!arg.startsWith('-')) {
-    // Positional arg: treat as directory if no --dir given
-    if (watchDir === '.' && i < args.indexOf('--')) {
-      watchDir = arg;
-    }
-  }
+  const a = args[i];
+  if (a === '-d' || a === '--dir') { dir = args[++i]; }
+  else if (a === '-p' || a === '--pattern') { pattern = args[++i]; }
+  else if (a === '-i' || a === '--ignore') { ignore = args[++i].split(',').map(s => s.trim()); }
+  else if (a === '-q' || a === '--quiet') { quiet = true; }
+  else if (a === '-t' || a === '--throttle') { throttle = parseInt(args[++i], 10); }
+  else if (a === '-r' || a === '--restart') { restart = true; }
+  else if (a === '-h' || a === '--help') { console.log(usage); process.exit(0); }
+  else if (a === '--') { command = args.slice(i + 1).join(' '); break; }
+  else if (!command && !a.startsWith('-')) { command = args.slice(i).join(' '); break; }
 }
 
-if (!cmdParts || cmdParts.length === 0) {
+if (!command) {
   console.error('Error: No command specified. Use -- before the command.');
-  console.error('Example: filewatch -- node server.js');
+  console.log(usage);
   process.exit(1);
 }
 
-const cmd = cmdParts[0];
-const cmdArgs = cmdParts.slice(1);
-
-// Resolve watch directory
-const watchPath = path.resolve(watchDir);
-if (!fs.existsSync(watchPath)) {
-  console.error(`Error: Path not found: ${watchPath}`);
+// Resolve dir
+const watchDir = path.resolve(dir);
+if (!fs.existsSync(watchDir)) {
+  console.error(`Error: Directory not found: ${watchDir}`);
+  process.exit(1);
+}
+if (!fs.statSync(watchDir).isDirectory()) {
+  console.error(`Error: Not a directory: ${watchDir}`);
   process.exit(1);
 }
 
-const stat = fs.statSync(watchPath);
-const watchIsFile = stat.isFile();
-
-// Build ignore set
-const ignoreSet = new Set(ignorePatterns.map(p => path.resolve(p)));
+// Glob match helper (simple — zero deps)
+function globMatch(filename, pattern) {
+  const re = new RegExp(
+    '^' + pattern.replace(/\./g, '\\.').replace(/\*/g, '.*').replace(/\?/g, '.') + '$'
+  );
+  return re.test(filename);
+}
 
-function shouldWatch(filePath) {
-  if (ignoreSet.has(path.resolve(filePath))) return false;
-  // Check if path contains any ignore pattern as substring
-  for (const ig of ignorePatterns) {
-    if (filePath.includes(ig)) return false;
-  }
-  if (extensions.length > 0) {
-    const ext = path.extname(filePath).replace(/^\./, '');
-    if (ext && !extensions.includes(ext)) return false;
-  }
-  return true;
+function isIgnored(filePath) {
+  const rel = path.relative(watchDir, filePath);
+  const parts = rel.split(path.sep);
+  return parts.some(p => ignore.includes(p));
 }
 
+// Debounce
+let timer = null;
+let pending = false;
 let child = null;
-let debounceTimer = null;
-let running = false;
 
 function runCommand() {
-  if (running) {
-    if (child) {
-      child.kill('SIGTERM');
-      // Give it a moment to die
-      try { child.kill('SIGKILL'); } catch (_) {}
-    }
-    // Re-schedule
-    debounceTimer = setTimeout(runCommand, debounceMs);
-    return;
-  }
-
-  running = true;
+  if (!restart && child) return; // don't re-run if not restart mode
 
-  if (clearScreen) {
-    process.stdout.write('\x1b[2J\x1b[H');
+  if (child) {
+    child.kill('SIGTERM');
+    child = null;
   }
 
-  const now = new Date().toLocaleTimeString();
-  console.log(`\n[${now}] $ ${cmd} ${cmdArgs.join(' ')}`);
+  const [cmd, ...cmdArgs] = command.split(/\s+/);
+  if (!quiet) {
+    const now = new Date().toLocaleTimeString();
+    process.stderr.write(`\x1b[36m[${now}]\x1b[0m running: \x1b[33m${command}\x1b[0m\n`);
+  }
 
   child = spawn(cmd, cmdArgs, {
     stdio: 'inherit',
-    shell: true
+    cwd: watchDir,
+    shell: true,
   });
 
   child.on('exit', (code) => {
-    running = false;
-    if (code !== null && code !== 0) {
-      console.log(`[filewatch] Command exited with code ${code}`);
+    child = null;
+    if (!quiet && code !== 0 && code !== null) {
+      process.stderr.write(`\x1b[31mCommand exited with code ${code}\x1b[0m\n`);
     }
   });
-
-  child.on('error', (err) => {
-    running = false;
-    console.error(`[filewatch] Failed to start: ${err.message}`);
-  });
 }
 
 function onChange(eventType, filename) {
   if (!filename) return;
-  const fullPath = path.join(watchPath, watchIsFile ? '' : filename);
-  if (!shouldWatch(fullPath)) return;
+  const fullPath = path.join(watchDir, filename);
 
-  clearTimeout(debounceTimer);
-  debounceTimer = setTimeout(runCommand, debounceMs);
-}
+  // Ignore check
+  if (isIgnored(fullPath)) return;
 
-// Initial run
-if (!quiet) {
-  console.log(`[filewatch] Watching: ${watchPath}`);
-  if (extensions.length) console.log(`[filewatch] Extensions: ${extensions.join(',')}`);
-  console.log(`[filewatch] Command: ${cmd} ${cmdArgs.join(' ')}`);
-  console.log(`[filewatch] Ready for changes...`);
-}
-
-runCommand();
+  // Pattern match
+  if (!globMatch(filename, pattern)) return;
 
-// Start watching
-try {
-  if (watchIsFile) {
-    fs.watch(watchPath, onChange);
+  if (throttle > 0) {
+    if (timer) clearTimeout(timer);
+    if (!pending) {
+      pending = true;
+      if (!quiet) process.stderr.write(`\x1b[2mChange detected: ${filename}\x1b[0m\n`);
+    }
+    timer = setTimeout(() => {
+      pending = false;
+      timer = null;
+      runCommand();
+    }, throttle);
   } else {
-    fs.watch(watchPath, { recursive: true }, onChange);
+    if (!quiet) process.stderr.write(`\x1b[2mChange detected: ${filename}\x1b[0m\n`);
+    runCommand();
+  }
+}
+
+// Watch recursively
+function watchRecursive(dirPath) {
+  try {
+    fs.watch(dirPath, { recursive: false }, onChange);
+  } catch (e) {
+    // Some OSes don't support recursive watch natively, fall back to manual
   }
-} catch (err) {
-  // Fallback for platforms without recursive support
-  console.error(`[filewatch] Warning: ${err.message}`);
-  if (!watchIsFile) {
-    fs.watch(watchPath, onChange);
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const full = path.join(dirPath, entry.name);
+      if (isIgnored(full)) continue;
+      watchRecursive(full);
+    }
+  } catch (e) {
+    // Permission errors, skip
   }
 }
+
+// Start
+if (!quiet) {
+  console.log(`\x1b[1mfilewatch\x1b[0m — watching \x1b[2m${watchDir}\x1b[0m`);
+  console.log(`  pattern: ${pattern}  |  ignore: ${ignore.join(',')}  |  throttle: ${throttle}ms`);
+  console.log(`  command: \x1b[33m${command}\x1b[0m\n`);
+}
+
+watchRecursive(watchDir);
+runCommand(); // Initial run
+
+// Keep alive
+process.stdin.resume();

package/package.json

@@ -1,30 +1,16 @@
 {
   "name": "@chengyixu/filewatch",
-  "version": "1.0.0",
-  "description": "Watch files/directories and run a command on change — a zero-dependency mini-nodemon",
-  "main": "index.js",
+  "version": "1.0.2",
+  "description": "Watch files and run a command on changes — zero dependencies",
+  "license": "MIT",
+  "author": "chengyixu",
+  "keywords": ["watch", "files", "monitor", "restart", "nodemon", "cli", "dev"],
   "bin": {
     "filewatch": "./index.js"
   },
-  "files": [
-    "index.js"
-  ],
-  "scripts": {
-    "test": "node test.js"
-  },
-  "keywords": [
-    "watch",
-    "filewatcher",
-    "nodemon",
-    "cli",
-    "file-watch",
-    "dev",
-    "zero-dependency"
-  ],
-  "author": "chengyixu",
-  "license": "MIT",
+  "files": ["index.js"],
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=14"
   },
   "repository": {
     "type": "git",