devmedic 0.2.0__tar.gz → 0.3.0__tar.gz

{devmedic-0.2.0 → devmedic-0.3.0}/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: devmedic
-Version: 0.2.0
+Version: 0.3.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
+Keywords: developer-tools,cli,linux,ubuntu,windows,cleanup,ports,disk-usage
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development
 Classifier: Topic :: System :: Monitoring
@@ -47,16 +48,24 @@ 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.
+Works on **Linux** (built on Ubuntu) and **Windows 10/11**, with **Python 3.9+**.
 
 **With pipx (recommended)**
 
+Linux:
+
 ```bash
 sudo apt install pipx && pipx ensurepath        # once
 pipx install devmedic
 ```
 
+Windows (PowerShell or Windows Terminal):
+
+```powershell
+py -m pip install --user pipx; py -m pipx ensurepath   # once, then open a new terminal
+pipx install devmedic
+```
+
 **With pip**
 
 ```bash
@@ -115,7 +124,10 @@ 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.
+- **Links are never followed:** symlinks and Windows junctions (used by pnpm) are skipped when
+  scanning and removed as links, so nothing outside the folder is ever deleted.
+- **Never runs `sudo` or Administrator commands.** System fixes (journal, apt, snap, Recycle Bin,
+  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.
 

{devmedic-0.2.0 → devmedic-0.3.0}/README.md

@@ -25,16 +25,24 @@ 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.
+Works on **Linux** (built on Ubuntu) and **Windows 10/11**, with **Python 3.9+**.
 
 **With pipx (recommended)**
 
+Linux:
+
 ```bash
 sudo apt install pipx && pipx ensurepath        # once
 pipx install devmedic
 ```
 
+Windows (PowerShell or Windows Terminal):
+
+```powershell
+py -m pip install --user pipx; py -m pipx ensurepath   # once, then open a new terminal
+pipx install devmedic
+```
+
 **With pip**
 
 ```bash
@@ -93,7 +101,10 @@ 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.
+- **Links are never followed:** symlinks and Windows junctions (used by pnpm) are skipped when
+  scanning and removed as links, so nothing outside the folder is ever deleted.
+- **Never runs `sudo` or Administrator commands.** System fixes (journal, apt, snap, Recycle Bin,
+  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.
 

devmedic-0.3.0/devmedic/__init__.py

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

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/caches.py

@@ -6,13 +6,35 @@ 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)
+from .util import (HOME, WINDOWS, confirm, console, dir_size, have, human_size,
+                   is_real_dir, remove_tree, run, run_full, short_path, size_style)
 
 h = lambda *p: os.path.join(HOME, *p)
+LOCAL = os.environ.get("LOCALAPPDATA") or h("AppData", "Local")
+ROAMING = os.environ.get("APPDATA") or h("AppData", "Roaming")
+lo = lambda *p: os.path.join(LOCAL, *p)
+ro = lambda *p: os.path.join(ROAMING, *p)
 
 # key, label, path, clean command (None -> delete dir contents), note
-CACHES = [
+WINDOWS_CACHES = [
+    ("pip",      "pip cache",            lo("pip", "Cache"),          ["pip", "cache", "purge"], ""),
+    ("uv",       "uv cache",             lo("uv", "cache"),           ["uv", "cache", "clean"], ""),
+    ("npm",      "npm cache",            lo("npm-cache", "_cacache"), ["npm", "cache", "clean", "--force"], ""),
+    ("yarn",     "yarn cache",           lo("Yarn", "Cache"),         ["yarn", "cache", "clean"], ""),
+    ("pnpm",     "pnpm store",           lo("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",       lo("go-build"),              ["go", "clean", "-cache"], ""),
+    ("gradle",   "Gradle caches",        h(".gradle", "caches"),      None, ""),
+    ("maven",    "Maven repo",           h(".m2", "repository"),      None, ""),
+    ("nuget",    "NuGet packages",       h(".nuget", "packages"),     ["dotnet", "nuget", "locals", "all", "--clear"], ""),
+    ("hf",       "HuggingFace models",   h(".cache", "huggingface"),  None, "re-download is big!"),
+    ("temp",     "Temp files",           os.environ.get("TEMP") or lo("Temp"), None, "files in use are skipped"),
+    ("vscode",   "VS Code cache",        ro("Code", "Cache"),         None, "close VS Code first"),
+    ("chrome",   "Chrome cache",         lo("Google", "Chrome", "User Data", "Default", "Cache"), None, "close Chrome first"),
+    ("edge",     "Edge cache",           lo("Microsoft", "Edge", "User Data", "Default", "Cache"), None, "close Edge first"),
+]
+LINUX_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"], ""),
@@ -30,6 +52,28 @@ CACHES = [
     ("chrome",   "Chrome cache",         h(".cache", "google-chrome"), None, "close Chrome first"),
     ("firefox",  "Firefox cache",        h(".cache", "mozilla"),      None, "close Firefox first"),
 ]
+CACHES = WINDOWS_CACHES if WINDOWS else LINUX_CACHES
+
+
+def recycle_bin_usage():
+    """Bytes in the Windows Recycle Bin (all drives), or None."""
+    if not WINDOWS:
+        return None
+    import ctypes
+    from ctypes import wintypes
+
+    class SHQUERYRBINFO(ctypes.Structure):
+        _fields_ = [("cbSize", wintypes.DWORD), ("i64Size", ctypes.c_longlong),
+                    ("i64NumItems", ctypes.c_longlong)]
+
+    info = SHQUERYRBINFO()
+    info.cbSize = ctypes.sizeof(info)
+    try:
+        if ctypes.windll.shell32.SHQueryRecycleBinW(None, ctypes.byref(info)) != 0:
+            return None
+    except (AttributeError, OSError):
+        return None
+    return info.i64Size or None
 
 
 def journal_usage():
@@ -85,6 +129,7 @@ def collect():
         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)
+        rbin = pool.submit(recycle_bin_usage)
     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)
