devmedic 0.2.0__py3-none-any.whl

devmedic/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

devmedic/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

devmedic/caches.py

@@ -0,0 +1,173 @@
+"""Global tool caches (pip, npm, cargo, …) plus system things like journald/apt/docker."""
+import os
+import re
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.table import Table
+
+from .util import (HOME, confirm, console, dir_size, have, human_size, remove_tree,
+                   run, short_path, size_style)
+
+h = lambda *p: os.path.join(HOME, *p)
+
+# key, label, path, clean command (None -> delete dir contents), note
+CACHES = [
+    ("pip",      "pip cache",            h(".cache", "pip"),          ["pip", "cache", "purge"], ""),
+    ("uv",       "uv cache",             h(".cache", "uv"),           ["uv", "cache", "clean"], ""),
+    ("npm",      "npm cache",            h(".npm", "_cacache"),       ["npm", "cache", "clean", "--force"], ""),
+    ("yarn",     "yarn cache",           h(".cache", "yarn"),         ["yarn", "cache", "clean"], ""),
+    ("pnpm",     "pnpm store",           h(".local", "share", "pnpm", "store"), ["pnpm", "store", "prune"], "prunes unused only"),
+    ("cargo",    "cargo registry",       h(".cargo", "registry"),     None, ""),
+    ("go",       "Go module cache",      h("go", "pkg", "mod"),       ["go", "clean", "-modcache"], ""),
+    ("gobuild",  "Go build cache",       h(".cache", "go-build"),     ["go", "clean", "-cache"], ""),
+    ("gradle",   "Gradle caches",        h(".gradle", "caches"),      None, ""),
+    ("maven",    "Maven repo",           h(".m2", "repository"),      None, ""),
+    ("hf",       "HuggingFace models",   h(".cache", "huggingface"),  None, "re-download is big!"),
+    ("thumbs",   "Thumbnails",           h(".cache", "thumbnails"),   None, ""),
+    ("trash",    "Trash",                h(".local", "share", "Trash"), None, "permanent!"),
+    ("vscode",   "VS Code cache",        h(".config", "Code", "Cache"), None, "close VS Code first"),
+    ("chrome",   "Chrome cache",         h(".cache", "google-chrome"), None, "close Chrome first"),
+    ("firefox",  "Firefox cache",        h(".cache", "mozilla"),      None, "close Firefox first"),
+]
+
+
+def journal_usage():
+    out = run(["journalctl", "--disk-usage"])
+    m = re.search(r"take up ([\d.]+)([KMGT])", out)
+    if not m:
+        return None
+    mult = {"K": 1024, "M": 1024**2, "G": 1024**3, "T": 1024**4}[m.group(2)]
+    return int(float(m.group(1)) * mult)
+
+
+def apt_usage():
+    path = "/var/cache/apt/archives"
+    return dir_size(path) if os.path.isdir(path) else None
+
+
+def snap_disabled():
+    """Old disabled snap revisions: list of (name, rev, bytes)."""
+    out = run(["snap", "list", "--all"]) if have("snap") else ""
+    res = []
+    for line in out.splitlines()[1:]:
+        cols = line.split()
+        if len(cols) >= 3 and "disabled" in line:
+            snap_file = f"/var/lib/snapd/snaps/{cols[0]}_{cols[2]}.snap"
+            try:
+                size = os.stat(snap_file).st_blocks * 512
+            except OSError:
+                size = 0
+            res.append((cols[0], cols[2], size))
+    return res
+
+
+def docker_usage():
+    """Reclaimable bytes from `docker system df`, or None if unavailable."""
+    if not have("docker"):
+        return None
+    out = run(["docker", "system", "df", "--format", "{{.Reclaimable}}"], timeout=20)
+    if not out.strip():
+        return None
+    total = 0
+    for line in out.splitlines():
+        m = re.match(r"([\d.]+)\s*([kKMGT]?B)", line.strip())
+        if m:
+            mult = {"B": 1, "kB": 1000, "KB": 1000, "MB": 1000**2,
+                    "GB": 1000**3, "TB": 1000**4}[m.group(2)]
+            total += int(float(m.group(1)) * mult)
+    return total
+
+
+def collect():
+    present = [c for c in CACHES if os.path.isdir(c[2])]
+    with ThreadPoolExecutor(max_workers=8) as pool:
+        sizes = list(pool.map(dir_size, [c[2] for c in present]))
+        j, a, d = pool.submit(journal_usage), pool.submit(apt_usage), pool.submit(docker_usage)
+        snaps = pool.submit(snap_disabled)
+    user = [{"key": c[0], "label": c[1], "path": c[2], "cmd": c[3], "note": c[4],
+             "size": s} for c, s in zip(present, sizes) if s > 0]
+    user.sort(key=lambda r: r["size"], reverse=True)
+    system = []
+    if j.result() and j.result() > 250 * 1024**2:
+        system.append({"key": "journal", "label": "systemd journal logs", "size": j.result(),
+                       "fix": "sudo journalctl --vacuum-size=200M"})
+    if a.result():
+        system.append({"key": "apt", "label": "apt package cache", "size": a.result(),
+                       "fix": "sudo apt clean && sudo apt autoremove --purge"})
+    if d.result():
+        system.append({"key": "docker", "label": "Docker (reclaimable)", "size": d.result(),
+                       "fix": "docker system prune  (add -a --volumes for everything)"})
+    if snaps.result():
+        cmds = "; ".join(f"sudo snap remove {n} --revision={r}" for n, r, _ in snaps.result())
+        system.append({"key": "snap", "label": f"Old snap revisions ({len(snaps.result())})",
+                       "size": sum(sz for *_, sz in snaps.result()) or None, "fix": cmds})
+    return user, system
+
+
+def show(user, system):
+    t = Table(title="Caches you can clean", title_justify="left")
+    t.add_column("Key", style="bold cyan")
+    t.add_column("Size", justify="right")
+    t.add_column("What")
+    t.add_column("Path", style="dim")
+    t.add_column("Note", style="yellow")
+    for r in user:
+        t.add_row(r["key"], f"[{size_style(r['size'])}]{human_size(r['size'])}[/]",
+                  r["label"], short_path(r["path"]), r["note"])
+    console.print(t)
+    total = sum(r["size"] for r in user)
+    console.print(f"[bold]{human_size(total)}[/] in user caches. "
+                  f"Clean with: [bold]devmedic caches --clean pip npm …[/] or [bold]--clean all[/]")
+    if system:
+        s = Table(title="System (needs sudo / docker)", title_justify="left")
+        s.add_column("Size", justify="right")
+        s.add_column("What")
+        s.add_column("Fix command", style="bold", overflow="fold")
+        for r in system:
+            size = f"[{size_style(r['size'])}]{human_size(r['size'])}[/]" if r["size"] else "—"
+            s.add_row(size, r["label"], r["fix"])
+        console.print(s)
+        console.print("[dim]devmedic never runs sudo itself — copy the command if you want it.[/]")
+
+
+def clean(user, keys, assume_yes=False):
+    by_key = {r["key"]: r for r in user}
+    if "all" in keys:
+        # 'all' deliberately excludes the ones with a warning note.
+        chosen = [r for r in user if not r["note"]]
+    else:
+        unknown = [k for k in keys if k not in by_key]
+        if unknown:
+            console.print(f"[red]Unknown / empty cache(s): {', '.join(unknown)}[/]. "
+                          f"Available: {', '.join(by_key) or 'none'}")
+        chosen = [by_key[k] for k in keys if k in by_key]
+    if not chosen:
+        return
+    total = sum(r["size"] for r in chosen)
+    for r in chosen:
+        console.print(f"  • {r['label']:<22} {human_size(r['size']):>10}"
+                      + (f"  [yellow]({r['note']})[/]" if r["note"] else ""))
+    if not confirm(f"Clean these ({human_size(total)})?", assume_yes):
+        return
+    for r in chosen:
+        ok = False
+        if r["cmd"] and have(r["cmd"][0]):
+            try:
+                ok = subprocess.run(r["cmd"], capture_output=True, timeout=300).returncode == 0
+            except (OSError, subprocess.SubprocessError):
+                ok = False
+        if not ok:
+            ok = all(remove_tree(e.path) if e.is_dir(follow_symlinks=False)
+                     else _unlink(e.path) for e in os.scandir(r["path"]))
+        after = dir_size(r["path"]) if os.path.isdir(r["path"]) else 0
+        mark = "[green]✔[/]" if ok else "[yellow]~[/]"
+        console.print(f"{mark} {r['label']}: freed {human_size(max(r['size'] - after, 0))}")
+
+
+def _unlink(path):
+    try:
+        os.unlink(path)
+        return True
+    except OSError:
+        return False

