fixos 2.2.52__tar.gz → 2.2.53__tar.gz

{fixos-2.2.52 → fixos-2.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixos
-Version: 2.2.52
+Version: 2.2.53
 Summary: AI-powered Linux/Windows diagnostics and repair – audio, hardware, system issues
 Home-page: https://github.com/wronai/fixos
 Author: fixos contributors

fixos-2.2.53/VERSION

@@ -0,0 +1 @@
+2.2.53

{fixos-2.2.52 → fixos-2.2.53}/fixos/cli/_cleanup_space.py

@@ -52,6 +52,31 @@ def _run_cmd(argv: list[str], timeout: int = 60) -> subprocess.CompletedProcess:
     return subprocess.run(argv, capture_output=True, text=True, timeout=timeout, check=False)
 
 
+_DU_BATCH = 512
+
+
+def _dir_sizes(paths: list[Path]) -> dict[str, int]:
+    """Sizes in bytes for many directories with one ``du`` per batch.
+
+    ``--count-links`` keeps each directory independent of the others, as a
+    separate ``du`` would be; NUL-terminated output survives any file name.
+    Paths missing from the result must be measured individually.
+    """
+    sizes: dict[str, int] = {}
+    for start in range(0, len(paths), _DU_BATCH):
+        batch = [str(path) for path in paths[start : start + _DU_BATCH]]
+        try:
+            result = _run_cmd(["du", "-sbl0", "--", *batch], timeout=300)
+        except (OSError, subprocess.TimeoutExpired):
+            continue
+        # du exits 1 when some subtree is unreadable but still prints totals.
+        for record in result.stdout.split("\0"):
+            size, sep, name = record.partition("\t")
+            if sep and size.isdigit():
+                sizes[name] = int(size)
+    return sizes
+
+
 def _dir_size(path: Path) -> int:
     """Return directory size in bytes (du -sb with a Python fallback)."""
     try:
@@ -876,6 +901,7 @@ def _scan_tmp(
     cutoff_seconds = days * 86400
     tmp_path = Path(tmp_dir) if tmp_dir is not None else Path("/tmp")
     candidates = []
+    directories = []
 
     if tmp_path.is_dir():
         try:
@@ -893,23 +919,29 @@ def _scan_tmp(
                     mtime = stat_val.st_mtime
                     age_seconds = now - mtime
                     if age_seconds >= cutoff_seconds:
-                        size = (
-                            stat_val.st_size if not item.is_dir() else _dir_size(item)
-                        )
+                        is_dir = stat_module.S_ISDIR(stat_val.st_mode)
                         age_days = age_seconds / 86400
                         candidates.append({
                             "description": f"{name} (wiek: {age_days:.1f} dni)",
                             "path": item,
                             "name": name,
-                            "size_bytes": size,
+                            "size_bytes": 0 if is_dir else stat_val.st_size,
                             "note": f"{age_days:.1f} dni",
                             "age_days": age_days,
                         })
+                        if is_dir:
+                            directories.append(candidates[-1])
                 except (OSError, PermissionError):
                     continue
         except (OSError, PermissionError):
             pass
 
+    # One `du` per directory meant thousands of processes on a busy /tmp.
+    sizes = _dir_sizes([c["path"] for c in directories])
+    for candidate in directories:
+        size = sizes.get(str(candidate["path"]))
+        candidate["size_bytes"] = size if size is not None else _dir_size(candidate["path"])
+
     return candidates
 
 

{fixos-2.2.52 → fixos-2.2.53}/fixos/cli/cleanup_cmd.py

@@ -129,11 +129,7 @@ def _clean_terminal_input(value: str) -> str:
 
 def _display_service_item(svc: dict) -> None:
     """Display a single service item with details."""
-    size_str = (
-        f"{svc['size_gb']:.2f} GB"
-        if svc["size_gb"] >= 1
-        else f"{svc['size_mb']:.0f} MB"
-    )
+    size_str = _size_str(svc)
     risk = svc.get("risk_level") or ("safe" if svc["safe_to_cleanup"] else "review")
     safe_text, safe_color = _RISK_LABELS.get(risk, _RISK_LABELS["review"])
 
@@ -164,6 +160,8 @@ def _display_service_item(svc: dict) -> None:
                     )
             else:
                 click.echo(f"   Komponenty: {svc['details']['components']}")
+        elif svc["service_type"] == "docker" and svc["details"].get("fast_inventory"):
+            _display_docker_inventory(svc["details"]["fast_inventory"])
         elif svc["service_type"] == "ollama" and svc["details"].get("models"):
             models = svc["details"]["models"]
             if models:
@@ -173,6 +171,26 @@ def _display_service_item(svc: dict) -> None:
     click.echo()
 
 
+def _display_docker_inventory(inventory: dict) -> None:
+    """Show what a timed-out `docker system df` could not size."""
+    click.echo("   Docker — szybki spis (bez rozmiarów wolumenów):")
+    pairs = (
+        ("obrazy", "images", "dangling_images", "wiszących"),
+        ("kontenery", "containers", "stopped_containers", "zatrzymanych"),
+        ("wolumeny", "volumes", "dangling_volumes", "nieużywanych — dane, tylko ręcznie"),
+    )
+    for label, total_key, part_key, part_label in pairs:
+        if total_key in inventory:
+            part = inventory.get(part_key)
+            suffix = f" ({part} {part_label})" if part is not None else ""
+            click.echo(f"     • {label}: {inventory[total_key]}{suffix}")
+    if "build_cache_total_gb" in inventory:
+        click.echo(
+            f"     • cache buildów: {inventory['build_cache_total_gb']:.2f} GB "
+            f"(odzyskiwalne {inventory.get('build_cache_reclaimable_gb', 0):.2f} GB)"
+        )
+
+
 def _error_message(result: dict) -> str:
     """Human-readable failure reason, even when the command's own stderr was
     empty (e.g. suppressed with 2>/dev/null inside the cleanup command

{fixos-2.2.52 → fixos-2.2.53}/fixos/config.py

@@ -128,7 +128,8 @@ PROVIDER_DEFAULTS = {
         "description": "Cerebras – najszybsze wnioskowanie na świecie, darmowy tier",
     },
     "ollama": {
-        "base_url": "http://localhost:11434/v1",
+        # Resolved from OLLAMA_HOST at load time, see ollama_host_url().
+        "base_url": None,
         "model": "llama3.2",
         "key_env": None,
         "key_url": "https://ollama.com/download",
@@ -142,6 +143,22 @@ _OPENROUTER_MODEL_MIGRATIONS = {
 }
 
 
+DEFAULT_OLLAMA_HOST = "127.0.0.1:11434"
+
+
+def ollama_host_url() -> str:
+    """Ollama server URL from ``OLLAMA_HOST`` (the variable Ollama itself reads).
+
+    Single source for every fixOS component talking to Ollama: the LLM
+    provider and model cleanup previously disagreed when OLLAMA_HOST pointed
+    to another host.
+    """
+    host = os.environ.get("OLLAMA_HOST", "").strip() or DEFAULT_OLLAMA_HOST
+    if "://" not in host:
+        host = f"http://{host}"
+    return host.rstrip("/")
+
+
 def _normalize_model_id(provider: str, model: str) -> str:
     """Normalize provider-specific model IDs without changing valid choices."""
     normalized = model.strip()
@@ -293,7 +310,12 @@ class FixOsConfig:
 
         # Base URL
         url_env_key = f"{cfg.provider.upper()}_BASE_URL"
-        cfg.base_url = base_url or os.environ.get(url_env_key) or pdef["base_url"]
+        cfg.base_url = (
+            base_url
+            or os.environ.get(url_env_key)
+            or pdef["base_url"]
+            or (f"{ollama_host_url()}/v1" if cfg.provider == "ollama" else None)
+        )
 
         # Transport Gemini: natywne API Google albo endpoint OpenAI-compatible
         cfg.gemini_transport = os.environ.get("GEMINI_TRANSPORT", "native").lower()

{fixos-2.2.52 → fixos-2.2.53}/fixos/diagnostics/native_scan.py

@@ -69,9 +69,19 @@ def measure_tree(
 
 
 def measure_batch(
-    paths: list[Path], exclude: tuple[str, ...] = (), *, native: bool = True
+    paths: list[Path],
+    exclude: tuple[str, ...] = (),
+    *,
+    native: bool = True,
+    timeout: float = 120,
+    python_fallback: bool = True,
 ) -> dict[str, dict]:
-    """Measure multiple paths, accelerating with Rust batch measurement if available."""
+    """Measure multiple paths, accelerating with Rust batch measurement if available.
+
+    Results are keyed by the resolved path.  ``python_fallback=False`` returns
+    ``{}`` instead of an unbounded Python walk when the native batch is
+    missing, fails or exceeds ``timeout``; time-budgeted callers use it.
+    """
     if not paths:
         return {}
     if native:
@@ -84,7 +94,7 @@ def measure_batch(
                         [str(executable), "batch-measure", *abs_paths],
                         capture_output=True,
                         text=True,
-                        timeout=120,
+                        timeout=timeout,
                         check=True,
                     )
                     data = json.loads(result.stdout)
@@ -103,6 +113,8 @@ def measure_batch(
                             return res
                 except (OSError, ValueError, subprocess.SubprocessError):
                     pass
+    if not python_fallback:
+        return {}
     return {str(p.resolve()): measure_python(p, exclude) for p in paths}
 
 

{fixos-2.2.52 → fixos-2.2.53}/fixos/diagnostics/quick_snapshot.py

@@ -348,11 +348,15 @@ def _measure_caches(
             from fixos.diagnostics.native_scan import measure_batch
 
             unique_paths = list({path for _, path in jobs})
-            batch_result = measure_batch(unique_paths)
+            # The native batch had a 120 s limit and an unbounded Python
+            # fallback; on a busy disk that turned "quick" into minutes.
+            batch_result = measure_batch(
+                unique_paths, timeout=timeout * 2, python_fallback=False
+            )
             if isinstance(batch_result, dict) and batch_result:
                 unresolved_jobs: list[tuple[CacheRule, Path]] = []
                 for rule, path in jobs:
-                    m = batch_result.get(str(path))
+                    m = batch_result.get(str(path.resolve()))
                     if isinstance(m, dict) and "bytes" in m:
                         kib = (m["bytes"] + 1023) // 1024
                         measured.setdefault(rule.id, []).append((path, kib))
@@ -569,6 +573,28 @@ def _history_row(
     }
 
 
+def _fill_from_history(
+    items: list[dict[str, Any]], history: list[dict[str, Any]]
+) -> None:
+    """Show the last complete size for caches that missed the time budget.
+
+    The item stays ``complete: False`` so growth reports never compare it.
+    """
+    for item in items:
+        if item.get("complete", True):
+            continue
+        for row in reversed(history):
+            if row.get("cache_complete", {}).get(item["id"]) and item["id"] in row.get(
+                "cache_sizes", {}
+            ):
+                size = int(row["cache_sizes"][item["id"]])
+                if size > item["size_bytes"]:
+                    item["size_bytes"] = size
+                    item["size_gb"] = round(size / 1024**3, 3)
+                item["last_complete_at"] = row.get("generated_at")
+                break
+
+
 def _parse_timestamp(row: dict[str, Any]) -> datetime | None:
     try:
         parsed = datetime.fromisoformat(str(row["generated_at"]))
@@ -836,6 +862,9 @@ def collect_quick_snapshot(
     history_path = _state_dir(state_dir) / "quick-history.json"
     history = _load_history(history_path)
     current_row = _history_row(generated_at, resources, safe_items, review_items)
+    _fill_from_history(safe_items + review_items, history)
+    safe_items.sort(key=lambda item: item["size_bytes"], reverse=True)
+    review_items.sort(key=lambda item: item["size_bytes"], reverse=True)
     growth = _growth_report(history, current_row, now, max(1, hours))
     alerts = _alerts(resources, growth, thresholds)
 

{fixos-2.2.52 → fixos-2.2.53}/fixos/diagnostics/service_cleanup.py

@@ -8,6 +8,7 @@ import os
 import re
 import shlex
 import shutil
+import stat
 import subprocess
 import urllib.error
 import urllib.request
@@ -341,10 +342,9 @@ class ServiceCleaner:
 
     @staticmethod
     def _ollama_base_url() -> str:
-        host = os.environ.get("OLLAMA_HOST", "127.0.0.1:11434").strip()
-        if "://" not in host:
-            host = f"http://{host}"
-        return host.rstrip("/")
+        from ..config import ollama_host_url
+
+        return ollama_host_url()
 
     @staticmethod
     def _parse_ollama_modified_at(value: str) -> datetime:
@@ -1480,6 +1480,16 @@ class ServiceCleaner:
                 result["estimated_max_gb"] = estimated_gb
                 return result
 
+            planned_paths = service.details.get("paths") or [service.path]
+            # uv/pnpm/conda caches hardlink files into environments; deleting
+            # the cache link frees nothing while another link survives.
+            measure_shared = service_enum != ServiceType.DOCKER
+            shared_before_gb = (
+                self._shared_hardlink_bytes(planned_paths) / 1024**3
+                if measure_shared
+                else 0.0
+            )
+
             # Execute cleanup
             cleanup_result = subprocess.run(
                 service.cleanup_command,
@@ -1492,7 +1502,6 @@ class ServiceCleaner:
 
             # Check new size
             measure = getattr(self.scanner, "measure_service_size_mb", None)
-            planned_paths = service.details.get("paths") or [service.path]
             if callable(measure):
                 new_size_mb = sum(
                     measure(service_enum, path, refresh=True) for path in planned_paths
@@ -1502,7 +1511,14 @@ class ServiceCleaner:
                     self.scanner._get_path_size_mb(path) for path in planned_paths
                 )
             new_size_gb = new_size_mb / 1024
-            freed_gb = max(0, initial_size - new_size_gb)
+            shared_after_gb = (
+                self._shared_hardlink_bytes(planned_paths) / 1024**3
+                if measure_shared
+                else 0.0
+            )
+            freed_gb = max(
+                0, (initial_size - shared_before_gb) - (new_size_gb - shared_after_gb)
+            )
 
             result["success"] = cleanup_result.returncode == 0
             result["output"] = cleanup_result.stdout
@@ -1511,6 +1527,9 @@ class ServiceCleaner:
             result["space_freed_gb"] = round(freed_gb, 3)
             result["initial_size_gb"] = initial_size
             result["remaining_size_gb"] = round(new_size_gb, 3)
+            result["shared_hardlink_gb"] = round(
+                max(0.0, shared_before_gb - shared_after_gb), 3
+            )
 
         except Exception as e:  # noqa: BLE001 - stored in result["error"] for the caller to display
             result["error"] = str(e)
@@ -1528,6 +1547,32 @@ class ServiceCleaner:
             == "docker builder prune --force --filter until=168h"
         )
 
+    @staticmethod
+    def _shared_hardlink_bytes(paths: list[str]) -> int:
+        """Allocated bytes under ``paths`` whose inode also has links elsewhere.
+
+        Removing such a link does not return blocks to the filesystem, so it
+        must not count as freed space.  Links inside the measured trees are
+        counted together; only an inode with more links than seen is shared.
+        """
+        inodes: dict[tuple[int, int], list[int]] = {}
+        for root in paths:
+            if not root or os.path.islink(root) or not os.path.isdir(root):
+                continue
+            for dirpath, _dirnames, filenames in os.walk(root):
+                for name in filenames:
+                    try:
+                        st = os.lstat(os.path.join(dirpath, name))
+                    except OSError:
+                        continue
+                    if st.st_nlink < 2 or not stat.S_ISREG(st.st_mode):
+                        continue
+                    entry = inodes.setdefault(
+                        (st.st_dev, st.st_ino), [st.st_nlink, 0, st.st_blocks * 512]
+                    )
+                    entry[1] += 1
+        return sum(size for nlink, seen, size in inodes.values() if seen < nlink)
+
     @staticmethod
     def _estimated_cleanup_gb(service) -> float:
         """Best available upper bound for a dry-run cleanup.

{fixos-2.2.52 → fixos-2.2.53}/fixos/diagnostics/service_scanner.py

@@ -330,7 +330,12 @@ class ServiceDataScanner:
             for path in matching_paths:
                 if os.path.exists(path):
                     info = self._analyze_service_path(service_type, path)
-                    if info and info.size_mb >= self.threshold_mb:
+                    # An unmeasurable entry (slow Docker daemon) has no size to
+                    # compare; dropping it hid hundreds of GB from the report.
+                    if info and (
+                        info.size_mb >= self.threshold_mb
+                        or info.details.get("size_unknown")
+                    ):
                         results.append(info)
         if len(results) > 1:
             return self._merge_by_risk(results)
@@ -543,10 +548,64 @@ class ServiceDataScanner:
             preview_command=ServiceCleaner.get_preview_command(ServiceType.DOCKER, path),
             safe_to_cleanup=False,
             impact="high",
-            details={"size_unknown": True, "reason": "docker_system_df_timeout"},
+            details={
+                "size_unknown": True,
+                "reason": "docker_system_df_timeout",
+                "fast_inventory": self._docker_fast_inventory(),
+            },
             risk_level=ServiceCleaner.get_risk_level(ServiceType.DOCKER, path),
         )
 
+    @staticmethod
+    def _docker_fast_inventory(timeout_s: float = 10.0) -> dict[str, Any]:
+        """Counts and build-cache size from Docker commands that stay fast.
+
+        ``docker system df`` walks every volume to size it; with hundreds of
+        volumes it can take minutes even on an idle host.  Listing objects and
+        ``docker builder du`` answer in well under a second, so a timed-out
+        scan can still show where Docker holds data.  Volume sizes stay
+        unknown; orphaned volumes are data and are only counted.
+        """
+
+        def lines(*args: str) -> list[str] | None:
+            try:
+                result = subprocess.run(
+                    ["docker", *args],
+                    capture_output=True,
+                    text=True,
+                    timeout=timeout_s,
+                    check=False,
+                )
+            except (OSError, subprocess.TimeoutExpired):
+                return None
+            if result.returncode != 0:
+                return None
+            return [line for line in result.stdout.splitlines() if line.strip()]
+
+        inventory: dict[str, Any] = {}
+        queries = {
+            "images": ("image", "ls", "-q", "--no-trunc"),
+            "dangling_images": ("image", "ls", "-q", "--no-trunc", "-f", "dangling=true"),
+            "containers": ("ps", "-aq"),
+            "stopped_containers": ("ps", "-aq", "-f", "status=exited"),
+            "volumes": ("volume", "ls", "-q"),
+            "dangling_volumes": ("volume", "ls", "-q", "-f", "dangling=true"),
+        }
+        for key, args in queries.items():
+            found = lines(*args)
+            if found is not None:
+                inventory[key] = len(set(found))
+
+        builder = lines("builder", "du")
+        if builder is not None:
+            for line in builder:
+                label, _, value = line.partition(":")
+                label = label.strip().lower()
+                if label in ("total", "reclaimable") and value.strip():
+                    size_mb = ServiceDataScanner._parse_human_size_to_mb(value.strip())
+                    inventory[f"build_cache_{label}_gb"] = round(size_mb / 1024, 3)
+        return inventory
+
     def _get_docker_daemon_size_mb(self, *, refresh: bool = False) -> float | None:
         """Total Docker disk usage as reported by the daemon itself."""
         usage = self._get_docker_daemon_usage(refresh=refresh)

{fixos-2.2.52 → fixos-2.2.53}/fixos/interactive/cleanup_planner.py

@@ -1,13 +1,13 @@
-#!/usr/bin/env python3
 """
 Interactive Cleanup Planner for fixOS
 Groups cleanup actions and provides interactive selection
 """
 
 import json
-from typing import Dict, List, Any
 from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
+from typing import Any
 
 
 class Priority(Enum):
@@ -42,7 +42,7 @@ class CleanupAction:
     impact: str
     category: str = ""
     estimated_time: str = ""
-    dependencies: List[str] = None
+    dependencies: list[str] = None
     preview_command: str = ""
 
     def __post_init__(self):
@@ -116,8 +116,8 @@ class CleanupPlanner:
         }
 
     def group_by_category(
-        self, suggestions: List[Dict]
-    ) -> Dict[str, List[CleanupAction]]:
+        self, suggestions: list[dict]
+    ) -> dict[str, list[CleanupAction]]:
         """Group cleanup suggestions by category"""
         grouped = {}
 
