wizard-central-toolkit 0.2.0__py3-none-any.whl

wiz_central_toolkit/rustwiz/lib/rust_wizard.py

@@ -0,0 +1,128 @@
+"""rust-wizard: honest Rust validator. No tracebacks, verdicts only."""
+import subprocess
+import tempfile
+from pathlib import Path
+
+LAW_TEXT = """RUST LAW (Rust Wizard, the honest validator)
+1. The Rust Wizard judges Rust; it never writes it. Verdicts only.
+2. Every verdict comes from the real toolchain (rustc, cargo).
+   No toolchain, no verdict: a plain message, exit 2.
+3. fmt speaks in --check: it reports drift, it never reformats.
+4. clean is the one delete the Rust Wizard performs: a crate's
+   own target/ directory, and nothing else, ever.
+5. Mortal and stateless: one command, one verdict, then death.
+"""
+
+
+def package_version():
+    try:
+        from importlib import metadata
+        for _n in ("wizard-central-toolkit", "wiz-central-toolkit"):
+            try:
+                return metadata.version(_n)
+            except metadata.PackageNotFoundError:
+                continue
+    except Exception:
+        pass
+    try:
+        from wiz_central_toolkit import __version__
+        return __version__
+    except Exception:
+        return "unknown"
+
+
+class RustWizard:
+    NAME = "rustwiz"
+
+    def check(self, targets):
+        files = []
+        for target in targets:
+            t = Path(target).expanduser()
+            if t.is_dir():
+                files.extend(sorted(t.rglob("*.rs")))
+            elif t.suffix == ".rs" and t.is_file():
+                files.append(t)
+            else:
+                print(f"out of scope - not a .rs file or directory: {target}")
+                return 2
+        if not files:
+            print("[FAIL] no .rs files found")
+            return 1
+        bad = 0
+        for f in files:
+            with tempfile.TemporaryDirectory() as tmp:
+                try:
+                    r = subprocess.run(
+                        ["rustc", "--edition", "2021", "-A", "warnings",
+                         "--crate-type", "lib", "--emit=metadata",
+                         "--out-dir", tmp, str(f)],
+                        capture_output=True, text=True, timeout=120)
+                except (FileNotFoundError, OSError):
+                    print("[FAIL] rustc not found — install Rust to use rust_wizard check")
+                    return 2
+            if r.returncode == 0:
+                print(f"[OK]   {f}")
+            else:
+                bad += 1
+                print(f"[FAIL] {f}")
+                first = (r.stderr or "").strip().splitlines()
+                for line in first[:5]:
+                    print(f"       {line}")
+        print(f"{len(files) - bad}/{len(files)} valid, {bad} invalid")
+        return 1 if bad else 0
+
+    def _cargo(self, crate_dir, args, verb, show_stdout=False):
+        """Run one cargo verb against a crate. One verdict shape for all."""
+        d = Path(crate_dir).expanduser()
+        if not (d / "Cargo.toml").is_file():
+            print(f"[FAIL] no Cargo.toml in {d}")
+            return 1
+        try:
+            r = subprocess.run(["cargo"] + args, cwd=str(d),
+                               capture_output=True, text=True, timeout=600)
+        except (FileNotFoundError, OSError):
+            print(f"[FAIL] cargo not found — install Rust to use rust_wizard {verb}")
+            return 2
+        if r.returncode == 0:
+            print(f"[OK]   cargo {args[0]} passed: {d}")
+            return 0
+        print(f"[FAIL] cargo {args[0]} failed: {d}")
+        stream = (r.stdout if show_stdout else r.stderr) or ""
+        for line in stream.strip().splitlines()[:8]:
+            print(f"       {line}")
+        return 1
+
+    def build(self, crate_dir):
+        return self._cargo(crate_dir, ["check", "--quiet"], "build")
+
+    def test(self, crate_dir):
+        return self._cargo(crate_dir, ["test", "--quiet"], "test")
+
+    def clippy(self, crate_dir):
+        return self._cargo(crate_dir, ["clippy", "--quiet"], "clippy")
+
+    def doc(self, crate_dir):
+        return self._cargo(crate_dir, ["doc", "--no-deps"], "doc")
+
+    def fmt(self, crate_dir):
+        # --check only: fmt reports drift, it never reformats (RUST LAW 3).
+        return self._cargo(crate_dir, ["fmt", "--check"], "fmt",
+                           show_stdout=True)
+
+    def clean(self, crate_dir):
+        # The one delete (RUST LAW 4): cargo clean removes target/ only.
+        return self._cargo(crate_dir, ["clean"], "clean")
+
+    def run(self, crate_dir):
+        d = Path(crate_dir).expanduser()
+        if not (d / "Cargo.toml").is_file():
+            print(f"[FAIL] no Cargo.toml in {d}")
+            return 1
+        try:
+            # No capture: the program's own output belongs on the terminal.
+            r = subprocess.run(["cargo", "run", "--quiet"], cwd=str(d),
+                               timeout=600)
+        except (FileNotFoundError, OSError):
+            print("[FAIL] cargo not found — install Rust to use rust_wizard run")
+            return 2
+        return r.returncode

