devmedic 0.2.0__py3-none-any.whl

devmedic/procs.py

@@ -0,0 +1,113 @@
+"""Dev processes grouped by the project (cwd) they were started from."""
+import os
+import time
+from collections import defaultdict
+
+import psutil
+from rich.table import Table
+
+from .util import HOME, console, human_age, human_size, short_path, size_style
+
+DEV_NAMES = {"node", "python", "python3", "java", "ruby", "go", "cargo", "rustc",
+             "deno", "bun", "php", "dotnet", "gradle", "mvn", "npm", "pnpm", "yarn",
+             "vite", "esbuild", "webpack", "next-server", "uvicorn", "gunicorn",
+             "flask", "celery", "jupyter", "jupyter-lab", "postgres", "mysqld",
+             "mongod", "redis-server", "tsserver", "ng", "air", "nodemon",
+             "docker-proxy", "containerd-shim", "gopls", "rust-analyzer", "pyright",
+             "language_server", "kotlin", "emulator", "qemu-system-x86_64", "adb"}
+
+
+def is_dev(name, cmdline):
+    base = name.split(".")[0].lower()
+    if base in DEV_NAMES or name.lower() in DEV_NAMES:
+        return True
+    return bool(cmdline) and os.path.basename(cmdline[0]).lower() in DEV_NAMES
+
+
+def collect():
+    ports = defaultdict(set)
+    try:
+        for c in psutil.net_connections(kind="inet"):
+            if c.status == psutil.CONN_LISTEN and c.pid:
+                ports[c.pid].add(c.laddr.port)
+    except (psutil.AccessDenied, OSError):
+        pass
+    me, self_pid = os.getuid(), os.getpid()
+    rows = []
+    for p in psutil.process_iter(["pid", "name", "cmdline", "memory_info", "create_time",
+                                  "uids", "cwd", "cpu_percent"]):
+        info = p.info
+        if not info["uids"] or info["uids"].real != me or info["pid"] == self_pid:
+            continue
+        if not is_dev(info["name"] or "", info["cmdline"] or []):
+            continue
+        rows.append({"pid": info["pid"], "name": info["name"],
+                     "cmd": " ".join(" ".join(info["cmdline"] or []).split()),
+                     "rss": info["memory_info"].rss if info["memory_info"] else 0,
+                     "started": info["create_time"] or time.time(),
+                     "cwd": info["cwd"] or "?", "ports": sorted(ports.get(info["pid"], ())),
+                     "proc": p})
+    # One CPU sample over a short window for everything at once.
+    for r in rows:
+        try:
+            r["proc"].cpu_percent(None)
+        except psutil.Error:
+            pass
+    time.sleep(0.5)
+    for r in rows:
+        try:
+            r["cpu"] = r["proc"].cpu_percent(None)
+        except psutil.Error:
+            r["cpu"] = 0.0
+    return rows
+
+
+def group(rows):
+    groups = defaultdict(list)
+    for r in rows:
+        groups[r["cwd"]].append(r)
+    out = [{"cwd": cwd, "procs": ps, "rss": sum(p["rss"] for p in ps),
+            "cpu": sum(p["cpu"] for p in ps),
+            "ports": sorted({x for p in ps for x in p["ports"]}),
+            "oldest": min(p["started"] for p in ps)}
+           for cwd, ps in groups.items()]
+    return sorted(out, key=lambda g: g["rss"], reverse=True)
+
+
+def show(rows, detail=False):
+    if not rows:
+        console.print("[green]No dev processes running.[/]")
+        return
+    vm = psutil.virtual_memory()
+    groups = group(rows)
+    total = sum(g["rss"] for g in groups)
+    t = Table(title=f"Dev processes — {human_size(total)} RAM "
+                    f"({total / vm.total * 100:.0f}% of {human_size(vm.total)})",
+              title_justify="left")
+    t.add_column("Started in", overflow="fold")
+    t.add_column("RAM", justify="right")
+    t.add_column("CPU", justify="right")
+    t.add_column("Procs", justify="right")
+    t.add_column("Ports", style="cyan")
+    t.add_column("Running for", justify="right")
+    t.add_column("What", overflow="ellipsis", no_wrap=True, max_width=50)
+    for g in groups:
+        names = sorted({p["name"] for p in g["procs"]})
+        cwd = g["cwd"]
+        label = "~" if cwd == HOME else short_path(cwd)
+        t.add_row(label, f"[{size_style(g['rss'] * 4)}]{human_size(g['rss'])}[/]",
+                  f"{g['cpu']:.0f}%", str(len(g["procs"])),
+                  ", ".join(map(str, g["ports"])),
+                  human_age(g["oldest"]).replace(" ago", ""), ", ".join(names))
+        if detail:
+            for p in sorted(g["procs"], key=lambda p: p["rss"], reverse=True):
+                t.add_row(f"  [dim]pid {p['pid']}[/]", f"[dim]{human_size(p['rss'])}[/]",
+                          f"[dim]{p['cpu']:.0f}%[/]", "",
+                          ", ".join(map(str, p["ports"])), "", f"[dim]{p['cmd']}[/]")
+    console.print(t)
+    stale = [g for g in groups if time.time() - g["oldest"] > 86400 and g["ports"]]
+    if stale:
+        console.print(f"[yellow]💡 {len(stale)} server(s) running for over a day — "
+                      f"forgotten dev servers? Kill with [bold]devmedic kill <port>[/].[/]")
+    if not detail:
+        console.print("[dim]Use -v to see individual processes.[/]")