@@ -133,13 +133,12 @@ class CleanupPlanner:
                     grouped[category] = []
                 grouped[category].append(action)
 
-            except Exception:
-                # Skip invalid suggestions
+            except Exception:  # noqa: BLE001, S112 - one malformed suggestion must not drop the whole plan
                 continue
 
         # Sort actions within each category by priority and size
-        for category in grouped:
-            grouped[category].sort(
+        for actions in grouped.values():
+            actions.sort(
                 key=lambda x: (self._priority_score(x.priority), x.size_gb),
                 reverse=True,
             )
@@ -147,25 +146,25 @@ class CleanupPlanner:
         return grouped
 
     def prioritize_actions(
-        self, grouped_actions: Dict[str, List[CleanupAction]]
-    ) -> List[CleanupAction]:
+        self, grouped_actions: dict[str, list[CleanupAction]]
+    ) -> list[CleanupAction]:
         """Create prioritized list of all actions"""
         all_actions = []
 
         # Add high priority actions first
-        for category, actions in grouped_actions.items():
+        for actions in grouped_actions.values():
             high_priority = [
                 a for a in actions if a.priority in [Priority.CRITICAL, Priority.HIGH]
             ]
             all_actions.extend(high_priority)
 
         # Add medium priority actions
-        for category, actions in grouped_actions.items():
+        for actions in grouped_actions.values():
             medium_priority = [a for a in actions if a.priority == Priority.MEDIUM]
             all_actions.extend(medium_priority)
 
         # Add low priority actions