devmedic/cli.py

@@ -0,0 +1,152 @@
+"""devmedic — a health check for your developer machine."""
+import argparse
+import os
+import sys
+
+from . import __version__, caches, dashboard, junk, menu, ports, procs, repos
+from .util import console
+
+
+def cmd_overview(args):
+    # Interactive menu in a real terminal; full dashboard when piped/redirected.
+    if sys.stdin.isatty() and sys.stdout.isatty():
+        menu.run()
+    else:
+        dashboard.show()
+    return 0
+
+
+def cmd_all(args):
+    dashboard.show()
+    return 0
+
+
+def cmd_section(args):
+    menu.show_section(args.cmd)
+    return 0
+
+
+def cmd_watch(args):
+    dashboard.watch(args.interval)
+    return 0
+
+
+def cmd_ports(args):
+    ports.show(args.all)
+    return 0
+
+
+def cmd_kill(args):
+    return ports.kill(args.port, args.force, args.yes)
+
+
+def cmd_junk(args):
+    items = junk.scan(args.path, args.older)
+    junk.show(items, args.limit, args.path)
+    if args.clean:
+        junk.clean(items, args.yes, args.limit)
+    elif items:
+        console.print("[dim]Run again with --clean to pick folders to delete. "
+                      "--older 30 shows only projects untouched for 30 days.[/]")
+    return 0
+
+
+def cmd_caches(args):
+    user, system = caches.collect()
+    caches.show(user, system)
+    if args.clean:
+        console.print()
+        caches.clean(user, args.clean, args.yes)
+    return 0
+
+
+def cmd_repos(args):
+    repos.show(repos.scan(args.path), args.all, args.path)
+    return 0
+
+
+def cmd_procs(args):
+    procs.show(procs.collect(), args.verbose)
+    return 0
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="devmedic", description=__doc__)
+    p.add_argument("--version", action="version", version=f"devmedic {__version__}")
+    sub = p.add_subparsers(dest="cmd")
+
+    s = sub.add_parser("menu", help="interactive section picker (default)")
+    s.set_defaults(func=cmd_overview)
+
+    s = sub.add_parser("all", aliases=["check"], help="full dashboard on one screen")
+    s.set_defaults(func=cmd_all)
+
+    for key, icon, title, *_ in menu.SECTIONS:
+        s = sub.add_parser(key, help=f"{title} section")
+        s.set_defaults(func=cmd_section)
+
+    s = sub.add_parser("watch", help="live full-screen dashboard (Ctrl+C to exit)")
+    s.add_argument("-n", "--interval", type=float, default=1.0, metavar="SEC")
+    s.set_defaults(func=cmd_watch)
+
+    s = sub.add_parser("ports", help="what is listening on which port")
+    s.add_argument("-a", "--all", action="store_true", help="include system services")
+    s.set_defaults(func=cmd_ports)
+
+    s = sub.add_parser("kill", help="kill whatever holds a port")
+    s.add_argument("port", type=int)
+    s.add_argument("-f", "--force", action="store_true", help="SIGKILL immediately")
+    s.add_argument("-y", "--yes", action="store_true", help="don't ask")
+    s.set_defaults(func=cmd_kill)
+
+    s = sub.add_parser("junk", help="find node_modules, .venv, target/ … and their sizes")
+    s.add_argument("path", nargs="?", default=os.path.expanduser("~"))
+    s.add_argument("--older", type=int, default=0, metavar="DAYS",
+                   help="only projects untouched for DAYS days")
+    s.add_argument("--limit", type=int, default=40)
+    s.add_argument("--clean", action="store_true", help="choose folders to delete")
+    s.add_argument("-y", "--yes", action="store_true", help="delete all listed without asking")
+    s.set_defaults(func=cmd_junk)
+
+    s = sub.add_parser("caches", help="tool & system caches (pip, npm, docker, journal …)")
+    s.add_argument("--clean", nargs="+", metavar="KEY", help="cache keys to clean, or 'all'")
+    s.add_argument("-y", "--yes", action="store_true")
+    s.set_defaults(func=cmd_caches)
+
+    s = sub.add_parser("repos", help="git repos with uncommitted / unpushed work")
+    s.add_argument("path", nargs="?", default=os.path.expanduser("~"))
+    s.add_argument("-a", "--all", action="store_true", help="show clean repos too")
+    s.set_defaults(func=cmd_repos)
+
+    s = sub.add_parser("procs", help="dev processes grouped by project")
+    s.add_argument("-v", "--verbose", action="store_true")
+    s.set_defaults(func=cmd_procs)
+    return p
+
+
+WSL_URL = "https://learn.microsoft.com/windows/wsl/install"
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    if sys.platform == "win32":
+        console.print("[bold yellow]devmedic doesn't support native Windows yet.[/]\n"
+                      "It works great inside WSL (Ubuntu on Windows):\n"
+                      f"  1. Install WSL: [cyan]{WSL_URL}[/]\n"
+                      "  2. In the Ubuntu terminal: [bold]pipx install devmedic[/]\n"
+                      "Native Windows support is coming in a future release.")
+        return 1
+    if not sys.platform.startswith("linux"):
+        console.print("[yellow]devmedic is built for Linux; some checks may be "
+                      "missing on this system.[/]")
+    if not getattr(args, "func", None):
+        args.func = cmd_overview
+    try:
+        return args.func(args) or 0
+    except KeyboardInterrupt:
+        console.print("\n[dim]Interrupted.[/]")
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())