@@ -95,6 +140,9 @@ def collect():
     if a.result():
         system.append({"key": "apt", "label": "apt package cache", "size": a.result(),
                        "fix": "sudo apt clean && sudo apt autoremove --purge"})
+    if rbin.result():
+        system.append({"key": "recyclebin", "label": "Recycle Bin", "size": rbin.result(),
+                       "fix": "Clear-RecycleBin -Force   (PowerShell, permanent!)"})
     if d.result():
         system.append({"key": "docker", "label": "Docker (reclaimable)", "size": d.result(),
                        "fix": "docker system prune  (add -a --volumes for everything)"})
@@ -120,7 +168,8 @@ def show(user, system):
     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")
+        needs = "Administrator / PowerShell" if WINDOWS else "sudo / docker"
+        s = Table(title=f"System (needs {needs})", title_justify="left")
         s.add_column("Size", justify="right")
         s.add_column("What")
         s.add_column("Fix command", style="bold", overflow="fold")
@@ -128,7 +177,8 @@ def show(user, 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.[/]")
+        console.print("[dim]devmedic never runs system-wide commands itself — "
+                      "copy the command if you want it.[/]")
 
 
 def clean(user, keys, assume_yes=False):
@@ -154,20 +204,30 @@ def clean(user, keys, assume_yes=False):
         ok = False
         if r["cmd"] and have(r["cmd"][0]):
             try:
-                ok = subprocess.run(r["cmd"], capture_output=True, timeout=300).returncode == 0
+                ok = run_full(r["cmd"], 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"]))
+            # Try every entry (a list, not a generator: one locked file must not
+            # stop the rest from being cleaned).
+            try:
+                entries = list(os.scandir(r["path"]))
+            except OSError:
+                entries = []
+            ok = all([_remove_entry(e) for e in entries])
         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):
+def _remove_entry(entry):
+    if is_real_dir(entry):
+        return remove_tree(entry.path)
     try:
-        os.unlink(path)
+        if entry.is_dir(follow_symlinks=False):
+            os.rmdir(entry.path)  # Windows junction: remove the link, never the target
+        else:
+            os.unlink(entry.path)
         return True
     except OSError:
         return False

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/cli.py

@@ -124,21 +124,25 @@ def build_parser():
     return p
 
 
-WSL_URL = "https://learn.microsoft.com/windows/wsl/install"
+def utf8_output():
+    """Windows pipes/redirects default to a legacy code page that can't print
+    emoji or box-drawing characters; switch to UTF-8 instead of crashing."""
+    for stream in (sys.stdout, sys.stderr):
+        enc = (getattr(stream, "encoding", "") or "").lower().replace("-", "")
+        if enc != "utf8" and hasattr(stream, "reconfigure"):
+            try:
+                stream.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                pass
 
 
 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.[/]")
+        utf8_output()
+    elif not sys.platform.startswith("linux"):
+        console.print("[yellow]devmedic supports Linux and Windows; on this system "
+                      "some checks may be missing.[/]")
     if not getattr(args, "func", None):
         args.func = cmd_overview
     try:

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/dashboard.py

@@ -18,8 +18,8 @@ from rich.table import Table
 from rich.text import Text
 
 from . import caches, junk, ports, procs, repos
-from .util import (HOME, console, dir_size, have, human_age, human_size, run,
-                   short_path)
+from .util import (HOME, WINDOWS, console, dir_size, have, human_age, human_size, run,
+                   run_full, short_path)
 
 # ───────────────────────── visuals ─────────────────────────
 
@@ -93,7 +93,22 @@ def panel(body, title, color):
 
 # ───────────────────────── collectors ─────────────────────────
 
+def windows_version():
+    """'Windows 11 Pro' — platform.release() says '10' on Windows 11, so use the build."""
+    ver = platform.version()            # e.g. 10.0.22631
+    try:
+        build = int(ver.split(".")[2])
+    except (IndexError, ValueError):
+        build = 0
+    name = "11" if build >= 22000 else platform.release()
+    edition = getattr(platform, "win32_edition", lambda: "")() or ""
+    edition = {"Professional": "Pro", "Core": "Home"}.get(edition, edition)
+    return f"Windows {name} {edition}".strip()
+
+
 def os_name():
+    if WINDOWS:
+        return windows_version()
     try:
         with open("/etc/os-release") as f:
             for line in f:
@@ -104,14 +119,25 @@ def os_name():
     return platform.system()
 
 
+def tidy_cpu(name):
+    name = re.sub(r"\((R|TM)\)|CPU|Processor|\s@.*|\d+-Core", "", name)
+    return " ".join(name.split())
+
+
 def cpu_model():
+    if WINDOWS:
+        try:
+            import winreg
+            with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE,
+                                r"HARDWARE\DESCRIPTION\System\CentralProcessor\0") as k:
+                return tidy_cpu(winreg.QueryValueEx(k, "ProcessorNameString")[0])
+        except OSError:
+            pass
     try:
         with open("/proc/cpuinfo") as f:
             for line in f:
                 if line.startswith("model name"):
