Buckets:

download
raw
11.4 kB
#!/usr/bin/env python3
"""
mw watch — Smart File Watcher with Auto-Test
=============================================
Watches project files and automatically runs relevant tests when changes are detected.
Usage:
mw watch Watch current directory, auto-run tests
mw watch --test-cmd "pytest" Override test command
mw watch --dir src/ Watch specific directory
mw watch --lint Also run linting on changes
mw watch --build Also run build on changes
mw watch --debounce 500 Debounce delay in ms (default: 300)
"""
import os
import sys
import time
import subprocess
import hashlib
import argparse
from pathlib import Path
from datetime import datetime
from typing import Dict, Set, Optional, List
# ANSI colors
BOLD = "\033[1m"
DIM = "\033[2m"
RED = "\033[91m"
GREEN = "\033[92m"
YELLOW = "\033[93m"
BLUE = "\033[94m"
CYAN = "\033[96m"
RESET = "\033[0m"
CLEAR_LINE = "\033[2K\r"
# File extensions to watch by language
WATCH_PATTERNS = {
"python": {".py"},
"javascript": {".js", ".jsx", ".ts", ".tsx"},
"rust": {".rs"},
"go": {".go"},
"ruby": {".rb"},
"java": {".java"},
"css": {".css", ".scss", ".less"},
"html": {".html", ".htm"},
}
# Test commands by detection
TEST_COMMANDS = {
"pytest.ini": "python -m pytest -x --tb=short",
"pyproject.toml": "python -m pytest -x --tb=short",
"setup.py": "python -m pytest -x --tb=short",
"package.json": "npm test",
"Cargo.toml": "cargo test",
"go.mod": "go test ./...",
"Gemfile": "bundle exec rspec",
"Makefile": "make test",
}
LINT_COMMANDS = {
"pyproject.toml": "python -m ruff check --fix",
".flake8": "python -m flake8",
"package.json": "npm run lint",
"Cargo.toml": "cargo clippy",
".eslintrc.json": "npx eslint --fix",
".eslintrc.js": "npx eslint --fix",
}
BUILD_COMMANDS = {
"package.json": "npm run build",
"Cargo.toml": "cargo build",
"go.mod": "go build ./...",
"Makefile": "make build",
"pyproject.toml": "python -m build",
}
def detect_project_type(directory: str) -> str:
"""Detect project type from config files."""
for marker, _ in TEST_COMMANDS.items():
if os.path.exists(os.path.join(directory, marker)):
return marker
return ""
def detect_test_command(directory: str) -> str:
"""Auto-detect the test command."""
for marker, cmd in TEST_COMMANDS.items():
if os.path.exists(os.path.join(directory, marker)):
return cmd
return ""
def detect_lint_command(directory: str) -> str:
"""Auto-detect the lint command."""
for marker, cmd in LINT_COMMANDS.items():
if os.path.exists(os.path.join(directory, marker)):
return cmd
return ""
def detect_build_command(directory: str) -> str:
"""Auto-detect the build command."""
for marker, cmd in BUILD_COMMANDS.items():
if os.path.exists(os.path.join(directory, marker)):
return cmd
return ""
def get_watchable_extensions(directory: str) -> Set[str]:
"""Determine which file extensions to watch."""
extensions = set()
for lang, exts in WATCH_PATTERNS.items():
for ext in exts:
# Check if any files with this extension exist
for root, _, files in os.walk(directory):
if any(skip in root for skip in ["node_modules", ".git", "__pycache__", "dist", "build", ".venv", "venv"]):
continue
if any(f.endswith(ext) for f in files):
extensions.update(exts)
break
return extensions if extensions else {".py", ".js", ".ts", ".tsx", ".jsx"}
def get_file_hash(filepath: str) -> str:
"""Get MD5 hash of file contents."""
try:
with open(filepath, "rb") as f:
return hashlib.md5(f.read()).hexdigest()
except (OSError, IOError):
return ""
def scan_files(directory: str, extensions: Set[str]) -> Dict[str, str]:
"""Scan directory and return {filepath: hash} dict."""
files = {}
skip_dirs = {"node_modules", ".git", "__pycache__", "dist", "build", ".venv", "venv", ".next", ".cache", "coverage"}
for root, dirs, filenames in os.walk(directory):
dirs[:] = [d for d in dirs if d not in skip_dirs]
for fname in filenames:
if any(fname.endswith(ext) for ext in extensions):
fpath = os.path.join(root, fname)
files[fpath] = get_file_hash(fpath)
return files
def find_related_test(changed_file: str, directory: str) -> Optional[str]:
"""Find test file related to a changed source file."""
basename = Path(changed_file).stem
parent = Path(changed_file).parent
# Common test file patterns
test_patterns = [
f"test_{basename}.py",
f"{basename}_test.py",
f"{basename}.test.ts",
f"{basename}.test.tsx",
f"{basename}.test.js",
f"{basename}.test.jsx",
f"{basename}.spec.ts",
f"{basename}.spec.tsx",
f"{basename}.spec.js",
]
# Check in same directory
for pattern in test_patterns:
test_path = parent / pattern
if test_path.exists():
return str(test_path)
# Check in tests/ or __tests__/ directory
for test_dir in ["tests", "__tests__", "test", "spec"]:
for pattern in test_patterns:
test_path = Path(directory) / test_dir / pattern
if test_path.exists():
return str(test_path)
return None
def run_command(cmd: str, label: str, directory: str) -> bool:
"""Run a shell command and return success status."""
print(f"\n{CYAN}▶ {label}:{RESET} {DIM}{cmd}{RESET}")
start = time.time()
result = subprocess.run(
cmd, shell=True, cwd=directory,
capture_output=False,
timeout=120
)
elapsed = time.time() - start
if result.returncode == 0:
print(f"{GREEN}✓ {label} passed{RESET} {DIM}({elapsed:.1f}s){RESET}")
return True
else:
print(f"{RED}✗ {label} failed{RESET} {DIM}({elapsed:.1f}s){RESET}")
return False
def print_banner(directory: str, test_cmd: str, extensions: Set[str], lint: bool, build: bool):
"""Print startup banner."""
print(f"\n{BOLD}{CYAN}🔍 mw watch — Smart File Watcher{RESET}")
print(f"{'─' * 50}")
print(f" {DIM}Directory:{RESET} {directory}")
print(f" {DIM}Test cmd:{RESET} {test_cmd or '(none detected)'}")
print(f" {DIM}Watching:{RESET} {', '.join(sorted(extensions))}")
if lint:
print(f" {DIM}Lint:{RESET} enabled")
if build:
print(f" {DIM}Build:{RESET} enabled")
print(f"{'─' * 50}")
print(f" {DIM}Press Ctrl+C to stop{RESET}\n")
def main(args: List[str] = None) -> int:
parser = argparse.ArgumentParser(description="Smart file watcher with auto-test")
parser.add_argument("--test-cmd", help="Override test command")
parser.add_argument("--dir", default=".", help="Directory to watch")
parser.add_argument("--lint", action="store_true", help="Also run linter")
parser.add_argument("--build", action="store_true", help="Also run build")
parser.add_argument("--debounce", type=int, default=300, help="Debounce delay in ms")
parser.add_argument("--focused", action="store_true", help="Only run related test file")
opts = parser.parse_args(args or [])
directory = os.path.abspath(opts.dir)
if not os.path.isdir(directory):
print(f"{RED}Error: {directory} is not a directory{RESET}")
return 1
extensions = get_watchable_extensions(directory)
test_cmd = opts.test_cmd or detect_test_command(directory)
lint_cmd = detect_lint_command(directory) if opts.lint else ""
build_cmd = detect_build_command(directory) if opts.build else ""
print_banner(directory, test_cmd, extensions, opts.lint, opts.build)
# Initial scan
prev_state = scan_files(directory, extensions)
run_count = 0
pass_count = 0
fail_count = 0
debounce_s = opts.debounce / 1000.0
try:
while True:
time.sleep(debounce_s)
current_state = scan_files(directory, extensions)
# Find changes
changed = []
for fpath, fhash in current_state.items():
if fpath not in prev_state or prev_state[fpath] != fhash:
changed.append(fpath)
# Check for deleted files
deleted = set(prev_state.keys()) - set(current_state.keys())
if changed or deleted:
run_count += 1
now = datetime.now().strftime("%H:%M:%S")
# Show what changed
for f in changed:
rel = os.path.relpath(f, directory)
status = "modified" if f in prev_state else "created"
print(f"{YELLOW}● {now}{RESET} {status}: {BOLD}{rel}{RESET}")
for f in deleted:
rel = os.path.relpath(f, directory)
print(f"{RED}● {now}{RESET} deleted: {BOLD}{rel}{RESET}")
all_passed = True
# Run lint if enabled
if lint_cmd:
if not run_command(lint_cmd, "Lint", directory):
all_passed = False
# Run tests
if test_cmd:
if opts.focused and len(changed) == 1:
related = find_related_test(changed[0], directory)
if related:
focused_cmd = f"{test_cmd.split()[0]} {related}"
if not run_command(focused_cmd, "Test (focused)", directory):
all_passed = False
else:
if not run_command(test_cmd, "Test", directory):
all_passed = False
else:
if not run_command(test_cmd, "Test", directory):
all_passed = False
# Run build if enabled
if build_cmd:
if not run_command(build_cmd, "Build", directory):
all_passed = False
if all_passed:
pass_count += 1
print(f"\n{GREEN}{'━' * 40}")
print(f" ✅ All checks passed (run #{run_count})")
print(f"{'━' * 40}{RESET}\n")
else:
fail_count += 1
print(f"\n{RED}{'━' * 40}")
print(f" ❌ Some checks failed (run #{run_count})")
print(f"{'━' * 40}{RESET}\n")
prev_state = current_state
else:
prev_state = current_state
except KeyboardInterrupt:
print(f"\n\n{CYAN}📊 Session Summary{RESET}")
print(f" Runs: {run_count} | ✅ {pass_count} | ❌ {fail_count}")
print(f" {DIM}Goodbye!{RESET}\n")
return 0
if __name__ == "__main__":
sys.exit(main())

Xet Storage Details

Size:
11.4 kB
·
Xet hash:
add6b73c3edcd259b8c7e0062c72ae64289ad22aee9a753048219d6cc389d862

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.