-        for category, actions in grouped_actions.items():
+        for actions in grouped_actions.values():
             low_priority = [a for a in actions if a.priority == Priority.LOW]
             all_actions.extend(low_priority)
 
@@ -181,7 +180,7 @@ class CleanupPlanner:
 
         return all_actions
 
-    def create_cleanup_plan(self, suggestions: List[Dict]) -> Dict[str, Any]:
+    def create_cleanup_plan(self, suggestions: list[dict]) -> dict[str, Any]:
         """Create comprehensive cleanup plan"""
         grouped = self.group_by_category(suggestions)
         prioritized = self.prioritize_actions(grouped)
@@ -237,7 +236,7 @@ class CleanupPlanner:
 
         return plan
 
-    def interactive_selection(self, plan: Dict[str, Any]) -> Dict[str, Any]:
+    def interactive_selection(self, plan: dict[str, Any]) -> dict[str, Any]:
         """Interactive selection process (simulated for now)"""
         selected_actions = []
 
@@ -255,7 +254,7 @@ class CleanupPlanner:
             "selection_method": "auto_safe_high_impact",
         }
 
-    def _dict_to_action(self, suggestion: Dict) -> CleanupAction:
+    def _dict_to_action(self, suggestion: dict) -> CleanupAction:
         """Convert dictionary suggestion to CleanupAction"""
         try:
             # Need to handle strings if suggestion payload comes in as string not Enum