-                    name = line.split(":", 1)[1].strip()
-                    name = re.sub(r"\((R|TM)\)|CPU|Processor|\s@.*", "", name)
-                    return " ".join(name.split())
+                    return tidy_cpu(line.split(":", 1)[1])
     except OSError:
         pass
     return platform.processor() or "unknown CPU"
@@ -136,15 +162,32 @@ def battery():
         return None
 
 
+def load_average():
+    try:
+        return psutil.getloadavg()  # emulated on Windows (zeros on the first call)
+    except (AttributeError, OSError):
+        return (0.0, 0.0, 0.0)
+
+
+def shell_name():
+    """The shell devmedic was started from (bash, zsh, pwsh, cmd…)."""
+    try:
+        name = psutil.Process(os.getppid()).name()
+    except psutil.Error:
+        name = os.environ.get("SHELL", "")
+    name = os.path.splitext(os.path.basename(name))[0]
+    return {"powershell": "Windows PowerShell"}.get(name.lower(), name)
+
+
 def system_info():
     return {
         "user": getpass.getuser(), "host": socket.gethostname(), "os": os_name(),
-        "kernel": platform.release(), "cpu": cpu_model(),
+        "kernel": platform.version() if WINDOWS else platform.release(), "cpu": cpu_model(),
         "cores": psutil.cpu_count(logical=True),
         "phys": psutil.cpu_count(logical=False),
-        "boot": psutil.boot_time(), "load": os.getloadavg(),
+        "boot": psutil.boot_time(), "load": load_average(),
         "temp": temperature(), "battery": battery(),
-        "shell": os.path.basename(os.environ.get("SHELL", "")),
+        "shell": shell_name(),
     }
 
 
@@ -155,8 +198,10 @@ def memory_hogs(limit=5):
         if mi and p.info["name"]:
             name = p.info["name"]
             # Group chrome/chromium helpers, "Web Content", etc. under the app.
