devmedic 0.2.0__py3-none-any.whl

devmedic/junk.py

@@ -0,0 +1,185 @@
+"""Find regenerable build/dependency folders across your projects."""
+import os
+import time
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from .util import (HOME, confirm, console, dir_size, display_path, human_age, human_size,
+                   remove_tree, short_path, size_style)
+
+# name -> (kind, check) ; check(parent_dir, junk_dir) says whether it's really junk
+def _sibling(*names):
+    return lambda parent, _d: any(os.path.exists(os.path.join(parent, n)) for n in names)
+
+def _always(_parent, _d):
+    return True
+
+def _is_venv(_parent, d):
+    return os.path.exists(os.path.join(d, "pyvenv.cfg"))
+
+PATTERNS = {
+    "node_modules":  ("Node deps",     _always),
+    ".venv":         ("Python venv",   _is_venv),
+    "venv":          ("Python venv",   _is_venv),
+    "env":           ("Python venv",   _is_venv),
+    "target":        ("Rust/Maven",    _sibling("Cargo.toml", "pom.xml")),
+    ".next":         ("Next.js build", _always),
+    ".nuxt":         ("Nuxt build",    _always),
+    ".svelte-kit":   ("SvelteKit",     _always),
+    ".parcel-cache": ("Parcel cache",  _always),
+    ".turbo":        ("Turbo cache",   _always),
+    ".angular":      ("Angular cache", _always),
+    ".gradle":       ("Gradle cache",  _sibling("build.gradle", "build.gradle.kts",
+                                                "settings.gradle", "settings.gradle.kts")),
+    ".dart_tool":    ("Dart/Flutter",  _sibling("pubspec.yaml")),
+    ".tox":          ("tox envs",      _always),
+    ".pytest_cache": ("pytest cache",  _always),
+    ".mypy_cache":   ("mypy cache",    _always),
+    ".ruff_cache":   ("ruff cache",    _always),
+}
+
+# Never descend into these (huge, or not your projects).
+SKIP_DIRS = {".git", ".cache", ".local", ".npm", ".cargo", ".rustup", "snap",
+             ".mozilla", ".config", ".vscode", ".vscode-server", ".var",
+             ".m2", ".gradle", ".nvm", ".pyenv", ".docker", ".Trash"}
+# Skipped only directly under $HOME / filesystem root.
+SKIP_AT_TOP = {"go", "proc", "sys", "dev", "run", "tmp", "boot", "lost+found"}
+
+
+def find(root, max_depth=8):
+    """Yield (junk_path, kind) — does not descend into junk it found."""
+    root = os.path.abspath(root)
+    stack = [(root, 0)]
+    while stack:
+        current, depth = stack.pop()
+        try:
+            entries = list(os.scandir(current))
+        except OSError:
+            continue
+        for e in entries:
+            if not e.is_dir(follow_symlinks=False):
+                continue
+            pattern = PATTERNS.get(e.name)
+            if pattern and pattern[1](current, e.path):
+                yield e.path, pattern[0]
+                continue
+            at_top = current in (HOME, "/")
+            if depth < max_depth and e.name not in SKIP_DIRS and not (
+                    at_top and (e.name.startswith(".") or e.name in SKIP_AT_TOP)):
+                stack.append((e.path, depth + 1))
+
+
+def project_last_touched(junk_path):
+    """Newest mtime among the project's own top-level files (not the junk)."""
+    parent = os.path.dirname(junk_path)
+    newest = 0
+    try:
+        for e in os.scandir(parent):
+            if e.path == junk_path or e.name in PATTERNS:
+                continue
+            try:
+                newest = max(newest, e.stat(follow_symlinks=False).st_mtime)
+            except OSError:
+                pass
+    except OSError:
+        pass
+    return newest or os.stat(junk_path).st_mtime
+
+
+def scan(root, older_than_days=0):
+    with Progress(SpinnerColumn(), TextColumn("{task.description}"),
+                  console=console, transient=True) as prog:
+        task = prog.add_task(f"Scanning {short_path(os.path.abspath(root))} …")
+        found = []
+        for path, kind in find(root):
+            found.append((path, kind))
+            prog.update(task, description=f"Found {len(found)} — {short_path(path)}")
+        prog.update(task, description=f"Measuring {len(found)} folders …")
+        with ThreadPoolExecutor(max_workers=8) as pool:
+            sizes = list(pool.map(dir_size, [p for p, _ in found]))
+    cutoff = time.time() - older_than_days * 86400
+    items = []
+    for (path, kind), size in zip(found, sizes):
+        touched = project_last_touched(path)
+        if older_than_days and touched > cutoff:
+            continue
+        items.append({"path": path, "kind": kind, "size": size, "touched": touched})
+    items.sort(key=lambda i: i["size"], reverse=True)
+    return items
+
+
+def show(items, limit=40, root=None):
+    if not items:
+        console.print("[green]No junk folders found. Clean machine! ✨[/]")
+        return
+    total = sum(i["size"] for i in items)
+    t = Table(title=f"Regenerable folders — {human_size(total)} total",
+              title_justify="left")
+    t.add_column("#", justify="right", style="dim")
+    t.add_column("Size", justify="right")
+    t.add_column("Type")
+    t.add_column("Project last touched", justify="right")
+    t.add_column("Path", overflow="fold")
+    for n, i in enumerate(items[:limit], 1):
+        t.add_row(str(n), f"[{size_style(i['size'])}]{human_size(i['size'])}[/]",
+                  i["kind"], human_age(i["touched"]), display_path(i["path"], root))
+    console.print(t)
+    if len(items) > limit:
+        rest = items[limit:]
+        console.print(f"[dim]…and {len(rest)} more "
+                      f"({human_size(sum(i['size'] for i in rest))}). Use --limit.[/]")
+
+
+def parse_selection(text, count):
+    """'1,3,5-7' / 'all' -> sorted list of 0-based indices."""
+    text = text.strip().lower()
+    if text in ("a", "all"):
+        return list(range(count))
+    picked = set()
+    for part in text.replace(" ", ",").split(","):
+        if not part:
+            continue
+        if "-" in part:
+            lo, hi = part.split("-", 1)
+            picked.update(range(int(lo), int(hi) + 1))
+        else:
+            picked.add(int(part))
+    return sorted(i - 1 for i in picked if 1 <= i <= count)
+
+
+def clean(items, assume_yes=False, limit=40):
+    if not items:
+        return
+    shown = items[:limit]
+    if assume_yes:
+        chosen = shown
+    else:
+        try:
+            answer = console.input("[bold]Delete which?[/] [dim](e.g. 1,3,5-8 / all / "
+                                   "Enter to cancel)[/] ")
+            chosen = [shown[i] for i in parse_selection(answer, len(shown))]
+        except ValueError:
+            console.print("[red]Couldn't parse that selection.[/]")
+            return
+        except (EOFError, KeyboardInterrupt):
+            console.print()
+            return
+    if not chosen:
+        console.print("Nothing deleted.")
+        return
+    total = sum(i["size"] for i in chosen)
+    console.print(f"About to delete [bold]{len(chosen)}[/] folders "
+                  f"([bold]{human_size(total)}[/]). They can be regenerated "
+                  f"(npm install, pip install, cargo build…).")
+    if not confirm("Proceed?", assume_yes):
+        return
+    freed = 0
+    for i in chosen:
+        if remove_tree(i["path"]):
+            freed += i["size"]
+            console.print(f"[green]✔[/] {short_path(i['path'])}")
+        else:
+            console.print(f"[red]✘ couldn't fully remove[/] {short_path(i['path'])}")
+    console.print(f"[bold green]Freed {human_size(freed)}[/]")