@@ -285,8 +284,7 @@ class CleanupPlanner:
                 dependencies=suggestion.get("dependencies", []),
                 preview_command=suggestion.get("preview_command", ""),
             )
-        except Exception:
-            # Create default action for invalid suggestions
+        except Exception:  # noqa: BLE001 - invalid suggestions become a low-priority default action
             return CleanupAction(
                 type=CleanupType.LARGE_FILE,
                 priority=Priority.LOW,
@@ -298,7 +296,7 @@ class CleanupPlanner:
                 impact="none",
             )
 
-    def _action_to_dict(self, action: CleanupAction) -> Dict[str, Any]:
+    def _action_to_dict(self, action: CleanupAction) -> dict[str, Any]:
         """Convert CleanupAction to dictionary"""
         return {
             "type": action.type.value,
@@ -345,7 +343,7 @@ class CleanupPlanner:
         return scores.get(priority, 1)
 
     @staticmethod
-    def _rec_safe_high_impact(prioritized: List[CleanupAction]) -> List[Dict]:
+    def _rec_safe_high_impact(prioritized: list[CleanupAction]) -> list[dict]:
         actions = [
             a
             for a in prioritized
@@ -368,7 +366,7 @@ class CleanupPlanner:
         ]
 
     @staticmethod
-    def _rec_cache(grouped: Dict[str, List[CleanupAction]]) -> List[Dict]:
+    def _rec_cache(grouped: dict[str, list[CleanupAction]]) -> list[dict]:
         actions = grouped.get("cache", [])
         if not actions:
             return []
@@ -387,7 +385,7 @@ class CleanupPlanner:
         ]
 
     @staticmethod