-            name = re.sub(r"^(chrome|chromium|firefox|code|electron)\b.*", r"\1", name,
-                          flags=re.I)
+            if name.lower().endswith(".exe"):
+                name = name[:-4]
+            name = re.sub(r"^(chrome|chromium|firefox|code|electron|brave|msedge)\b.*", r"\1",
+                          name, flags=re.I)
             by_name[name][0] += mi.rss
             by_name[name][1] += 1
     return sorted(((n, rss, c) for n, (rss, c) in by_name.items()),
@@ -166,7 +211,9 @@ def memory_hogs(limit=5):
 def disks():
     seen, out = set(), []
     for p in psutil.disk_partitions(all=False):
-        if p.fstype in ("squashfs", "tmpfs", "overlay") or p.device in seen:
+        if p.fstype in ("squashfs", "tmpfs", "overlay", "") or p.device in seen:
+            continue  # "" = empty CD/DVD drive on Windows
+        if "cdrom" in p.opts:
             continue
         if p.mountpoint.startswith(("/snap", "/var/snap", "/run")):
             continue
@@ -181,7 +228,8 @@ def disks():
 
 
 TOOLS = [  # label, version command
-    ("git", ["git", "--version"]), ("python", ["python3", "--version"]),
+    ("git", ["git", "--version"]),
+    ("python", ["python", "--version"] if WINDOWS else ["python3", "--version"]),
     ("pip", ["pip3", "--version"]), ("node", ["node", "--version"]),
     ("npm", ["npm", "--version"]), ("pnpm", ["pnpm", "--version"]),
     ("yarn", ["yarn", "--version"]), ("bun", ["bun", "--version"]),
@@ -192,6 +240,10 @@ TOOLS = [  # label, version command
     ("gh", ["gh", "--version"]), ("code", ["code", "--version"]),
     ("nvim", ["nvim", "--version"]), ("vim", ["vim", "--version"]),
 ]
+if WINDOWS:
+    TOOLS = [t for t in TOOLS if t[0] not in ("gcc", "make", "vim")] + [
+        ("pwsh", ["pwsh", "--version"]), ("winget", ["winget", "--version"]),
+        ("wsl", ["wsl", "--version"]), ("dotnet", ["dotnet", "--version"])]
 VERSION_RE = re.compile(r"(\d+\.\d+(?:\.\d+)?)")
 
 
@@ -199,11 +251,13 @@ def tool_version(cmd):
     if not have(cmd[0]):
         return None
     try:
-        r = subprocess.run(cmd, capture_output=True, text=True, timeout=4)
+        r = run_full(cmd, timeout=4)
     except (OSError, subprocess.SubprocessError):
         return "?"
-    m = VERSION_RE.search(r.stdout + r.stderr)
-    return m.group(1) if m else "?"
+    # No version in the output = not really installed (e.g. Windows' "python"
+    # shortcut that just opens the Microsoft Store).
+    m = VERSION_RE.search((r.stdout + r.stderr).replace("\x00", ""))
+    return m.group(1) if m else None
 
 
 def dev_tools():
@@ -216,8 +270,8 @@ def docker_status():
     if not have("docker"):
         return {"state": "missing"}
     try:
-        r = subprocess.run(["docker", "ps", "--format", "{{.Names}}\t{{.Image}}\t{{.Status}}"],
-                           capture_output=True, text=True, timeout=5)
+        r = run_full(["docker", "ps", "--format", "{{.Names}}\t{{.Image}}\t{{.Status}}"],
+                     timeout=5)
     except (OSError, subprocess.SubprocessError):
         return {"state": "down"}
     if "permission denied" in r.stderr.lower():
@@ -232,21 +286,34 @@ def network():
     ips = []
     stats = psutil.net_if_stats()
     for name, addrs in psutil.net_if_addrs().items():
-        if name == "lo" or name.startswith(("docker", "br-", "veth", "virbr")):
+        if name == "lo" or name.startswith(("docker", "br-", "veth", "virbr", "Loopback",
+                                             "vEthernet", "VirtualBox", "VMware")):
             continue
         if name in stats and not stats[name].isup:
             continue
         for a in addrs:
-            if a.family == socket.AF_INET:
+            if a.family == socket.AF_INET and not a.address.startswith("169.254."):
                 ips.append((name, a.address))
-    wifi = None
-    if have("nmcli"):
-        for line in run(["nmcli", "-t", "-f", "active,ssid", "dev", "wifi"], timeout=3).splitlines():
-            if line.startswith("yes:"):
-                wifi = line[4:] or None
-                break
     io = psutil.net_io_counters()
-    return {"ips": ips, "wifi": wifi, "sent": io.bytes_sent, "recv": io.bytes_recv}
+    return {"ips": ips, "wifi": wifi_name(), "sent": io.bytes_sent, "recv": io.bytes_recv}
+
+
+def wifi_name():
+    if WINDOWS:
+        # "    SSID                   : MyNetwork"  (skip the BSSID line)
+        for line in run(["netsh", "wlan", "show", "interfaces"], timeout=4).splitlines():
+            key, _, value = line.partition(":")
+            if key.strip() == "SSID" and value.strip():
+                return value.strip()
+        return None
+    if have("nmcli"):
+        # Active connections only — `nmcli dev wifi` may trigger a slow rescan.
+        for line in run(["nmcli", "-t", "-f", "NAME,TYPE", "connection", "show", "--active"],
+                        timeout=3).splitlines():
+            name, _, kind = line.rpartition(":")
+            if kind == "802-11-wireless" and name:
+                return name.replace("\\:", ":")
+    return None
 
 
 def git_summary():
@@ -329,13 +396,17 @@ def health(d):
     if stale:
         hit(3 * len(stale), f"{len(stale)} dev server(s) running > 1 day → [bold]devmedic ports[/]")
     if d["docker"]["state"] == "denied":
-        hit(2, "Docker needs sudo → [bold]sudo usermod -aG docker $USER[/] then log out/in")
+        hit(2, DOCKER_FIX)
     bat = d["sys"]["battery"]
     if bat and not bat.power_plugged and bat.percent < 20:
         tips.append(f"[yellow]Battery low ({bat.percent:.0f}%)[/] — plug in before long builds")
     return max(score, 0), tips
 
 
+DOCKER_FIX = ("Docker isn't reachable → start [bold]Docker Desktop[/]" if WINDOWS else
+              "Docker needs sudo → [bold]sudo usermod -aG docker $USER[/] then log out/in")
+
+
 def grade(score):
     for limit, g, color in ((90, "A", "green"), (75, "B", "cyan"), (60, "C", "yellow")):
         if score >= limit:
@@ -350,7 +421,7 @@ def header(d, score):
     g, color = grade(score)
     info = Text.assemble(
         (f"{s['user']}", "bold cyan"), ("@", "grey50"), (f"{s['host']}\n", "bold magenta"),
-        (f"{s['os']}", "bold"), (f"  ·  kernel {s['kernel']}\n", "grey62"),
+        (f"{s['os']}", "bold"), (f"  ·  {'build' if WINDOWS else 'kernel'} {s['kernel']}\n", "grey62"),
         (f"up {human_age(s['boot']).replace(' ago', '')}", "green"),
         (f"  ·  {s['shell'] or 'shell ?'}  ·  {time.strftime('%a %d %b %H:%M')}", "grey62"),
     )

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/junk.py

@@ -6,7 +6,7 @@ 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,
+from .util import (HOME, confirm, console, dir_size, display_path, is_real_dir, human_age, human_size,
                    remove_tree, short_path, size_style)
 
 # name -> (kind, check) ; check(parent_dir, junk_dir) says whether it's really junk
@@ -45,7 +45,9 @@ 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"}
+SKIP_AT_TOP = {"go", "proc", "sys", "dev", "run", "tmp", "boot", "lost+found",
+               # Windows: app data, cloud-synced folders (scanning can trigger downloads)
+               "AppData", "OneDrive", "iCloudDrive", "Dropbox", "scoop"}
 
 
 def find(root, max_depth=8):
@@ -59,13 +61,13 @@ def find(root, max_depth=8):
         except OSError:
             continue
         for e in entries:
-            if not e.is_dir(follow_symlinks=False):
+            if not is_real_dir(e):
                 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, "/")
+            at_top = current == HOME or os.path.dirname(current) == current  # ~ or a drive root
             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))