wiz_central_toolkit/tmuxwiz/__main__.py

@@ -0,0 +1,15 @@
+"""Entry point for tmuxwiz dispatch."""
+import sys
+from .lib import cli as internal_cli
+
+def main(argv=None):
+    old_argv = sys.argv
+    if argv is not None:
+        sys.argv = [sys.argv[0]] + list(argv)
+    try:
+        return internal_cli.main()
+    finally:
+        sys.argv = old_argv
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/tmuxwiz/cli.py

@@ -0,0 +1,7 @@
+"""cli.py - entry module for tmuxwiz (contains main())."""
+import sys
+
+from tmux_wizard import main
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

wiz_central_toolkit/tmuxwiz/lib/__init__.py

@@ -0,0 +1 @@
+# wizard package init

wiz_central_toolkit/tmuxwiz/lib/cli.py

@@ -0,0 +1,10 @@
+"""cli.py - entry module for tmuxwiz."""
+import sys
+from .tmux_wizard import main as tmux_main
+
+def main():
+    """CLI entry point - wraps tmux_main with sys.argv."""
+    return tmux_main(sys.argv[1:])
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/tmuxwiz/lib/tmux_wizard.py

@@ -0,0 +1,229 @@
+import sys
+"""tmux_wizard - sovereign tmux session manager (stdlib only)."""
+import subprocess
+
+SUBCOMMANDS = ("new", "attach", "kill", "list", "census", "rename",
+               "capture", "detach", "law", "version")
+
+LAW_TEXT = """TMUX LAW (Tmux Wizard, the session keeper)
+1. The Tmux Wizard manages sessions; the truth about them comes
+   from tmux itself, never from memory or invention.
+2. tmux is always called with an argument list, never through
+   a shell.
+3. capture reads a pane; it changes nothing.
+4. detach frees the client; the session and its work keep
+   running.
+5. kill is the only destroyer, and it names its session.
+"""
+
+
+def package_version():
+    try:
+        from importlib import metadata
+        for _n in ("wizard-central-toolkit", "wiz-central-toolkit"):
+            try:
+                return metadata.version(_n)
+            except metadata.PackageNotFoundError:
+                continue
+    except Exception:
+        pass
+    try:
+        from wiz_central_toolkit import __version__
+        return __version__
+    except Exception:
+        return "unknown"
+
+
+def _run(args):
+    """Run tmux with an arg list. Never shell=True (injection law)."""
+    try:
+        proc = subprocess.run(
+            ["tmux"] + args, capture_output=True, text=True, timeout=10
+        )
+        return proc.returncode, proc.stdout.strip(), proc.stderr.strip()
+    except FileNotFoundError:
+        return 127, "", "tmux not installed"
+    except subprocess.TimeoutExpired:
+        return 124, "", "tmux timed out"
+
+
+def _sessions():
+    """Live session names. Ground truth from tmux itself, zero fabrication."""
+    rc, out, _ = _run(["ls", "-F", "#{session_name}"])
+    if rc != 0:
+        return []
+    return [line for line in out.splitlines() if line]
+
+
+def cmd_new(name, start_dir):
+    if not name or "/" in name or ":" in name:
+        print("[FAIL] invalid session name")
+        return 1
+    if name in _sessions():
+        print("[FAIL] session '%s' already exists" % name)
+        return 1
+    rc, _, err = _run(["new-session", "-d", "-s", name, "-c", start_dir])
+    if rc == 0:
+        print("[OK] session '%s' created" % name)
+    else:
+        print("[FAIL] %s" % err)
+    return rc
+
+
+def cmd_attach(name):
+    if name not in _sessions():
+        print("[FAIL] no session '%s'" % name)
+        return 1
+    rc, _, err = _run(["attach-session", "-t", name])
+    if rc == 0:
+        print("[OK] attached to '%s'" % name)
+    else:
+        print("[FAIL] attach to '%s' failed%s" % (name, (": " + err) if err else ""))
+    return rc
+
+
+def cmd_kill(name):
+    if name not in _sessions():
+        print("[FAIL] no session '%s'" % name)
+        return 1
+    rc, _, _ = _run(["kill-session", "-t", name])
+    print("[OK] session '%s' killed" % name if rc == 0 else "[FAIL] kill failed")
+    return rc
+
+
+def cmd_list():
+    sessions = _sessions()
+    if not sessions:
+        print("no sessions running")
+        return 0
+    for s in sessions:
+        print(s)
+    return 0
+
+
+def cmd_census():
+    """Fleet-style census: every session, window count, attach state."""
+    sessions = _sessions()
+    total = len(sessions)
+    print("sessions total: %d" % total)
+    ok = 0
+    for s in sessions:
+        rc, out, _ = _run(
+            ["list-windows", "-t", s, "-F", "#{window_index}:#{window_name}"]
+        )
+        windows = out.splitlines() if rc == 0 else []
+        rc2, out2, _ = _run(["display-message", "-p", "-t", s, "#{session_attached}"])
+        attached = "ATTACHED" if out2 == "1" else "detached"
+        print("%s %-20s windows=%2d %s" % ("[OK]" if rc == 0 else "[FAIL]", s, len(windows), attached))
+        if rc == 0:
+            ok += 1
+    print("census verdict: %d/%d healthy" % (ok, total))
+    return 0 if ok == total else 1
+
+
+def cmd_capture(name, lines=200):
+    if name not in _sessions():
+        print("[FAIL] no session '%s'" % name)
+        return 1
+    rc, out, err = _run(["capture-pane", "-t", name, "-p", "-S", "-%d" % lines])
+    if rc == 0:
+        print(out)
+    else:
+        print("[FAIL] capture from '%s' failed%s" % (name, (": " + err) if err else ""))
+    return rc
+
+
+def cmd_detach(name):
+    if name not in _sessions():
+        print("[FAIL] no session '%s'" % name)
+        return 1
+    rc, _, err = _run(["detach-client", "-s", name])
+    if rc == 0:
+        print("[OK] clients detached from '%s' (session keeps running)" % name)
+    else:
+        print("[FAIL] detach from '%s' failed%s" % (name, (": " + err) if err else ""))
+    return rc
+
+
+def cmd_rename(old, new):
+    if old not in _sessions():
+        print("[FAIL] no session '%s'" % old)
+        return 1
+    if not new or "/" in new or ":" in new:
+        print("[FAIL] invalid new name")
+        return 1
+    rc, _, err = _run(["rename-session", "-t", old, new])
+    print("[OK] '%s' -> '%s'" % (old, new) if rc == 0 else "[FAIL] %s" % err)
+    return rc
+
+
+def main(argv):
+    if not argv or argv[0] in ("-h", "--help", "help"):
+        print("Tmux Wizard — sovereign tmux session manager")
+        print("alias: tmuxwiz")
+        print("usage: tmux_wizard <new|attach|kill|list|census|rename|capture|detach|law|version> [args]")
+        print("  new <name> [dir]    create session (default cwd)")
+        print("  attach <name>       join session")
+        print("  kill <name>         destroy session")
+        print("  list                names of live sessions")
+        print("  census              health of every session")
+        print("  rename <old> <new>  rename session")
+        print("  capture <name> [lines]  print a pane's recent output (read-only)")
+        print("  detach <name>       detach clients; the session keeps running")
+        print("  law                 print the TMUX LAW alone")
+        print("  version             print the version")
+        return 0
+    cmd, rest = argv[0], argv[1:]
+    if cmd == "law":
+        print(LAW_TEXT)
+        return 0
+    if cmd == "version":
+        print("tmux_wizard %s" % package_version())
+        return 0
+    if cmd not in SUBCOMMANDS:
+        print("out of scope - unknown command: %s" % cmd)
+        return 2
+    if cmd == "new":
+        if not rest:
+            print("[FAIL] new requires a session name")
+            return 2
+        return cmd_new(rest[0], rest[1] if len(rest) > 1 else ".")
+    if cmd == "attach":
+        if not rest:
+            print("[FAIL] attach requires a name")
+            return 2
+        return cmd_attach(rest[0])
+    if cmd == "kill":
+        if not rest:
+            print("[FAIL] kill requires a name")
+            return 2
+        return cmd_kill(rest[0])
+    if cmd == "rename":
+        if len(rest) < 2:
+            print("[FAIL] rename requires old and new names")
+            return 2
+        return cmd_rename(rest[0], rest[1])
+    if cmd == "capture":
+        if not rest:
+            print("[FAIL] capture requires a session name")
+            return 2
+        lines = 200
+        if len(rest) > 1:
+            try:
+                lines = int(rest[1])
+            except ValueError:
+                print("[FAIL] capture lines must be a number")
+                return 2
+        return cmd_capture(rest[0], lines)
+    if cmd == "detach":
+        if not rest:
+            print("[FAIL] detach requires a name")
+            return 2
+        return cmd_detach(rest[0])
+    if cmd == "list":
+        return cmd_list()
+    return cmd_census()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(__import__("sys").argv[1:]))