-    def _rec_logs(grouped: Dict[str, List[CleanupAction]]) -> List[Dict]:
+    def _rec_logs(grouped: dict[str, list[CleanupAction]]) -> list[dict]:
         actions = grouped.get("logs", [])
         if not actions:
             return []
@@ -406,7 +404,7 @@ class CleanupPlanner:
         ]
 
     @staticmethod
-    def _rec_manual(prioritized: List[CleanupAction]) -> List[Dict]:
+    def _rec_manual(prioritized: list[CleanupAction]) -> list[dict]:
         actions = [a for a in prioritized if not a.safe and a.size_gb > 1.0]
         if not actions:
             return []
@@ -423,10 +421,10 @@ class CleanupPlanner:
         ]
 
     def _generate_recommendations(
-        self, grouped: Dict[str, List[CleanupAction]], prioritized: List[CleanupAction]
-    ) -> List[Dict]:
+        self, grouped: dict[str, list[CleanupAction]], prioritized: list[CleanupAction]
+    ) -> list[dict]:
         """Generate cleanup recommendations"""
-        recs: List[Dict] = []
+        recs: list[dict] = []
         recs.extend(self._rec_safe_high_impact(prioritized))
         recs.extend(self._rec_cache(grouped))
         recs.extend(self._rec_logs(grouped))