@@ -76,13 +78,14 @@ def project_last_touched(junk_path):
     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
+        with os.scandir(parent) as it:
+            for e in it:
+                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

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/menu.py

@@ -9,7 +9,7 @@ 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
+from .util import WINDOWS, console, human_size, short_path
 
 # ───────────────────────── section details ─────────────────────────
 
@@ -50,8 +50,7 @@ def detail_tools(d):
             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.")
+        console.print(db.DOCKER_FIX)
 
 
 def detail_projects(d):
@@ -188,7 +187,29 @@ KEYS = {b"\x1b[A": "up", b"\x1bOA": "up", b"k": "up",
         b"r": "refresh", b"a": "all", b"w": "watch", b"\x1b[H": "home", b"\x1b[F": "end"}
 
 
+# Windows (msvcrt) sends special keys as a prefix + one letter.
+WINDOWS_KEYS = {"H": "up", "P": "down", "M": "enter", "K": "back", "G": "home", "O": "end"}
+
+
+def decode_windows_key(first, second=""):
+    """Map msvcrt.getwch() output to our key names (pure, so it's testable anywhere)."""
+    if first in ("\x00", "\xe0"):
+        return WINDOWS_KEYS.get(second, "other")
+    if first == "\x03":
+        raise KeyboardInterrupt
+    if first.isdigit():
+        return first
+    return KEYS.get(first.encode("utf-8", "ignore"), "other")
+
+
 def read_key():
+    if WINDOWS:
+        import msvcrt
+
+        first = msvcrt.getwch()
+        second = msvcrt.getwch() if first in ("\x00", "\xe0") else ""
+        return decode_windows_key(first, second)
+
     import termios  # POSIX only — imported here so the package loads everywhere
     import tty
 

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/ports.py

