Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /DansiDanutz_MyWork-AI /tools /task_runner.py
| #!/usr/bin/env python3 | |
| """MyWork Task Runner — Universal project task discovery and execution. | |
| Usage: | |
| mw run List all discovered tasks | |
| mw run <task> Run a named task | |
| mw run <task> -- <args> Run task with extra arguments | |
| mw run add <name> <cmd> Add a custom mw task | |
| mw run rm <name> Remove a custom mw task | |
| Discovers tasks from: | |
| - mw.tasks.json (custom MyWork tasks) | |
| - package.json scripts | |
| - Makefile targets | |
| - pyproject.toml [tool.taskipy.tasks] or [project.scripts] | |
| - Cargo.toml (build/run/test/bench) | |
| - Procfile entries | |
| Tasks are displayed with source labels and can be run from any directory. | |
| """ | |
| import json | |
| import os | |
| import re | |
| import subprocess | |
| import sys | |
| from collections import OrderedDict | |
| from pathlib import Path | |
| from typing import Dict, List, Optional, Tuple | |
| class Colors: | |
| GREEN = "\033[92m" | |
| RED = "\033[91m" | |
| YELLOW = "\033[93m" | |
| BLUE = "\033[94m" | |
| CYAN = "\033[96m" | |
| MAGENTA = "\033[95m" | |
| BOLD = "\033[1m" | |
| DIM = "\033[2m" | |
| ENDC = "\033[0m" | |
| TASKS_FILE = "mw.tasks.json" | |
| def _find_project_root() -> Path: | |
| """Walk up to find project root.""" | |
| cwd = Path.cwd() | |
| markers = ["package.json", "pyproject.toml", "Cargo.toml", "Makefile", "mw.tasks.json", ".git"] | |
| for p in [cwd] + list(cwd.parents): | |
| if any((p / m).exists() for m in markers): | |
| return p | |
| if p == p.parent: | |
| break | |
| return cwd | |
| def _discover_mw_tasks(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover tasks from mw.tasks.json. Returns {name: (command, source)}.""" | |
| tasks = {} | |
| tf = root / TASKS_FILE | |
| if tf.exists(): | |
| try: | |
| data = json.loads(tf.read_text()) | |
| for name, entry in data.items(): | |
| if isinstance(entry, str): | |
| tasks[name] = (entry, "mw") | |
| elif isinstance(entry, dict): | |
| tasks[name] = (entry.get("cmd", entry.get("command", "")), "mw") | |
| except (json.JSONDecodeError, AttributeError): | |
| pass | |
| return tasks | |
| def _discover_npm_scripts(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover from package.json scripts.""" | |
| tasks = {} | |
| pj = root / "package.json" | |
| if pj.exists(): | |
| try: | |
| data = json.loads(pj.read_text()) | |
| for name, cmd in data.get("scripts", {}).items(): | |
| tasks[f"npm:{name}"] = (f"npm run {name}", "npm") | |
| except (json.JSONDecodeError, AttributeError): | |
| pass | |
| return tasks | |
| def _discover_makefile(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover from Makefile.""" | |
| tasks = {} | |
| mf = root / "Makefile" | |
| if mf.exists(): | |
| content = mf.read_text() | |
| for match in re.finditer(r'^([a-zA-Z_][\w-]*)\s*:', content, re.MULTILINE): | |
| target = match.group(1) | |
| if target not in ("PHONY", "FORCE", "SHELL"): | |
| tasks[f"make:{target}"] = (f"make {target}", "make") | |
| return tasks | |
| def _discover_pyproject(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover from pyproject.toml (taskipy or scripts).""" | |
| tasks = {} | |
| pp = root / "pyproject.toml" | |
| if pp.exists(): | |
| content = pp.read_text() | |
| # Simple TOML parser for [tool.taskipy.tasks] | |
| in_taskipy = False | |
| for line in content.split("\n"): | |
| if "[tool.taskipy.tasks]" in line: | |
| in_taskipy = True | |
| continue | |
| if in_taskipy: | |
| if line.startswith("["): | |
| break | |
| m = re.match(r'(\w+)\s*=\s*"(.+)"', line.strip()) | |
| if m: | |
| tasks[f"py:{m.group(1)}"] = (m.group(2), "taskipy") | |
| # [project.scripts] | |
| in_scripts = False | |
| for line in content.split("\n"): | |
| if "[project.scripts]" in line: | |
| in_scripts = True | |
| continue | |
| if in_scripts: | |
| if line.startswith("["): | |
| break | |
| m = re.match(r'(\w[\w-]*)\s*=\s*"(.+)"', line.strip()) | |
| if m: | |
| tasks[f"py:{m.group(1)}"] = (m.group(2), "pyproject") | |
| return tasks | |
| def _discover_cargo(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover Cargo tasks.""" | |
| tasks = {} | |
| if (root / "Cargo.toml").exists(): | |
| for cmd in ["build", "run", "test", "bench", "check", "clippy"]: | |
| tasks[f"cargo:{cmd}"] = (f"cargo {cmd}", "cargo") | |
| return tasks | |
| def _discover_procfile(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover from Procfile.""" | |
| tasks = {} | |
| pf = root / "Procfile" | |
| if pf.exists(): | |
| for line in pf.read_text().strip().split("\n"): | |
| if ":" in line: | |
| name, cmd = line.split(":", 1) | |
| tasks[f"proc:{name.strip()}"] = (cmd.strip(), "procfile") | |
| return tasks | |
| def _discover_all(root: Path) -> Dict[str, Tuple[str, str]]: | |
| """Discover all tasks, mw tasks take priority.""" | |
| all_tasks = OrderedDict() | |
| # Priority order: mw > npm > make > pyproject > cargo > procfile | |
| for discoverer in [_discover_mw_tasks, _discover_npm_scripts, _discover_makefile, | |
| _discover_pyproject, _discover_cargo, _discover_procfile]: | |
| all_tasks.update(discoverer(root)) | |
| return all_tasks | |
| def _list_tasks(root: Path) -> int: | |
| """List all discovered tasks.""" | |
| tasks = _discover_all(root) | |
| if not tasks: | |
| print(f"\n{Colors.YELLOW}No tasks found.{Colors.ENDC}") | |
| print(f" Create one: {Colors.GREEN}mw run add dev \"npm run dev\"{Colors.ENDC}") | |
| print(f" Or add scripts to package.json, Makefile, etc.") | |
| return 0 | |
| # Group by source | |
| sources = OrderedDict() | |
| for name, (cmd, source) in tasks.items(): | |
| sources.setdefault(source, []).append((name, cmd)) | |
| source_colors = { | |
| "mw": Colors.GREEN, "npm": Colors.RED, "make": Colors.BLUE, | |
| "taskipy": Colors.YELLOW, "pyproject": Colors.YELLOW, | |
| "cargo": Colors.MAGENTA, "procfile": Colors.CYAN, | |
| } | |
| print(f"\n{Colors.BOLD}⚡ Available Tasks{Colors.ENDC} ({len(tasks)} total)") | |
| print(f"{'─' * 60}") | |
| for source, items in sources.items(): | |
| color = source_colors.get(source, Colors.DIM) | |
| print(f"\n {color}[{source}]{Colors.ENDC}") | |
| for name, cmd in items: | |
| # Show short name (strip prefix if it matches source) | |
| display = name.split(":", 1)[-1] if ":" in name else name | |
| truncated = cmd[:45] + "…" if len(cmd) > 45 else cmd | |
| print(f" {Colors.BOLD}{display:<20}{Colors.ENDC} {Colors.DIM}{truncated}{Colors.ENDC}") | |
| print(f"\n Run: {Colors.GREEN}mw run <task>{Colors.ENDC}") | |
| print() | |
| return 0 | |
| def _run_task(name: str, extra_args: List[str], root: Path) -> int: | |
| """Run a specific task.""" | |
| tasks = _discover_all(root) | |
| # Exact match | |
| if name in tasks: | |
| cmd, source = tasks[name] | |
| else: | |
| # Try without prefix | |
| matches = [(k, v) for k, v in tasks.items() if k.split(":", 1)[-1] == name or k == name] | |
| if len(matches) == 1: | |
| cmd, source = matches[0][1] | |
| name = matches[0][0] | |
| elif len(matches) > 1: | |
| print(f"{Colors.YELLOW}⚠️ Ambiguous task '{name}'. Did you mean:{Colors.ENDC}") | |
| for k, (c, s) in matches: | |
| print(f" {Colors.GREEN}{k}{Colors.ENDC} → {c}") | |
| return 1 | |
| else: | |
| print(f"{Colors.RED}❌ Task '{name}' not found.{Colors.ENDC}") | |
| print(f" Run {Colors.GREEN}mw run{Colors.ENDC} to see available tasks.") | |
| return 1 | |
| if extra_args: | |
| cmd = f"{cmd} {' '.join(extra_args)}" | |
| source_emoji = {"mw": "⚡", "npm": "📦", "make": "🔨", "cargo": "🦀", "procfile": "🔧"}.get(source, "▶️") | |
| print(f"{source_emoji} Running {Colors.CYAN}{name}{Colors.ENDC} → {Colors.DIM}{cmd}{Colors.ENDC}\n") | |
| try: | |
| result = subprocess.run(cmd, shell=True, cwd=str(root)) | |
| return result.returncode | |
| except KeyboardInterrupt: | |
| print(f"\n{Colors.YELLOW}Interrupted.{Colors.ENDC}") | |
| return 130 | |
| def _add_task(name: str, cmd: str, root: Path) -> int: | |
| """Add a custom mw task.""" | |
| tf = root / TASKS_FILE | |
| data = {} | |
| if tf.exists(): | |
| try: | |
| data = json.loads(tf.read_text()) | |
| except json.JSONDecodeError: | |
| pass | |
| data[name] = cmd | |
| tf.write_text(json.dumps(data, indent=2) + "\n") | |
| print(f"{Colors.GREEN}✅ Added task:{Colors.ENDC} {Colors.BOLD}{name}{Colors.ENDC} → {cmd}") | |
| return 0 | |
| def _rm_task(name: str, root: Path) -> int: | |
| """Remove a custom mw task.""" | |
| tf = root / TASKS_FILE | |
| if not tf.exists(): | |
| print(f"{Colors.RED}❌ No mw.tasks.json found{Colors.ENDC}") | |
| return 1 | |
| data = json.loads(tf.read_text()) | |
| if name not in data: | |
| print(f"{Colors.RED}❌ Task '{name}' not found{Colors.ENDC}") | |
| return 1 | |
| del data[name] | |
| tf.write_text(json.dumps(data, indent=2) + "\n") | |
| print(f"{Colors.GREEN}✅ Removed task: {name}{Colors.ENDC}") | |
| return 0 | |
| def cmd_run(args: List[str] = None) -> int: | |
| """Main entry for mw run.""" | |
| args = args or [] | |
| root = _find_project_root() | |
| if not args or args[0] in ("-h", "--help", "help"): | |
| return _list_tasks(root) | |
| if args[0] == "add": | |
| if len(args) < 3: | |
| print(f"{Colors.RED}❌ Usage: mw run add <name> <command>{Colors.ENDC}") | |
| return 1 | |
| return _add_task(args[1], " ".join(args[2:]), root) | |
| if args[0] == "rm": | |
| if len(args) < 2: | |
| print(f"{Colors.RED}❌ Usage: mw run rm <name>{Colors.ENDC}") | |
| return 1 | |
| return _rm_task(args[1], root) | |
| # Split on -- for extra args | |
| task_name = args[0] | |
| extra = [] | |
| if "--" in args: | |
| idx = args.index("--") | |
| extra = args[idx + 1:] | |
| return _run_task(task_name, extra, root) | |
| if __name__ == "__main__": | |
| sys.exit(cmd_run(sys.argv[1:])) | |
Xet Storage Details
- Size:
- 10.1 kB
- Xet hash:
- 288460eca51edefd9792aed13d7e3557e2030f77414217adf1dae48293c6a850
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.