devmedic 0.2.0__tar.gz

devmedic-0.2.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,111 @@
+# 🩺 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/devmedic/__init__.py

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

devmedic-0.2.0/devmedic/__main__.py

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

devmedic-0.2.0/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-0.2.0/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())