devmedic/menu.py

@@ -0,0 +1,295 @@
+"""Interactive section picker: `devmedic` with no arguments in a terminal."""
+import os
+import select
+import sys
+
+from rich.console import Group
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from . import caches, dashboard as db, ports, procs, repos
+from .util import console, human_size, short_path
+
+# ───────────────────────── section details ─────────────────────────
+
+
+def detail_system(d):
+    console.print(db.system_panel(d))
+    t = Table(title="Per-core usage", title_justify="left", box=None, padding=(0, 1))
+    t.add_column("Core", style="bold grey70", justify="right")
+    t.add_column("Usage")
+    for i, pct in enumerate(d["cpu"]):
+        t.add_row(str(i), db.bar(pct, 30))
+    console.print(t)
+
+
+def detail_memory(d):
+    console.print(db.memory_panel(d, limit=12))
+    console.print("[dim]Processes are grouped by app (e.g. all browser tabs together).[/]")
+
+
+def detail_storage(d):
+    console.print(db.storage_panel(d))
+    console.print("[dim]Free space fast: devmedic junk --clean · devmedic caches[/]")
+
+
+def detail_network(d):
+    console.print(db.network_panel(d))
+    ports.show()
+
+
+def detail_tools(d):
+    console.print(db.tools_panel(d))
+    dk = d["docker"]
+    if dk["state"] == "ok" and dk["containers"]:
+        t = Table(title="Running containers", title_justify="left")
+        for col in ("Name", "Image", "Status"):
+            t.add_column(col)
+        for row in dk["containers"]:
+            t.add_row(*row[:3])
+        console.print(t)
+    elif dk["state"] == "denied":
+        console.print("Fix Docker permissions: [bold]sudo usermod -aG docker $USER[/] "
+                      "then log out and back in.")
+
+
+def detail_projects(d):
+    procs.show(d["procs"])
+    console.print()
+    repos.show(d["git"]["infos"], show_all=True)
+
+
+def detail_cleanup(d):
+    user_c, sys_c = d["caches"]
+    caches.show(user_c, sys_c)
+    j = d["junk"]
+    console.print()
+    if j["count"]:
+        console.print(f"[bold]{j['count']} junk folders[/] ({human_size(j['total'])}), biggest:")
+        for size, path in j["top"]:
+            console.print(f"  {human_size(size):>9}  {short_path(path)}")
+        console.print("[dim]Review & delete: devmedic junk --clean[/]")
+    else:
+        console.print("[green]No node_modules / .venv / target junk found in ~ ✨[/]")
+
+
+def detail_notes(d):
+    _, tips = db.health(d)
+    console.print(db.tips_panel(tips))
+
+
+# ───────────────────────── menu summaries ─────────────────────────
+
+
+def _c(text, color):
+    return f"[{color}]{text}[/]"
+
+
+def sum_system(d):
+    s, cores = d["sys"], d["cpu"]
+    total = sum(cores) / len(cores) if cores else 0
+    parts = [_c(f"CPU {total:.0f}%", db.level_color(total))]
+    if s["temp"]:
+        parts.append(_c(f"{s['temp']:.0f}°C", db.level_color(s["temp"], 70, 85)))
+    if s["battery"]:
+        b = s["battery"]
+        parts.append(_c(f"battery {b.percent:.0f}%{' ⚡' if b.power_plugged else ''}",
+                        db.level_color(100 - b.percent, 70, 85)))
+    return " · ".join(parts)
+
+
+def sum_memory(d):
+    m = d["mem"]
+    top = d["hogs"][0] if d["hogs"] else None
+    return (_c(f"RAM {m.percent:.0f}%", db.level_color(m.percent, 75, 90))
+            + (f" · {top[0]} {human_size(top[1])}" if top else ""))
+
+
+def sum_storage(d):
+    return " · ".join(_c(f"{x['mount']} {x['pct']:.0f}%", db.level_color(x["pct"]))
+                      for x in d["disks"][:3])
+
+
+def sum_network(d):
+    n = d["net"]
+    where = n["wifi"] or (n["ips"][0][0] if n["ips"] else None)
+    ip = n["ips"][0][1] if n["ips"] else None
+    head = f"{where} {ip}" if ip else _c("offline", "yellow")
+    return f"{head} · {db.plural(len(d['ports']), 'port')} listening"
+
+
+def sum_tools(d):
+    installed = sum(1 for _, v in d["tools"] if v)
+    dk = {"ok": _c("docker ✔", "green"), "denied": _c("docker needs permission", "yellow"),
+          "down": _c("docker stopped", "grey62"), "missing": ""}[d["docker"]["state"]]
+    return " · ".join(x for x in (f"{installed} tools installed", dk) if x)
+
+
+def sum_projects(d):
+    g = d["git"]
+    risky = len(g["noremote"]) + len(g["unpushed"])
+    parts = [f"{db.plural(g['total'], 'repo')}"]
+    parts.append(_c(f"{risky} not backed up", "red") if risky else _c("all backed up", "green"))
+    parts.append(f"{db.plural(len(d['procs']), 'dev process', 'dev processes')}")
+    return " · ".join(parts)
+
+
+def sum_cleanup(d):
+    user_c, sys_c = d["caches"]
+    total = (sum(c["size"] for c in user_c) + sum(s["size"] or 0 for s in sys_c)
+             + d["junk"]["total"])
+    color = "red" if total > 5 * 1024**3 else "yellow" if total > 300 * 1024**2 else "green"
+    return _c(f"{human_size(total)} reclaimable", color)
+
+
+def sum_notes(d):
+    _, tips = db.health(d)
+    return _c(f"{db.plural(len(tips), 'suggestion')}", "yellow") if tips else _c("all good ✨", "green")
+
+
+# key, icon, title, summary(d), detail(d)
+SECTIONS = [
+    ("system",   "⚡", "System",         sum_system,   detail_system),
+    ("memory",   "🧠", "Memory",         sum_memory,   detail_memory),
+    ("storage",  "💾", "Storage",        sum_storage,  detail_storage),
+    ("network",  "🌐", "Network",        sum_network,  detail_network),
+    ("tools",    "🛠 ", "Dev tools",      sum_tools,    detail_tools),
+    ("projects", "📂", "Projects",       sum_projects, detail_projects),
+    ("cleanup",  "🧹", "Cleanup",        sum_cleanup,  detail_cleanup),
+    ("notes",    "💡", "Doctor's notes", sum_notes,    detail_notes),
+]
+EXTRAS = [  # key, icon, title, hint
+    ("all",     "📊", "Everything",   "full dashboard on one screen"),
+    ("watch",   "📡", "Live monitor", "real-time CPU / RAM / network"),
+    ("refresh", "🔄", "Refresh",      "re-scan the machine"),
+    ("quit",    "🚪", "Quit",         ""),
+]
+SECTION_KEYS = [s[0] for s in SECTIONS]
+
+
+def show_section(key, d=None):
+    """Print one section (used by `devmedic memory` etc.)."""
+    d = d or db.gather()
+    for k, icon, title, _, detail in SECTIONS:
+        if k == key:
+            if key in ("projects", "cleanup"):  # the others open with their own panel
+                console.rule(f"[bold cyan]{icon} {title}[/]", align="left", style="cyan")
+            detail(d)
+            return
+
+
+# ───────────────────────── keyboard ─────────────────────────
+
+KEYS = {b"\x1b[A": "up", b"\x1bOA": "up", b"k": "up",
+        b"\x1b[B": "down", b"\x1bOB": "down", b"j": "down",
+        b"\r": "enter", b"\n": "enter", b" ": "enter", b"\x1b[C": "enter", b"l": "enter",
+        b"q": "quit", b"Q": "quit", b"\x1b": "back", b"\x1b[D": "back", b"h": "back",
+        b"r": "refresh", b"a": "all", b"w": "watch", b"\x1b[H": "home", b"\x1b[F": "end"}
+
+
+def read_key():
+    import termios  # POSIX only — imported here so the package loads everywhere
+    import tty
+
+    fd = sys.stdin.fileno()
+    old = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        data = os.read(fd, 1)
+        # Escape sequences arrive as a burst; grab the rest if it's there.
+        while data.startswith(b"\x1b") and select.select([fd], [], [], 0.03)[0]:
+            data += os.read(fd, 8)
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old)
+    if data.isdigit():
+        return data.decode()
+    return KEYS.get(data, "other")
+
+
+def wait_key(msg="Press any key to go back · q to quit"):
+    console.print()
+    console.print(Text(f"  {msg}", style="grey50"))
+    return read_key()
+
+
+# ───────────────────────── menu screen ─────────────────────────
+
+
+def menu_body(d, cursor):
+    items = [(k, icon, title, Text.from_markup(summ(d))) for k, icon, title, summ, _ in SECTIONS]
+    items += [(k, icon, title, Text(hint, style="grey50")) for k, icon, title, hint in EXTRAS]
+    t = Table.grid(padding=(0, 1))
+    t.add_column(width=2)                           # pointer
+    t.add_column(width=3, justify="right", style="grey50")  # shortcut
+    t.add_column(no_wrap=True)                      # icon + title
+    t.add_column()                                  # summary
+    for i, (key, icon, title, summary) in enumerate(items):
+        if i == len(SECTIONS):
+            t.add_row("", "", Text("─" * 18, style="grey35"), "")
+        selected = i == cursor
+        shortcut = str(i + 1) if i < len(SECTIONS) else {"all": "a", "watch": "w",
+                                                          "refresh": "r", "quit": "q"}[key]
+        label = Text(f"{icon} {title}", style="bold reverse cyan" if selected else "bold")
+        t.add_row(Text("❯", style="bold magenta") if selected else "", shortcut, label, summary)
+    return t, [it[0] for it in items]
+
+
+def render_menu(d, cursor):
+    score, _ = db.health(d)
+    body, keys = menu_body(d, cursor)
+    footer = Text("↑↓ / j k move · Enter open · 1-8 jump · a all · w live · r refresh · q quit",
+                  style="grey50")
+    menu = Panel(Group(body, Text(""), footer), title="[bold cyan]Choose a section[/]",
+                 title_align="left", border_style="cyan", padding=(1, 2))
+    return Group(db.header(d, score), Text(""), menu), keys
+
+
+def run():
+    d = db.gather()
+    cursor = 0
+    while True:
+        console.clear()
+        screen, keys = render_menu(d, cursor)
+        console.print(screen)
+        key = read_key()
+        if key.isdigit():
+            n = int(key) - 1
+            if 0 <= n < len(keys):
+                cursor = n
+                key = "enter"
+            else:
+                continue
+        if key in ("all", "watch", "refresh"):
+            cursor = keys.index(key)
+            key = "enter"
+        if key == "up":
+            cursor = (cursor - 1) % len(keys)
+        elif key == "down":
+            cursor = (cursor + 1) % len(keys)
+        elif key == "home":
+            cursor = 0
+        elif key == "end":
+            cursor = len(keys) - 1
+        elif key in ("quit", "back"):
+            break
+        elif key == "enter":
+            choice = keys[cursor]
+            if choice == "quit":
+                break
+            if choice == "refresh":
+                console.clear()
+                d = db.gather()
+                continue
+            console.clear()
+            if choice == "watch":
+                db.watch()
+                continue
+            if choice == "all":
+                db.show(d)
+            else:
+                show_section(choice, d)
+            if wait_key() == "quit":
+                break
+    console.clear()
+    console.print("[bold cyan]🩺 devmedic[/] — stay healthy! 👋")

