@laphilosophia/steady-watch 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erdem Arslan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,87 @@
+# 🔭 Steady Watch
+
+> Intelligent file watcher with content hashing and debouncing. No more ghost rebuilds.
+
+[![npm version](https://img.shields.io/npm/v/@laphilosophia/steady-watch.svg)](https://www.npmjs.com/package/@laphilosophia/steady-watch)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## The Problem
+
+Standard file watchers trigger on every save, including:
+- Editor auto-saves that don't change content
+- IDE temp file operations
+- Multiple rapid saves
+
+This leads to unnecessary rebuilds, wasted CPU cycles, and noisy logs.
+
+## The Solution
+
+**Steady Watch** uses MD5 content hashing to detect *actual* changes. If the file content hasn't changed, no rebuild is triggered. Period.
+
+## Installation
+
+```bash
+npm install -g @laphilosophia/steady-watch
+```
+
+## Usage
+
+```bash
+steady-watch "src/**/*.ts" -c "npm run build"
+```
+
+Or use the short alias:
+
+```bash
+sw "src/**/*.ts" -c "npm run build"
+```
+
+### Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `-c, --cmd <command>` | Command to execute on change | *required* |
+| `-d, --delay <ms>` | Debounce delay in milliseconds | `300` |
+| `-v, --verbose` | Show hash calculations and file indexing | `false` |
+
+### Examples
+
+```bash
+# TypeScript build
+sw "src/**/*.ts" -c "npm run build"
+
+# Run tests on change
+sw "src/**/*.{ts,tsx}" -c "npm test" -d 500
+
+# Verbose mode to see what's happening
+sw "lib/**/*.js" -c "node build.js" -v
+```
+
+## Features
+
+- 🎯 **Content Hashing** — Only triggers when file content actually changes
+- ⏱️ **Debouncing** — Batches rapid changes into single rebuilds
+- 🚀 **Process Management** — Won't start new build while previous is running
+- 🚫 **Smart Ignores** — Auto-ignores `node_modules`, `.git`, `dist`, `build`
+- 🎨 **Pretty Output** — Color-coded, timestamped logs
+
+## Output Example
+
+```
+🔭 Steady Watch Initialized
+   Pattern: src/**/*.ts
+   Command: npm run build
+   Delay:   300ms
+
+👁️  Watcher ready. Monitoring for changes...
+   Tracking 12 file(s)
+
+[9:53:26 PM] ⚡ Change detected: index.ts
+[9:53:26 PM] 🚀 Triggering: npm run build
+[9:53:28 PM] ✔ Done in 2.14s
+────────────────────────────────────────
+```
+
+## License
+
+MIT © [Erdem Arslan](https://github.com/laphilosophia)

package/dist/index.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_chalk = __toESM(require("chalk"));
+var import_child_process = require("child_process");
+var import_chokidar = __toESM(require("chokidar"));
+var import_commander = require("commander");
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+import_commander.program.name("steady-watch").description("Intelligent file watcher with debouncing and content hashing.").argument("<files>", 'Glob pattern to watch (e.g., "src/**/*.ts")').requiredOption("-c, --cmd <command>", "Command to execute on change").option("-d, --delay <ms>", "Debounce delay in milliseconds", "300").option("-v, --verbose", "Show hash calculations", false).version("1.0.0").parse();
+var options = import_commander.program.opts();
+var args = import_commander.program.args;
+var filePattern = args[0];
+var command = options.cmd;
+var delay = parseInt(options.delay);
+var verbose = options.verbose;
+var timeout;
+var isRunning = false;
+var activeProcess = null;
+var fileHashes = /* @__PURE__ */ new Map();
+var getHash = (filePath) => {
+  try {
+    if (!import_fs.default.existsSync(filePath)) return null;
+    const content = import_fs.default.readFileSync(filePath);
+    return import_crypto.default.createHash("md5").update(content).digest("hex");
+  } catch (e) {
+    return null;
+  }
+};
+var timestamp = () => import_chalk.default.gray(`[${(/* @__PURE__ */ new Date()).toLocaleTimeString()}]`);
+var runCommand = () => {
+  if (isRunning) {
+    if (verbose) console.log(import_chalk.default.yellow("\u26A0\uFE0F  Previous command still running, skipping..."));
+    return;
+  }
+  isRunning = true;
+  console.log(`${timestamp()} ${import_chalk.default.cyan("\u{1F680} Triggering:")} ${import_chalk.default.bold(command)}`);
+  const [cmd, ...cmdArgs] = command.split(" ");
+  const startTime = Date.now();
+  activeProcess = (0, import_child_process.spawn)(cmd, cmdArgs, {
+    stdio: "inherit",
+    shell: true
+  });
+  activeProcess.on("close", (code) => {
+    isRunning = false;
+    activeProcess = null;
+    const duration = ((Date.now() - startTime) / 1e3).toFixed(2);
+    if (code === 0) {
+      console.log(`${timestamp()} ${import_chalk.default.green("\u2714 Done")} in ${duration}s`);
+    } else {
+      console.log(`${timestamp()} ${import_chalk.default.red("\u2718 Failed")} (Exit code: ${code})`);
+    }
+    console.log(import_chalk.default.dim("\u2500".repeat(40)));
+  });
+};
+console.log(import_chalk.default.bold.blue("\n\u{1F52D} Steady Watch Initialized"));
+console.log(`   ${import_chalk.default.dim("Pattern:")} ${filePattern}`);
+console.log(`   ${import_chalk.default.dim("Command:")} ${command}`);
+console.log(`   ${import_chalk.default.dim("Delay:")}   ${delay}ms
+`);
+var watcher = import_chokidar.default.watch(filePattern, {
+  ignored: [/node_modules/, /\.git/, /dist/, /build/],
+  ignoreInitial: false
+  // Başta dosyaları indexle
+});
+watcher.on("ready", () => {
+  console.log(import_chalk.default.green("\u{1F441}\uFE0F  Watcher ready. Monitoring for changes..."));
+  if (verbose) console.log(import_chalk.default.dim(`   Tracking ${fileHashes.size} file(s)`));
+});
+watcher.on("error", (error) => {
+  console.error(import_chalk.default.red("Watcher error:"), error);
+});
+watcher.on("add", (filePath) => {
+  const hash = getHash(filePath);
+  if (hash) fileHashes.set(filePath, hash);
+  if (verbose) console.log(import_chalk.default.dim(`Indexed: ${import_path.default.basename(filePath)}`));
+});
+watcher.on("change", (filePath) => {
+  const currentHash = getHash(filePath);
+  const lastHash = fileHashes.get(filePath);
+  if (currentHash === lastHash) {
+    if (verbose) console.log(import_chalk.default.gray(`Skipping ghost change: ${import_path.default.basename(filePath)}`));
+    return;
+  }
+  if (currentHash) {
+    fileHashes.set(filePath, currentHash);
+  }
+  clearTimeout(timeout);
+  timeout = setTimeout(() => {
+    console.log(`${timestamp()} ${import_chalk.default.yellow("\u26A1 Change detected:")} ${import_path.default.basename(filePath)}`);
+    runCommand();
+  }, delay);
+});
+watcher.on("unlink", (filePath) => {
+  fileHashes.delete(filePath);
+  if (verbose) console.log(import_chalk.default.dim(`Removed: ${import_path.default.basename(filePath)}`));
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@laphilosophia/steady-watch",
+  "version": "1.0.0",
+  "description": "Intelligent file watcher with content hashing and debouncing. No more ghost rebuilds.",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "bin": {
+    "steady-watch": "dist/index.js",
+    "sw": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "watch",
+    "watcher",
+    "file-watcher",
+    "build",
+    "dev",
+    "cli",
+    "debounce",
+    "hash",
+    "content-hash"
+  ],
+  "author": "Erdem Arslan",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/laphilosophia/steady-watch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/laphilosophia/steady-watch/issues"
+  },
+  "homepage": "https://github.com/laphilosophia/steady-watch#readme",
+  "type": "commonjs",
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "chokidar": "^3.6.0",
+    "commander": "^14.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.8",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  }
+}