devmedic/repos.py

@@ -0,0 +1,129 @@
+"""Find git repos with work that isn't safely pushed."""
+import os
+import subprocess
+from concurrent.futures import ThreadPoolExecutor
+
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+from .junk import PATTERNS, SKIP_AT_TOP, SKIP_DIRS
+from .util import HOME, console, display_path, human_age, short_path
+
+
+def find(root, max_depth=6):
+    root = os.path.abspath(root)
+    stack = [(root, 0)]
+    while stack:
+        current, depth = stack.pop()
+        if os.path.exists(os.path.join(current, ".git")):
+            yield current
+            # keep going: nested repos / submodules-as-dirs are common
+        try:
+            entries = list(os.scandir(current))
+        except OSError:
+            continue
+        at_top = current in (HOME, "/")
+        for e in entries:
+            if (depth < max_depth and e.is_dir(follow_symlinks=False)
+                    and e.name not in SKIP_DIRS and e.name not in PATTERNS
+                    and not (at_top and (e.name.startswith(".") or e.name in SKIP_AT_TOP))):
+                stack.append((e.path, depth + 1))
+
+
+def git(repo, *args):
+    try:
+        r = subprocess.run(["git", "-C", repo, *args], capture_output=True, text=True,
+                           timeout=15)
+        return r.stdout if r.returncode == 0 else ""
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+
+def inspect(repo):
+    info = {"path": repo, "branch": "?", "ahead": 0, "behind": 0, "upstream": False,
+            "changed": 0, "untracked": 0, "stashes": 0, "last": 0, "no_remote": False,
+            "unpushed_branches": 0}
+    for line in git(repo, "status", "--porcelain=v2", "--branch").splitlines():
+        if line.startswith("# branch.head "):
+            info["branch"] = line.split(" ", 2)[2]
+        elif line.startswith("# branch.upstream "):
+            info["upstream"] = True
+        elif line.startswith("# branch.ab "):
+            a, b = line.split()[2:4]
+            info["ahead"], info["behind"] = int(a), -int(b)
+        elif line.startswith("?"):
+            info["untracked"] += 1
+        elif line[:1] in ("1", "2", "u"):
+            info["changed"] += 1
+    info["stashes"] = len(git(repo, "stash", "list").splitlines())
+    last = git(repo, "log", "-1", "--format=%ct").strip()
+    info["last"] = int(last) if last.isdigit() else 0
+    info["no_remote"] = not git(repo, "remote").strip()
+    # Local branches with commits not on any remote.
+    if not info["no_remote"]:
+        out = git(repo, "for-each-ref", "--format=%(refname:short)|%(upstream:track)",
+                  "refs/heads")
+        for line in out.splitlines():
+            name, _, track = line.partition("|")
+            if name == info["branch"]:
+                continue  # already covered by ahead/upstream
+            if "ahead" in track or (not track and
+                                    git(repo, "log", "--oneline", "-1", name, "--not",
+                                        "--remotes").strip()):
+                info["unpushed_branches"] += 1
+    return info
+
+
+def needs_attention(i):
+    return (i["changed"] or i["untracked"] or i["ahead"] or i["stashes"]
+            or i["unpushed_branches"] or i["no_remote"]
+            or (i["upstream"] is False and i["branch"] != "(detached)" and i["last"]))
+
+
+def scan(root):
+    with Progress(SpinnerColumn(), TextColumn("{task.description}"),
+                  console=console, transient=True) as prog:
+        task = prog.add_task(f"Looking for git repos in {short_path(os.path.abspath(root))} …")
+        repos = list(find(root))
+        prog.update(task, description=f"Inspecting {len(repos)} repos …")
+        with ThreadPoolExecutor(max_workers=8) as pool:
+            infos = list(pool.map(inspect, repos))
+    return sorted(infos, key=lambda i: i["last"], reverse=True)
+
+
+def show(infos, show_all=False, root=None):
+    if not infos:
+        console.print("[dim]No git repositories found.[/]")
+        return
+    flagged = [i for i in infos if needs_attention(i)]
+    rows = infos if show_all else flagged
+    if not rows:
+        console.print(f"[green]All {len(infos)} repos are clean and pushed. ✨[/]")
+        return
+    t = Table(title=f"Git repos — {len(flagged)} of {len(infos)} need attention",
+              title_justify="left")
+    t.add_column("Repo", overflow="fold")
+    t.add_column("Branch", style="cyan")
+    t.add_column("Problems")
+    t.add_column("Last commit", justify="right")
+    for i in rows:
+        p = []
+        if i["changed"]:
+            p.append(f"[yellow]{i['changed']} modified[/]")
+        if i["untracked"]:
+            p.append(f"[yellow]{i['untracked']} untracked[/]")
+        if i["ahead"]:
+            p.append(f"[red]{i['ahead']} unpushed[/]")
+        if i["behind"]:
+            p.append(f"[blue]{i['behind']} behind[/]")
+        if i["stashes"]:
+            p.append(f"[magenta]{i['stashes']} stash[/]")
+        if i["unpushed_branches"]:
+            p.append(f"[red]{i['unpushed_branches']} other branch(es) unpushed[/]")
+        if i["no_remote"]:
+            p.append("[red]no remote (not backed up!)[/]")
+        elif not i["upstream"] and i["last"]:
+            p.append("[yellow]branch has no upstream[/]")
+        t.add_row(display_path(i["path"], root), i["branch"], ", ".join(p) or "[green]clean[/]",
+                  human_age(i["last"]) if i["last"] else "no commits")
+    console.print(t)