wiz_central_toolkit/todowiz/__main__.py

@@ -0,0 +1,22 @@
+"""Entry point for wiz dispatch."""
+import sys
+from .lib import cli as internal_cli
+from .lib.todo_wizard import TodoWizard  # noqa: F401 (re-exported for tests)
+
+# Wrap main() to accept argv (wiz dispatcher calls main(args))
+def main(argv=None):
+    # Save original sys.argv
+    old_argv = sys.argv
+    # Replace with provided argv (or empty list)
+    if argv is not None:
+        sys.argv = [sys.argv[0]] + list(argv)
+    try:
+        return internal_cli.main()
+    finally:
+        sys.argv = old_argv
+
+# Also expose for module-level access
+__all__ = ['main', 'TodoWizard']
+
+if __name__ == "__main__":
+    sys.exit(main())

wiz_central_toolkit/todowiz/cli.py

@@ -0,0 +1,4 @@
+"""todowiz CLI entry point; the implementation lives in lib/cli.py."""
+from .lib.cli import main
+
+__all__ = ["main"]

wiz_central_toolkit/todowiz/lib/__init__.py

@@ -0,0 +1 @@
+# wizard package init

wiz_central_toolkit/todowiz/lib/cli.py

@@ -0,0 +1,82 @@
+"""todo-wizard CLI front-end."""
+import sys
+import json
+from .todo_wizard import TodoWizard
+
+def main() -> int:
+    args = sys.argv[1:]
+    if not args or args[0] in ("-h", "--help", "help"):
+        print("Todo Wizard — standalone todo wizard")
+        print("alias: todowiz")
+        print("usage: todo_wizard <command> [args]")
+        print("  add <text>            add a task (default priority normal)")
+        print("  list                  list all tasks")
+        print("  done <id>            complete a task")
+        print("  undo <id>            reopen a completed task")
+        print("  note <id> <text>     append a progress note to a task")
+        print("  oldest               show the stalest pending task")
+        print("  overdue [days]       pending tasks older than N days (default 7)")
+        print("  archive-done         move completed tasks to archive")
+        print("  rm <id>              remove a task")
+        print("  stats                JSON summary")
+        print("  export               full JSON dump")
+        return 0
+
+    wiz = TodoWizard()
+    cmd = args[0]
+
+    if cmd == "add":
+        text = " ".join(args[1:]) or "untitled"
+        item = wiz.add(text)
+        print(f"[+] #{item['id']} {item['text']}")
+    elif cmd == "list":
+        for t in wiz.list_todos():
+            mark = "x" if t["done"] else " "
+            n_notes = len(t.get("notes", []))
+            suffix = f" [{n_notes} notes]" if n_notes else ""
+            print(f"[{mark}] #{t['id']} ({t['priority']}) {t['text']}{suffix}")
+    elif cmd == "done":
+        ok = wiz.complete(int(args[1]))
+        print("[OK] completed" if ok else "[FAIL] not found or already done")
+        return 0 if ok else 1
+    elif cmd == "undo":
+        ok = wiz.undo_complete(int(args[1]))
+        print("[OK] reopened" if ok else "[FAIL] not found or not done")
+        return 0 if ok else 1
+    elif cmd == "note":
+        if len(args) < 3:
+            print("out of scope - note requires id and text")
+            return 2
+        ok = wiz.note(int(args[1]), " ".join(args[2:]))
+        print("[OK] noted" if ok else "[FAIL] no such task")
+        return 0 if ok else 1
+    elif cmd == "oldest":
+        t = wiz.oldest()
+        if t is None:
+            print("no pending tasks")
+        else:
+            print(f"#{t['id']} {t['text']} (created {t['created']})")
+    elif cmd == "overdue":
+        days = int(args[1]) if len(args) > 1 else 7
+        results = wiz.overdue(days)
+        if not results:
+            print(f"no pending tasks older than {days} days")
+        else:
+            for t, age in results:
+                print(f"#{t['id']} {t['text']} — {age:.1f} days old (created {t['created']})")
+        return 1 if results else 0
+    elif cmd == "archive-done":
+        moved = wiz.archive_done()
+        print("[OK] archived %d completed tasks" % moved if moved else "no completed tasks to archive")
+    elif cmd == "rm":
+        ok = wiz.remove(int(args[1]))
+        print("[OK] removed" if ok else "[FAIL] not found")
+        return 0 if ok else 1
+    elif cmd == "stats":
+        print(json.dumps(wiz.stats()))
+    elif cmd == "export":
+        print(json.dumps(wiz.list_todos(), indent=2))
+    else:
+        print("out of scope")
+        return 2
+    return 0