devmedic/ports.py

@@ -0,0 +1,126 @@
+"""Who is listening on which port, and killing them."""
+import os
+import signal
+import time
+
+import psutil
+from rich.table import Table
+
+from .util import confirm, console, short_path
+
+
+# Friendly names for common root-owned services we can't inspect.
+WELL_KNOWN = {22: "sshd", 25: "smtp", 53: "DNS (systemd-resolved)", 80: "http",
+              443: "https", 631: "CUPS printing", 3306: "MySQL", 5432: "PostgreSQL",
+              6379: "Redis", 27017: "MongoDB", 5353: "mDNS (avahi)", 2375: "Docker",
+              11434: "Ollama"}
+
+
+def listening(include_system=False):
+    """List of dicts describing TCP listeners (deduped across IPv4/IPv6)."""
+    rows = {}
+    try:
+        conns = psutil.net_connections(kind="inet")
+    except (psutil.AccessDenied, OSError):
+        conns = []  # locked-down containers / non-Linux without root
+    for c in conns:
+        if c.status != psutil.CONN_LISTEN or not c.laddr:
+            continue
+        port = c.laddr.port
+        key = (port, c.pid)
+        if key in rows:
+            rows[key]["addrs"].add(c.laddr.ip)
+            continue
+        info = {"port": port, "pid": c.pid, "addrs": {c.laddr.ip},
+                "name": WELL_KNOWN.get(port, "?"), "cmd": "", "cwd": "", "user": "", "mine": False}
+        if c.pid:
+            try:
+                p = psutil.Process(c.pid)
+                info["name"] = p.name()
+                info["cmd"] = " ".join(" ".join(p.cmdline()).split())
+                info["user"] = p.username()
+                info["mine"] = p.uids().real == os.getuid()
+                info["cwd"] = p.cwd()
+            except (psutil.AccessDenied, psutil.NoSuchProcess, psutil.ZombieProcess):
+                pass
+        rows[key] = info
+    result = sorted(rows.values(), key=lambda r: r["port"])
+    if not include_system:
+        result = [r for r in result if r["mine"]]
+    return result
+
+
+def exposure(addrs):
+    if all(a.startswith("127.") or a == "::1" for a in addrs):
+        return "[green]local only[/]"
+    return "[yellow]network[/]"
+
+
+def show(include_system=False):
+    rows = listening(include_system)
+    if not rows:
+        console.print("[green]No listening ports owned by you.[/] "
+                      "[dim](use --all to include system services)[/]")
+        return
+    t = Table(title="Listening ports", title_justify="left")
+    t.add_column("Port", style="bold cyan", justify="right")
+    t.add_column("PID", justify="right")
+    t.add_column("Process")
+    t.add_column("Exposed")
+    t.add_column("Project dir", style="dim")
+    t.add_column("Command", overflow="ellipsis", max_width=60, no_wrap=True)
+    for r in rows:
+        t.add_row(str(r["port"]), str(r["pid"] or "?"), r["name"],
+                  exposure(r["addrs"]), short_path(r["cwd"]) if r["cwd"] else "",
+                  r["cmd"])
+    console.print(t)
+    if not include_system:
+        console.print("[dim]Showing your processes only. --all for system services.[/]")
+
+
+def kill(port, force=False, assume_yes=False):
+    targets = [r for r in listening(include_system=True) if r["port"] == port]
+    if not targets:
+        console.print(f"[green]Nothing is listening on port {port}.[/]")
+        return 0
+    status = 0
+    for r in targets:
+        if not r["pid"]:
+            console.print(f"[red]Port {port} is held by a process you can't see "
+                          f"(probably root).[/] Try: [bold]sudo ss -ltnp 'sport = :{port}'[/]")
+            status = 1
+            continue
+        console.print(f"Port [bold cyan]{port}[/] → PID {r['pid']} "
+                      f"[bold]{r['name']}[/] [dim]{r['cmd'][:100]}[/]")
+        if not r["mine"]:
+            console.print(f"[yellow]Owned by {r['user'] or 'another user'}; "
+                          f"you may need sudo.[/]")
+        if not confirm("Kill it?", assume_yes):
+            continue
+        status |= terminate(r["pid"], force)
+    return status
+
+
+def terminate(pid, force=False):
+    try:
+        p = psutil.Process(pid)
+        if force:
+            p.kill()
+        else:
+            p.terminate()
+            try:
+                p.wait(timeout=3)
+            except psutil.TimeoutExpired:
+                console.print("[yellow]Didn't exit after SIGTERM, sending SIGKILL…[/]")
+                p.kill()
+        p.wait(timeout=3)
+    except psutil.NoSuchProcess:
+        pass
+    except psutil.AccessDenied:
+        console.print(f"[red]Permission denied.[/] Try: [bold]sudo kill {pid}[/]")
+        return 1
+    except psutil.TimeoutExpired:
+        console.print(f"[red]PID {pid} is still alive.[/]")
+        return 1
+    console.print(f"[green]✔ Killed PID {pid}[/]")
+    return 0