@@ -441,7 +439,7 @@ def main():
         {
             "type": "cache_cleanup",
             "priority": "high",
-            "path": "/home/user/.cache/npm",
+            "path": str(Path.home() / ".cache" / "npm"),
             "size_gb": 2.5,
             "description": "Clear npm cache",
             "command": "npm cache clean --force",

{fixos-2.2.52 → fixos-2.2.53}/fixos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixos
-Version: 2.2.52
+Version: 2.2.53
 Summary: AI-powered Linux/Windows diagnostics and repair – audio, hardware, system issues
 Home-page: https://github.com/wronai/fixos
 Author: fixos contributors

{fixos-2.2.52 → fixos-2.2.53}/fixos.egg-info/SOURCES.txt

@@ -188,6 +188,7 @@ tests/unit/test_ask_and_nl_group.py
 tests/unit/test_cache_discovery.py
 tests/unit/test_cleanup_cmd.py
 tests/unit/test_cleanup_effectiveness.py
+tests/unit/test_cleanup_planner.py
 tests/unit/test_cleanup_retention.py
 tests/unit/test_cleanup_safety.py
 tests/unit/test_cleanup_space.py
@@ -208,6 +209,7 @@ tests/unit/test_jetbrains_recovery.py
 tests/unit/test_llm_auth_stop.py
 tests/unit/test_llm_provider.py
 tests/unit/test_native_scan.py
+tests/unit/test_ollama_endpoint.py
 tests/unit/test_orchestrator.py
 tests/unit/test_orphan_pins.py
 tests/unit/test_orphaned_workloads.py