devmedic/util.py

@@ -0,0 +1,109 @@
+"""Shared helpers: sizes, ages, confirmation prompts."""
+import os
+import shutil
+import subprocess
+import time
+
+from rich.console import Console
+
+console = Console()
+HOME = os.path.expanduser("~")
+
+
+def dir_size(path):
+    """Actual disk usage of a directory tree in bytes (doesn't follow symlinks)."""
+    total = 0
+    seen = set()
+    stack = [path]
+    while stack:
+        current = stack.pop()
+        try:
+            with os.scandir(current) as it:
+                for entry in it:
+                    try:
+                        st = entry.stat(follow_symlinks=False)
+                    except OSError:
+                        continue
+                    if entry.is_dir(follow_symlinks=False):
+                        stack.append(entry.path)
+                        continue
+                    # Hardlinked files (pnpm store, etc.) count once.
+                    if st.st_nlink > 1:
+                        key = (st.st_dev, st.st_ino)
+                        if key in seen:
+                            continue
+                        seen.add(key)
+                    total += st.st_blocks * 512
+        except OSError:
+            continue
+    return total
+
+
+def human_size(n):
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if abs(n) < 1024 or unit == "TB":
+            return f"{n:.0f} {unit}" if unit in ("B", "KB") else f"{n:.1f} {unit}"
+        n /= 1024
+
+
+def size_style(n):
+    if n >= 1024**3:
+        return "bold red"
+    if n >= 200 * 1024**2:
+        return "yellow"
+    return "green"
+
+
+def human_age(ts):
+    days = (time.time() - ts) / 86400
+    if days < 1:
+        hours = days * 24
+        return "just now" if hours < 1 else f"{hours:.0f}h ago"
+    if days < 60:
+        return f"{days:.0f}d ago"
+    if days < 730:
+        return f"{days / 30:.0f}mo ago"
+    return f"{days / 365:.1f}y ago"
+
+
+def short_path(path):
+    return "~" + path[len(HOME):] if path.startswith(HOME) else path
+
+
+def display_path(path, root=None):
+    """Path relative to the scan root (when that's shorter), else ~-style."""
+    if root:
+        root = os.path.abspath(root)
+        if root != HOME and path.startswith(root + os.sep):
+            return os.path.relpath(path, root)
+    return short_path(path)
+
+
+def confirm(question, assume_yes=False):
+    if assume_yes:
+        return True
+    try:
+        answer = console.input(f"[bold]{question}[/] [dim](y/N)[/] ")
+    except (EOFError, KeyboardInterrupt):
+        console.print()
+        return False
+    return answer.strip().lower() in ("y", "yes")
+
+
+def run(cmd, timeout=15):
+    """Run a command, return stdout ('' on any failure)."""
+    try:
+        return subprocess.run(
+            cmd, capture_output=True, text=True, timeout=timeout
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return ""
+
+
+def have(binary):
+    return shutil.which(binary) is not None
+
+
+def remove_tree(path):
+    shutil.rmtree(path, ignore_errors=True)
+    return not os.path.exists(path)

devmedic-0.2.0.dist-info/METADATA

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: devmedic
+Version: 0.2.0
+Summary: A health check for your developer machine: ports, junk folders, caches, git repos, dev processes — offline.
+License: MIT
+Project-URL: Homepage, https://github.com/yaswanthme007/devmedic
+Project-URL: Issues, https://github.com/yaswanthme007/devmedic/issues
+Keywords: developer-tools,cli,linux,ubuntu,cleanup,ports,disk-usage
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Monitoring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.8
+Requires-Dist: rich>=12.0
+Dynamic: license-file
+
+# 🩺 devmedic
+
+**A health check for your developer machine.** Find what's hogging your ports, RAM and disk,
+spot git work that isn't backed up, and clean up safely — all from one friendly terminal UI.
+Works **100% offline**. No accounts, no telemetry, nothing leaves your machine.
+
+```
+     _                                    _  _
+  __| |  ___ __   __ _ __ ___    ___   __| |(_)  ___
+ / _` | / _ \\ \ / /| '_ ` _ \  / _ \ / _` || | / __|
+| (_| ||  __/ \ V / | | | | | ||  __/| (_| || || (__
+ \__,_| \___|  \_/  |_| |_| |_| \___| \__,_||_| \___|      HEALTH 92/100  A
+```
+
+## Why?
+
+Every developer hits these, over and over:
+
+- 😤 `Error: listen EADDRINUSE: address already in use :::3000`
+- 💾 Disk full — from 40 forgotten `node_modules`, `.venv`s and `target/` folders
+- 🐢 Machine slow — three dev servers you started last week are still running
+- 😱 "Did I ever push that project?"
+
+devmedic answers all of them in seconds.
+
+## Install
+
+Requires **Linux** (built and tested on Ubuntu) and **Python 3.9+**.
+On **Windows**, use it inside [WSL](https://learn.microsoft.com/windows/wsl/install) for now; native support is planned.
+
+**With pipx (recommended)**
+
+```bash
+sudo apt install pipx && pipx ensurepath        # once
+pipx install devmedic
+```
+
+**With pip**
+
+```bash
+pip install devmedic        # inside a virtualenv, or: pip install --user devmedic
+```
+
+**From a clone**
+
+```bash
+git clone https://github.com/yaswanthme007/devmedic.git
+cd devmedic
+./install.sh          # uses pipx if present, otherwise a dev-mode link in ~/.local/bin
+```
+
+Dev mode needs `sudo apt install python3-psutil python3-rich` (already present on most Ubuntu
+desktops).
+
+## Usage
+
+```bash
+devmedic                 # interactive menu — pick a section with ↑↓ / 1-8 / Enter
+devmedic all             # everything on one screen (also used when output is piped)
+devmedic watch           # live full-screen monitor: CPU/RAM graphs, net speed, ports
+```
+
+**Sections** (open from the menu, or directly):
+
+| Command              | Shows                                                         |
+|----------------------|---------------------------------------------------------------|
+| `devmedic system`   | CPU model, per-core usage, load, temperature, battery         |
+| `devmedic memory`   | RAM/swap and the biggest apps (browser tabs grouped together) |
+| `devmedic storage`  | Usage of every real partition                                 |
+| `devmedic network`  | IPs, Wi-Fi, traffic, listening ports                          |
+| `devmedic tools`    | Installed versions of git, python, node, go, rust, docker …   |
+| `devmedic projects` | Dev processes by project + every git repo's status            |
+| `devmedic cleanup`  | How much space caches and junk folders are wasting            |
+| `devmedic notes`    | The doctor's recommendations, with exact commands             |
+
+**Fix things:**
+
+```bash
+devmedic ports [-a]                 # what's listening, and from which project folder
+devmedic kill 3000                  # free port 3000 (SIGTERM, then SIGKILL if needed)
+devmedic junk [PATH]                # node_modules, .venv, target/, .next … with sizes
+devmedic junk --older 30 --clean    # pick stale ones to delete: 1,3,5-8 / all
+devmedic caches                     # pip npm yarn pnpm cargo go gradle maven … + system
+devmedic caches --clean pip npm     # or --clean all (skips risky ones like Trash)
+devmedic repos [PATH]               # uncommitted, unpushed, stashed, or no remote at all
+devmedic procs [-v]                 # dev processes grouped by project, RAM/CPU/ports
+```
+
+## Safety
+
+devmedic is careful by design:
+
+- **Nothing is deleted without confirmation** (unless you pass `-y`).
+- **Conservative junk detection:** `target/` only next to `Cargo.toml`/`pom.xml`, venvs only if
+  they contain `pyvenv.cfg`. Generic `build/` and `dist/` folders are **never** touched.
+- **Never runs `sudo`.** System fixes (journal, apt, snap, docker) are printed for you to copy.
+- **Only kills what you confirm**, and can't touch other users' processes.
+- **Offline and private:** no network requests, no data collection.
+
+## Development
+
+```bash
+./install.sh --dev                        # edits take effect immediately
+python3 -m unittest discover -s tests -v  # run the tests
+```
+
+Ideas and pull requests are welcome! Please open an issue first for big changes.
+
+## License
+
+[MIT](LICENSE)

devmedic-0.2.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+devmedic/__init__.py,sha256=Zn1KFblwuFHiDRdRAiRnDBRkbPttWh44jKa5zG2ov0E,22
+devmedic/__main__.py,sha256=E6Gls0DNz8GQK2K-kOUIx8cYhgANW_CH54VKrfCfs14,52
+devmedic/caches.py,sha256=b3PGwVXITq1WJtlbvuLyhZhoLjm-jAZDCvKo-hN1b0A,7917
+devmedic/cli.py,sha256=mHtE2vLVnvVsYN0pVNkAAtpeqyiM9MFX34QqieGEdOI,5098
+devmedic/dashboard.py,sha256=MvLipL3QEHPyPTq1IBttcfR0LcvYoNnIH6HLGqIXtz0,25474
+devmedic/junk.py,sha256=KWNVYPADHIzjuutz2ULeKFQAbDW1V4Bm1Tp3xktOjSY,7339
+devmedic/menu.py,sha256=9Lu--X7SqzSjlSjxbaAlpYRq0Unt9Tk_i0B5lYTREjY,10906
+devmedic/ports.py,sha256=rYxQjfACEG-YMCt0S5HQZ9KSTP4ia9FMr_ALnZyp8Bw,4637
+devmedic/procs.py,sha256=PrSsIVW8j6UETvkc4FV1D_iHNKi50faF9Ip8CN61BCY,4860
+devmedic/repos.py,sha256=8ekx-1ibscyyG0zjdquz3EyDiZxvL4P2UaM6HWt5J8k,5403
+devmedic/util.py,sha256=NiEX1xxm3JJgF0NX43nygZEmdLD7MEaw3K45wQma8oA,2977
+devmedic-0.2.0.dist-info/licenses/LICENSE,sha256=64qGbQIfOrXIorKNN0D5R4FacU3r3JcYMfp9R1mK83Q,1078
+devmedic-0.2.0.dist-info/METADATA,sha256=34tipsbC8d0FRbBARU1BzNBgEuTRiKO2L22RYWsCYKY,5275
+devmedic-0.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+devmedic-0.2.0.dist-info/entry_points.txt,sha256=e0NQcvPkfQo1HsNkpje7CpQiTqh0Z6RT-kw2AafF9hg,47
+devmedic-0.2.0.dist-info/top_level.txt,sha256=ND2dM3AMx6h4OsMSqXTvHWfrlJp5hX5kOW81K0AqTZI,9
+devmedic-0.2.0.dist-info/RECORD,,

devmedic-0.2.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

devmedic-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+devmedic = devmedic.cli:main

devmedic-0.2.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 devmedic contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

devmedic-0.2.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devmedic