@chengyixu/filewatch 1.0.0

package/index.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+const VERSION = '1.0.0';
+const NAME = '@chengyixu/filewatch';
+
+// Parse CLI args
+const args = process.argv.slice(2);
+
+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);
+}
+
+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);
+  }
+}
+
+// Parse structured args
+let watchDir = '.';
+let extensions = [];
+let ignorePatterns = [];
+let debounceMs = 300;
+let clearScreen = false;
+let quiet = false;
+let cmdParts = 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;
+    }
+  }
+}
+
+if (!cmdParts || cmdParts.length === 0) {
+  console.error('Error: No command specified. Use -- before the command.');
+  console.error('Example: filewatch -- node server.js');
+  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}`);
+  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)));
+
+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;
+}
+
+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 (clearScreen) {
+    process.stdout.write('\x1b[2J\x1b[H');
+  }
+
+  const now = new Date().toLocaleTimeString();
+  console.log(`\n[${now}] $ ${cmd} ${cmdArgs.join(' ')}`);
+
+  child = spawn(cmd, cmdArgs, {
+    stdio: 'inherit',
+    shell: true
+  });
+
+  child.on('exit', (code) => {
+    running = false;
+    if (code !== null && code !== 0) {
+      console.log(`[filewatch] Command exited with code ${code}`);
+    }
+  });
+
+  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;
+
+  clearTimeout(debounceTimer);
+  debounceTimer = setTimeout(runCommand, debounceMs);
+}
+
+// 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();
+
+// Start watching
+try {
+  if (watchIsFile) {
+    fs.watch(watchPath, onChange);
+  } else {
+    fs.watch(watchPath, { recursive: true }, onChange);
+  }
+} catch (err) {
+  // Fallback for platforms without recursive support
+  console.error(`[filewatch] Warning: ${err.message}`);
+  if (!watchIsFile) {
+    fs.watch(watchPath, onChange);
+  }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "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",
+  "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",
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chengyixu/filewatch"
+  }
+}