wiz_central_toolkit/todowiz/lib/todo_wizard.py

@@ -0,0 +1,134 @@
+"""todo-wizard core: standalone, importable todo engine."""
+import json
+import hashlib
+import datetime as dt
+from pathlib import Path
+from typing import Optional
+
+class TodoWizard:
+    """Per-project persistent todo engine. Storage lives in ~/.todo-wizard/."""
+
+    BANK = Path.home() / ".todo-wizard"
+
+    def __init__(self, project_dir: Optional[str] = None, bank: Optional[Path] = None):
+        self.project = Path(project_dir or Path.cwd()).resolve()
+        self.bank = bank or self.BANK
+        self.store_path = self._store_for(self.project)
+
+    def _store_for(self, path: Path) -> Path:
+        key = hashlib.sha256(str(path).encode()).hexdigest()[:16]
+        return self.bank / f"{path.name}-{key}.json"
+
+    def _load(self) -> dict:
+        if self.store_path.exists():
+            return json.loads(self.store_path.read_text())
+        return {"project": str(self.project), "todos": [], "created": self._now()}
+
+    def _save(self, data: dict) -> None:
+        self.bank.mkdir(parents=True, exist_ok=True)
+        tmp = self.store_path.with_suffix(".tmp")
+        tmp.write_text(json.dumps(data, indent=2))
+        tmp.replace(self.store_path)
+
+    @staticmethod
+    def _now() -> str:
+        return dt.datetime.now().isoformat(timespec="seconds")
+
+    def add(self, text: str, priority: str = "normal") -> dict:
+        data = self._load()
+        item = {
+            "id": max((t["id"] for t in data["todos"] + data.get("archive", [])), default=0) + 1,
+            "text": text,
+            "priority": priority,
+            "done": False,
+            "created": self._now(),
+            "completed": None,
+        }
+        data["todos"].append(item)
+        data["last_modified"] = self._now()
+        self._save(data)
+        return item
+
+    def complete(self, todo_id: int) -> bool:
+        data = self._load()
+        for item in data["todos"]:
+            if item["id"] == todo_id and not item["done"]:
+                item["done"] = True
+                item["completed"] = self._now()
+                self._save(data)
+                return True
+        return False
+
+    def remove(self, todo_id: int) -> bool:
+        data = self._load()
+        before = len(data["todos"])
+        data["todos"] = [t for t in data["todos"] if t["id"] != todo_id]
+        if len(data["todos"]) < before:
+            self._save(data)
+            return True
+        return False
+
+    def list_todos(self, pending_only: bool = False) -> list:
+        todos = self._load()["todos"]
+        return [t for t in todos if not t["done"]] if pending_only else todos
+
+    def stats(self) -> dict:
+        todos = self.list_todos()
+        done = sum(1 for t in todos if t["done"])
+        return {"total": len(todos), "done": done, "pending": len(todos) - done}
+
+    def undo_complete(self, todo_id: int) -> bool:
+        """Reopen a closed task."""
+        data = self._load()
+        for item in data["todos"]:
+            if item["id"] == todo_id and item["done"]:
+                item["done"] = False
+                item["completed"] = None
+                data["last_modified"] = self._now()
+                self._save(data)
+                return True
+        return False
+
+    def note(self, todo_id: int, text: str) -> bool:
+        """Append a progress note to a task (evidence trail)."""
+        data = self._load()
+        for item in data["todos"]:
+            if item["id"] == todo_id:
+                notes = item.setdefault("notes", [])
+                notes.append({"text": text, "at": self._now()})
+                data["last_modified"] = self._now()
+                self._save(data)
+                return True
+        return False
+
+    def oldest(self) -> Optional[dict]:
+        """Return the stalest pending task."""
+        pending = self.list_todos(pending_only=True)
+        if not pending:
+            return None
+        return min(pending, key=lambda t: t["created"])
+
+    def archive_done(self) -> int:
+        """Move completed tasks to the archive list (never destroy)."""
+        data = self._load()
+        done_items = [t for t in data["todos"] if t["done"]]
+        if not done_items:
+            return 0
+        archive = data.setdefault("archive", [])
+        archive.extend(done_items)
+        archive.sort(key=lambda t: t.get("completed") or "")
+        data["todos"] = [t for t in data["todos"] if not t["done"]]
+        data["last_modified"] = self._now()
+        self._save(data)
+        return len(done_items)
+
+    def overdue(self, days: int = 7) -> list:
+        """Pending tasks older than N days."""
+        cutoff = dt.datetime.now() - dt.timedelta(days=days)
+        result = []
+        for t in self.list_todos(pending_only=True):
+            created = dt.datetime.fromisoformat(t["created"])
+            age_days = (dt.datetime.now() - created).total_seconds() / 86400
+            if created < cutoff:
+                result.append((t, age_days))
+        return result