@@ -1,19 +1,28 @@
 """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
+from .util import WINDOWS, confirm, console, is_mine, 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"}
+              11434: "Ollama", 135: "Windows RPC", 139: "NetBIOS", 445: "SMB file sharing",
+              5040: "Windows CDP", 7680: "Delivery Optimization"}
+
+
+def admin_hint(pid=None, port=None):
+    """How to do something as root/Administrator on this OS."""
+    if WINDOWS:
+        if pid:
+            return f"run PowerShell as Administrator: [bold]Stop-Process -Id {pid} -Force[/]"
+        return (f"run PowerShell as Administrator: "
+                f"[bold]Get-NetTCPConnection -LocalPort {port} | Select OwningProcess[/]")
+    if pid:
+        return f"try: [bold]sudo kill {pid}[/]"
+    return f"try: [bold]sudo ss -ltnp 'sport = :{port}'[/]"
 
 
 def listening(include_system=False):
@@ -35,14 +44,16 @@ def listening(include_system=False):
                 "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
+                # as_dict: fields we're not allowed to read come back as None
+                # instead of aborting (common on Windows for other users' processes).
+                d = psutil.Process(c.pid).as_dict(["name", "cmdline", "username", "cwd"])
+            except (psutil.NoSuchProcess, psutil.ZombieProcess):
+                d = {}
+            info["name"] = d.get("name") or info["name"]
+            info["cmd"] = " ".join(" ".join(d.get("cmdline") or []).split())
+            info["user"] = d.get("username") or ""
+            info["mine"] = is_mine(info["user"])
+            info["cwd"] = d.get("cwd") or ""
         rows[key] = info
     result = sorted(rows.values(), key=lambda r: r["port"])
     if not include_system:
@@ -87,14 +98,14 @@ def kill(port, force=False, assume_yes=False):
     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}'[/]")
+                          f"(probably a system service).[/] To find it, {admin_hint(port=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.[/]")
+                          f"you may need {'Administrator rights' if WINDOWS else 'sudo'}.[/]")
         if not confirm("Kill it?", assume_yes):
             continue
         status |= terminate(r["pid"], force)
@@ -117,7 +128,7 @@ def terminate(pid, force=False):
     except psutil.NoSuchProcess:
         pass
     except psutil.AccessDenied:
-        console.print(f"[red]Permission denied.[/] Try: [bold]sudo kill {pid}[/]")
+        console.print(f"[red]Permission denied.[/] To force it, {admin_hint(pid=pid)}")
         return 1
     except psutil.TimeoutExpired:
         console.print(f"[red]PID {pid} is still alive.[/]")

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/procs.py

@@ -6,7 +6,7 @@ from collections import defaultdict
 import psutil
 from rich.table import Table
 
-from .util import HOME, console, human_age, human_size, short_path, size_style
+from .util import HOME, console, human_age, human_size, is_mine, short_path, size_style
 
 DEV_NAMES = {"node", "python", "python3", "java", "ruby", "go", "cargo", "rustc",
              "deno", "bun", "php", "dotnet", "gradle", "mvn", "npm", "pnpm", "yarn",
@@ -21,7 +21,10 @@ 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
+    if not cmdline:
+        return False
+    exe = os.path.basename(cmdline[0].replace("\\", "/")).lower()
+    return exe in DEV_NAMES or os.path.splitext(exe)[0] in DEV_NAMES
 
 
 def collect():
@@ -32,12 +35,12 @@ def collect():
                 ports[c.pid].add(c.laddr.port)
     except (psutil.AccessDenied, OSError):
         pass
-    me, self_pid = os.getuid(), os.getpid()
+    self_pid = os.getpid()
     rows = []
     for p in psutil.process_iter(["pid", "name", "cmdline", "memory_info", "create_time",
-                                  "uids", "cwd", "cpu_percent"]):
+                                  "username", "cwd"]):
         info = p.info
-        if not info["uids"] or info["uids"].real != me or info["pid"] == self_pid:
+        if info["pid"] == self_pid or not is_mine(info["username"]):
             continue
         if not is_dev(info["name"] or "", info["cmdline"] or []):
             continue

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/repos.py

@@ -7,7 +7,7 @@ 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
+from .util import HOME, console, display_path, human_age, is_real_dir, run_full, short_path
 
 
 def find(root, max_depth=6):
@@ -22,9 +22,9 @@ def find(root, max_depth=6):
             entries = list(os.scandir(current))
         except OSError:
             continue
-        at_top = current in (HOME, "/")
+        at_top = current == HOME or os.path.dirname(current) == current  # ~ or a drive root
         for e in entries:
-            if (depth < max_depth and e.is_dir(follow_symlinks=False)
+            if (depth < max_depth and is_real_dir(e)
                     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))
@@ -32,8 +32,7 @@ def find(root, max_depth=6):
 
 def git(repo, *args):
     try:
-        r = subprocess.run(["git", "-C", repo, *args], capture_output=True, text=True,
-                           timeout=15)
+        r = run_full(["git", "-C", repo, *args])
         return r.stdout if r.returncode == 0 else ""
     except (OSError, subprocess.SubprocessError):
         return ""

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic/util.py

@@ -1,13 +1,38 @@
-"""Shared helpers: sizes, ages, confirmation prompts."""
+"""Shared helpers: sizes, ages, confirmation prompts, cross-platform bits."""
+import getpass
 import os
 import shutil
+import stat
 import subprocess
+import sys
 import time
 
 from rich.console import Console
 
 console = Console()
 HOME = os.path.expanduser("~")
+WINDOWS = sys.platform == "win32"
+_REPARSE_POINT = getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400)
+
+
+def is_real_dir(entry):
+    """A directory we may descend into: not a symlink, and on Windows not a
+    junction/reparse point (pnpm and Windows itself use junctions)."""
+    try:
+        if not entry.is_dir(follow_symlinks=False):
+            return False
+        if WINDOWS:
+            attrs = entry.stat(follow_symlinks=False).st_file_attributes
+            return not attrs & _REPARSE_POINT
+    except OSError:
+        return False
+    return True
+
+
+def file_bytes(st):
+    """Bytes a file really occupies on disk (st_blocks isn't available on Windows)."""
+    blocks = getattr(st, "st_blocks", None)
+    return blocks * 512 if blocks is not None else st.st_size
 
 
 def dir_size(path):
@@ -24,16 +49,19 @@ def dir_size(path):
                         st = entry.stat(follow_symlinks=False)
                     except OSError:
                         continue
-                    if entry.is_dir(follow_symlinks=False):
+                    if is_real_dir(entry):
                         stack.append(entry.path)
                         continue
-                    # Hardlinked files (pnpm store, etc.) count once.
+                    if entry.is_dir(follow_symlinks=False):
+                        continue  # junction: don't follow, don't count
+                    # Hardlinked files (pnpm store, etc.) count once. On Windows
+                    # scandir doesn't report link counts, so this is Linux/macOS only.
                     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
+                    total += file_bytes(st)
         except OSError:
             continue
     return total
@@ -90,12 +118,22 @@ def confirm(question, assume_yes=False):
     return answer.strip().lower() in ("y", "yes")
 
 
+def resolve(cmd):
+    """Full path for cmd[0] so Windows can launch npm.cmd, yarn.cmd, etc."""
+    exe = shutil.which(cmd[0])
+    return [exe, *cmd[1:]] if exe else list(cmd)
+
+
+def run_full(cmd, timeout=15):
+    """subprocess.run with text output that never fails on odd encodings."""
+    return subprocess.run(resolve(cmd), capture_output=True, text=True,
+                          errors="replace", timeout=timeout)
+
+
 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
+        return run_full(cmd, timeout).stdout
     except (OSError, subprocess.SubprocessError):
         return ""
 
@@ -104,6 +142,32 @@ def have(binary):
     return shutil.which(binary) is not None
 
 
+def current_user():
+    try:
+        return getpass.getuser().lower()
+    except Exception:  # no USER/USERNAME and no pwd entry
+        return ""
+
+
+def is_mine(username):
+    """Does a process owner string (e.g. 'alice' or 'LAPTOP\\alice') mean us?"""
+    if not username:
+        return False
+    return username.lower().rsplit("\\", 1)[-1] == current_user()
+
+
+def _force_remove(func, path, _exc):
+    # Windows refuses to delete read-only files (e.g. git objects): clear the flag, retry.
+    try:
+        os.chmod(path, stat.S_IWRITE)
+        func(path)
+    except OSError:
+        pass
+
+
 def remove_tree(path):
-    shutil.rmtree(path, ignore_errors=True)
+    if sys.version_info >= (3, 12):
+        shutil.rmtree(path, onexc=_force_remove)
+    else:
+        shutil.rmtree(path, onerror=_force_remove)
     return not os.path.exists(path)

{devmedic-0.2.0 → devmedic-0.3.0}/devmedic.egg-info/PKG-INFO

@@ -1,15 +1,16 @@
 Metadata-Version: 2.4
 Name: devmedic
-Version: 0.2.0
+Version: 0.3.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
+Keywords: developer-tools,cli,linux,ubuntu,windows,cleanup,ports,disk-usage
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Software Development
 Classifier: Topic :: System :: Monitoring
@@ -47,16 +48,24 @@ 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.
+Works on **Linux** (built on Ubuntu) and **Windows 10/11**, with **Python 3.9+**.
 
 **With pipx (recommended)**
 
+Linux:
+
 ```bash
 sudo apt install pipx && pipx ensurepath        # once
 pipx install devmedic
 ```
 
+Windows (PowerShell or Windows Terminal):
+
+```powershell
+py -m pip install --user pipx; py -m pipx ensurepath   # once, then open a new terminal
+pipx install devmedic
+```
+
 **With pip**
 
 ```bash
@@ -115,7 +124,10 @@ 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.
+- **Links are never followed:** symlinks and Windows junctions (used by pnpm) are skipped when
+  scanning and removed as links, so nothing outside the folder is ever deleted.
+- **Never runs `sudo` or Administrator commands.** System fixes (journal, apt, snap, Recycle Bin,
+  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.
 

{devmedic-0.2.0 → devmedic-0.3.0}/pyproject.toml

@@ -10,12 +10,13 @@ readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.9"
 dependencies = ["psutil>=5.8", "rich>=12.0"]
-keywords = ["developer-tools", "cli", "linux", "ubuntu", "cleanup", "ports", "disk-usage"]
+keywords = ["developer-tools", "cli", "linux", "ubuntu", "windows", "cleanup", "ports", "disk-usage"]
 classifiers = [
     "Environment :: Console",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
     "Programming Language :: Python :: 3",
     "Topic :: Software Development",
     "Topic :: System :: Monitoring",

{devmedic-0.2.0 → devmedic-0.3.0}/tests/test_devmedic.py

@@ -10,7 +10,14 @@ import time
 import unittest
 from contextlib import redirect_stdout
 
-from devmedic import caches, cli, junk, ports, repos, util
+from devmedic import caches, cli, junk, menu, ports, repos, util
+
+WINDOWS = sys.platform == "win32"
+
+
+def rel(path, root):
+    """Relative path with forward slashes, so expectations work on every OS."""
+    return os.path.relpath(path, root).replace(os.sep, "/")
 
 
 def write(path, size=1000):
@@ -33,6 +40,7 @@ class UtilTests(unittest.TestCase):
         with self.assertRaises(ValueError):
             junk.parse_selection("abc", 3)
 
+    @unittest.skipIf(WINDOWS, "scandir doesn't report hardlink counts on Windows")
     def test_dir_size_counts_hardlinks_once(self):
         with tempfile.TemporaryDirectory() as d:
             write(os.path.join(d, "a"), 100_000)
@@ -59,14 +67,15 @@ class JunkTests(unittest.TestCase):
         shutil.rmtree(self.root, ignore_errors=True)
 
     def found(self):
-        return sorted(os.path.relpath(p, self.root) for p, _ in junk.find(self.root))
+        return sorted(rel(p, self.root) for p, _ in junk.find(self.root))
 
     def test_detects_only_real_junk(self):
         self.assertEqual(self.found(), ["py2/.venv", "rust/target", "web/node_modules"])
 
     def test_clean_deletes_only_selected(self):
         items = junk.scan(self.root)
-        target = [i for i in items if i["path"].endswith("rust/target")]
+        target = [i for i in items if rel(i["path"], self.root) == "rust/target"]
+        self.assertEqual(len(target), 1)
         with redirect_stdout(io.StringIO()):
             junk.clean(target, assume_yes=True)
         self.assertFalse(os.path.exists(os.path.join(self.root, "rust", "target")))
@@ -78,7 +87,7 @@ class JunkTests(unittest.TestCase):
         old = os.path.join(self.root, "web", "package.json")
         past = time.time() - 90 * 86400
         os.utime(old, (past, past))
-        paths = [os.path.relpath(i["path"], self.root) for i in junk.scan(self.root, 30)]
+        paths = [rel(i["path"], self.root) for i in junk.scan(self.root, 30)]
         self.assertEqual(paths, ["web/node_modules"])
 
 
@@ -173,24 +182,69 @@ class CacheTests(unittest.TestCase):
             shutil.rmtree(u["path"])
 
 
-class WindowsTests(unittest.TestCase):
-    """Native Windows isn't supported yet: it must fail politely, not crash."""
-
-    def test_friendly_message_on_windows(self):
-        code = (
-            "import sys\n"
-            "sys.modules['termios'] = None\n"   # simulate: module doesn't exist
-            "sys.modules['tty'] = None\n"
-            "from devmedic import cli\n"         # must import without termios
-            "sys.platform = 'win32'\n"
-            "sys.exit(cli.main([]))\n"
-        )
-        env = dict(os.environ, COLUMNS="100")
-        r = subprocess.run([sys.executable, "-c", code], capture_output=True, text=True,
-                           env=env, cwd=os.path.dirname(os.path.dirname(__file__)))
-        self.assertEqual(r.returncode, 1, r.stderr)
-        self.assertNotIn("Traceback", r.stderr)
-        self.assertIn("WSL", r.stdout)
+class CrossPlatformTests(unittest.TestCase):
+    def test_is_mine(self):
+        me = util.current_user()
+        self.assertTrue(util.is_mine(me))
+        self.assertTrue(util.is_mine("SOME-PC\\" + me.upper()))  # Windows DOMAIN\user
+        self.assertFalse(util.is_mine("definitely-not-" + me))
+        self.assertFalse(util.is_mine(None))
+
+    def test_windows_key_decoding(self):
+        d = menu.decode_windows_key
+        self.assertEqual(d("\xe0", "H"), "up")
+        self.assertEqual(d("\x00", "P"), "down")
+        self.assertEqual(d("\r"), "enter")
+        self.assertEqual(d("q"), "quit")
+        self.assertEqual(d("7"), "7")
+        self.assertEqual(d("\xe0", "Z"), "other")
+        with self.assertRaises(KeyboardInterrupt):
+            d("\x03")
+
+    def test_utf8_output_survives_legacy_encoding(self):
+        buf = io.TextIOWrapper(io.BytesIO(), encoding="cp1252")
+        old = sys.stdout
+        try:
+            sys.stdout = buf
+            cli.utf8_output()
+            print("🩺 ████ ╭─╮")  # would raise UnicodeEncodeError in cp1252
+            buf.flush()
+        finally:
+            sys.stdout = old
+        self.assertIn("🩺".encode("utf-8"), buf.buffer.getvalue())
+
+
+@unittest.skipUnless(WINDOWS, "Windows junctions")
+class JunctionTests(unittest.TestCase):
+    """pnpm and Windows use junctions; we must never follow or delete through them."""
+
+    def setUp(self):
+        self.root = tempfile.mkdtemp()
+        self.target = os.path.join(self.root, "real")
+        write(os.path.join(self.target, "node_modules", "pkg", "big"), 200_000)
+        write(os.path.join(self.target, "package.json"))
+        self.link = os.path.join(self.root, "link")
+        subprocess.run(["cmd", "/c", "mklink", "/J", self.link, self.target], check=True,
+                       capture_output=True)
+
+    def tearDown(self):
+        subprocess.run(["cmd", "/c", "rmdir", self.link], capture_output=True)
+        shutil.rmtree(self.root, ignore_errors=True)
+
+    def test_scan_does_not_follow_junction(self):
+        found = sorted(rel(p, self.root) for p, _ in junk.find(self.root))
+        self.assertEqual(found, ["real/node_modules"])
+
+    def test_size_ignores_junction(self):
+        with_link = util.dir_size(self.root)
+        self.assertLess(with_link, 2 * util.dir_size(self.target))
+
+    def test_removing_junction_keeps_target(self):
+        with os.scandir(self.root) as it:
+            entry = next(e for e in it if e.name == "link")
+        self.assertTrue(caches._remove_entry(entry))
+        self.assertFalse(os.path.exists(self.link))
+        self.assertTrue(os.path.exists(os.path.join(self.target, "node_modules", "pkg", "big")))
 
 
 class SmokeTests(unittest.TestCase):

devmedic-0.2.0/devmedic/__init__.py

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