fixos 2.2.48__tar.gz → 2.2.49__tar.gz

{fixos-2.2.48 → fixos-2.2.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixos
-Version: 2.2.48
+Version: 2.2.49
 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.48 → fixos-2.2.49}/fixos/__init__.py

@@ -1,3 +1,3 @@
 """fixos – AI-powered Linux/Windows diagnostics and repair."""
 
-__version__ = "2.2.48"
+__version__ = "2.2.49"

{fixos-2.2.48 → fixos-2.2.49}/fixos/cli/cleanup_cmd.py

@@ -1218,26 +1218,58 @@ def _selection_description(svc: dict) -> str:
     return description
 
 
+def _parse_selection(raw: str, count: int) -> set[int]:
+    """Parse '1,3,7-9', 'all' or 'none' into 0-based indexes."""
+    tokens = raw.strip().lower().replace(" ", "")
+    if tokens in ("", "none", "0"):
+        return set()
+    if tokens == "all":
+        return set(range(count))
+    selected = set()
+    for part in tokens.split(","):
+        if not part:
+            continue
+        bounds = part.split("-", 1)
+        try:
+            if len(bounds) == 2:
+                numbers = range(int(bounds[0]), int(bounds[1]) + 1)
+            else:
+                numbers = (int(bounds[0]),)
+        except ValueError:
+            continue
+        for number in numbers:
+            if 1 <= number <= count:
+                selected.add(number - 1)
+    return selected
+
+
 def _select_individual_services(services: list) -> list:
     """Offer every scanned, executable entry in its displayed order."""
     click.echo(
         click.style(
-            "Wybierz kolejno spośród wszystkich możliwych usług:",
+            "Wybierz usługi do wyczyszczenia:",
             fg="cyan",
         )
     )
-    selected = []
+    executable = []
     for svc in services:
-        label = f"  {svc['name']} ({_size_str(svc)}) [{_selection_description(svc)}]"
+        label = f"{svc['name']} ({_size_str(svc)}) [{_selection_description(svc)}]"
         if not svc.get("can_cleanup") or not svc.get("cleanup_command", "").strip():
-            click.echo(f"{label} — brak bezpiecznej operacji zbiorczej")
+            click.echo(f"  {label} — brak bezpiecznej operacji zbiorczej")
             preview = svc.get("preview_command")
             if preview:
                 click.echo(f"    Podgląd: {preview}")
             continue
-        if click.confirm(label, default=False):
-            selected.append(svc)
-    return selected
+        executable.append(svc)
+        click.echo(f"  [{len(executable)}] {label}")
+    if not executable:
+        return []
+    raw = click.prompt(
+        "Numery do wyczyszczenia (np. 1,3,7-9; all = wszystkie; none = żadne)",
+        default="none",
+        show_default=True,
+    )
+    return [executable[i] for i in sorted(_parse_selection(raw, len(executable)))]
 
 
 def _execute_individual_cleanup(
@@ -1326,6 +1358,41 @@ def _run_interactive_cleanup(
         _display_dangerous_services(plan["dangerous"])
 
 
+def _execute_yes_cleanup(plan: dict, scanner, dry_run: bool = False) -> None:
+    """Execute the whole safe plan without prompting (--yes)."""
+    safe = plan["safe_to_cleanup"]
+    if not safe:
+        click.echo(
+            click.style(
+                "Brak bezpiecznych pozycji do automatycznego czyszczenia.",
+                fg="yellow",
+            )
+        )
+    else:
+        if dry_run:
+            click.echo(
+                click.style(
+                    "Tryb symulacji (--dry-run): wybrane pozycje nie zostaną usunięte.",
+                    fg="cyan",
+                    bold=True,
+                )
+            )
+        _execute_safe_cleanup(safe, scanner, dry_run=dry_run)
+        if not dry_run:
+            click.echo()
+            click.echo(
+                click.style(
+                    "Uwaga: listy poniżej pochodzą ze skanu sprzed czyszczenia — "
+                    "uruchom ponownie `fixos cleanup --list`, by zobaczyć aktualny stan.",
+                    fg="cyan",
+                )
+            )
+    if plan["requires_review"]:
+        _display_unsafe_services(plan["requires_review"])
+    if plan.get("dangerous"):
+        _display_dangerous_services(plan["dangerous"])
+
+
 # ── Main CLI command ──────────────────────────────────────────────────────
 
 
@@ -1479,6 +1546,14 @@ def _run_interactive_cleanup(
     default=False,
     help="Tylko wyświetl listę bez interakcji",
 )
+@click.option(
+    "--yes",
+    "-y",
+    "yes",
+    is_flag=True,
+    default=False,
+    help="Bez pytań — wykonaj wszystkie bezpieczne pozycje (SSH/cron/CI)",
+)
 @click.option(
     "--full",
     "-f",
@@ -1505,6 +1580,7 @@ def cleanup_services(
     days,
     dry_run,
     list_only,
+    yes,
     full_analysis,
 ) -> None:
     """
@@ -1522,6 +1598,7 @@ def cleanup_services(
       fixos cleanup -t 1000           # próg 1000MB (1GB)
       fixos cleanup -s docker,ollama  # tylko Docker i Ollama
       fixos cleanup --list              # tylko lista, bez czyszczenia
+      fixos cleanup --yes               # bez pytań: wszystkie bezpieczne
       fixos cleanup -c docker --dry-run  # tylko cache buildów >7 dni
       fixos cleanup --docker-all --dry-run
       # wszystkie unused images/cache + osierocone sieci
@@ -1737,4 +1814,8 @@ def cleanup_services(
     for svc in plan["services"]:
         _display_service_item(svc)
 
+    if yes:
+        _execute_yes_cleanup(plan, scanner, dry_run=dry_run)
+        return
+
     _run_interactive_cleanup(plan, list_only, scanner, dry_run=dry_run)

{fixos-2.2.48 → fixos-2.2.49}/fixos/cli/shared.py

@@ -178,9 +178,7 @@ class NaturalLanguageGroup(click.Group):
                 except (click.Abort, EOFError):
                     pass
             # In non-interactive mode or if rejected, fail cleanly with typo suggestion
-            raise click.exceptions.NoSuchCommand(
-                cmd_name, possibilities=all_commands, ctx=ctx
-            )
+            ctx.fail(f"No such command '{cmd_name}'. Did you mean '{best_match}'?")
 
         # 2. Check if this is a genuine natural language command:
         # - multiple arguments: e.g. `fixos wylacz kontenery`
@@ -196,7 +194,5 @@ class NaturalLanguageGroup(click.Group):
             return super().resolve_command(ctx, ["ask"] + args)
 
         # 3. Otherwise, unrecognized single token that is not NL nor a close match
-        raise click.exceptions.NoSuchCommand(
-            cmd_name, possibilities=all_commands, ctx=ctx
-        )
+        ctx.fail(f"No such command '{cmd_name}'.")
 

{fixos-2.2.48 → fixos-2.2.49}/fixos/cli/shell_cmd.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 
 import os
 import shlex
-import sys
 from typing import Any
 
 import click
@@ -17,53 +16,32 @@ from prompt_toolkit.history import FileHistory
 from prompt_toolkit.styles import Style
 
 
+def _command_completion_words(command: click.Command) -> dict[str, Any] | None:
+    """Collect subcommand and option words for one click command."""
+    words: dict[str, Any] = {}
+    if isinstance(command, click.Group):
+        for name in sorted(command.commands):
+            words[name] = _command_completion_words(command.commands[name])
+    for param in getattr(command, "params", []):
+        for opt in list(getattr(param, "opts", [])) + list(
+            getattr(param, "secondary_opts", [])
+        ):
+            words.setdefault(opt, None)
+    return words or None
+
+
 def get_command_completer() -> NestedCompleter:
-    """Build a nested completer for all fixOS commands and common options."""
-    return NestedCompleter.from_nested_dict({
-        "quick": {"--hours": None, "--json": None, "--deep": None, "--help": None},
-        "fix": {
-            "--modules": None,
-            "--dry-run": None,
-            "--json": None,
-            "--yaml": None,
-            "--help": None,
-        },
-        "cleanup": {
-            "--docker-all": None,
-            "--docker-old": None,
-            "--docker-networks": None,
-            "--docker-stale-services": None,
-            "--orphaned-projects": None,
-            "--ollama-old": None,
-            "--dry-run": None,
-            "--threshold": None,
-            "-t": None,
-            "--list": None,
-            "--full": None,
-            "--help": None,
-        },
-        "scan": {"--modules": None, "--show-raw": None, "--json": None, "--help": None},
-        "quickfix": {"--help": None},
-        "jetbrains": {"doctor": None, "--help": None},
-        "projects": {"--help": None},
-        "orchestrate": {"--dry-run": None, "--help": None},
-        "watch": {"--help": None},
-        "report": {"--help": None},
-        "history": {"--help": None},
-        "rollback": {"--help": None},
-        "profile": {"--help": None},
-        "llm": {"--free": None, "--help": None},
-        "providers": {"--help": None},
-        "token": {"set": None, "show": None, "clear": None, "--help": None},
-        "config": {"show": None, "set": None, "init": None, "--help": None},
-        "test-llm": {"--help": None},
-        "ask": {"--dry-run": None, "--help": None},
-        "help": None,
-        "clear": None,
-        "menu": None,
-        "exit": None,
-        "quit": None,
-    })
+    """Build a nested completer from the live click command tree."""
+    from fixos.cli.main import cli
+
+    words: dict[str, Any] = {
+        name: _command_completion_words(command)
+        for name, command in sorted(cli.commands.items())
+    }
+    words.update(
+        {"commands": None, "clear": None, "menu": None, "exit": None, "quit": None}
+    )
+    return NestedCompleter.from_nested_dict(words)
 
 
 def print_interactive_menu() -> None:
@@ -81,6 +59,7 @@ def print_interactive_menu() -> None:
         ("5", "jetbrains doctor", "Diagnoza PyCharm, WebStorm, IDEA"),
         ("6", "ask", "Zadaj pytanie / polecenie w języku naturalnym"),
         ("7", "config show", "Podgląd konfiguracji i aktywny model"),
+        ("8", "commands", "Pełna lista wszystkich komend i opcji"),
     ]
     for num, cmd, desc in menu_items:
         num_styled = click.style(f"[{num}]", fg="yellow", bold=True)
@@ -92,7 +71,7 @@ def print_interactive_menu() -> None:
     click.echo()
     click.echo(
         click.style(
-            "  💡 Wskazówka: wpisz numer [1-7], komendę lub zapytanie naturalne.",
+            "  💡 Wskazówka: wpisz numer [1-8], komendę lub zapytanie naturalne.",
             fg="bright_black",
         )
     )
@@ -106,6 +85,38 @@ def print_interactive_menu() -> None:
     click.echo()
 
 
+def print_command_catalog() -> None:
+    """Print every registered command with its one-line help."""
+    from fixos.cli.main import cli
+
+    click.echo(click.style("  📚 Wszystkie komendy fixos:", fg="cyan", bold=True))
+    click.echo()
+    for name in sorted(cli.commands):
+        command = cli.commands[name]
+        try:
+            short = command.get_short_help_str().splitlines()[0]
+        except Exception:
+            short = ""
+        name_styled = click.style(f"{name:<14}", fg="green")
+        click.echo(f"  {name_styled} {short}")
+        if isinstance(command, click.Group):
+            for sub_name in sorted(command.commands):
+                sub = command.commands[sub_name]
+                try:
+                    sub_short = sub.get_short_help_str().splitlines()[0]
+                except Exception:
+                    sub_short = ""
+                click.echo(f"    {sub_name:<12} {sub_short}")
+    click.echo()
+    click.echo(
+        click.style(
+            "  💡 Każdą komendę możesz uruchomić z flagą --help, np. `cleanup --help`.",
+            fg="bright_black",
+        )
+    )
+    click.echo()
+
+
 MENU_SHORTCUTS = {
     "1": "quick",
     "2": "fix",
@@ -114,6 +125,7 @@ MENU_SHORTCUTS = {
     "5": "jetbrains doctor",
     "6": "ask",
     "7": "config show",
+    "8": "commands",
 }
 
 
@@ -134,9 +146,11 @@ def run_interactive_shell(ctx: click.Context | None = None) -> None:
     history = FileHistory(history_file)
     completer = get_command_completer()
 
-    style = Style.from_dict({
-        "prompt": "#00d7af bold",
-    })
+    style = Style.from_dict(
+        {
+            "prompt": "#00d7af bold",
+        }
+    )
 
     session = PromptSession(
         history=history,
@@ -168,6 +182,10 @@ def run_interactive_shell(ctx: click.Context | None = None) -> None:
             click.clear()
             continue
 
+        if user_input.lower() == "commands":
+            print_command_catalog()
+            continue
+
         # Check menu shortcuts
         if user_input in MENU_SHORTCUTS:
             if user_input == "6":
@@ -179,6 +197,9 @@ def run_interactive_shell(ctx: click.Context | None = None) -> None:
                         continue
                 except (KeyboardInterrupt, EOFError):
                     continue
+            elif MENU_SHORTCUTS[user_input] == "commands":
+                print_command_catalog()
+                continue
             else:
                 user_input = MENU_SHORTCUTS[user_input]
 

{fixos-2.2.48 → fixos-2.2.49}/fixos.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fixos
-Version: 2.2.48
+Version: 2.2.49
 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.48 → fixos-2.2.49}/fixos.egg-info/SOURCES.txt

@@ -205,5 +205,6 @@ tests/unit/test_resources_quick.py
 tests/unit/test_security_quick.py
 tests/unit/test_service_cleanup.py
 tests/unit/test_service_scanner.py
+tests/unit/test_shell_ux.py
 tests/unit/test_storage_analyzer.py
 tests/unit/test_system_checks_parallel.py

{fixos-2.2.48 → fixos-2.2.49}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fixos"
-version = "2.2.48"
+version = "2.2.49"
 description = "AI-powered Linux/Windows diagnostics and repair – audio, hardware, system issues"
 readme = "README.md"
 requires-python = ">=3.10"

{fixos-2.2.48 → fixos-2.2.49}/tests/unit/test_cleanup_cmd.py

@@ -45,14 +45,14 @@ def test_individual_mode_walks_all_risk_tiers_in_display_order():
     def command():
         cleanup_cmd._run_interactive_cleanup(plan, False, Scanner())
 
-    # 2 = individual; Docker yes; JetBrains no; Npm yes; Docker risk
+    # 2 = individual; pick 1 (Docker) and 3 (Npm) in one input; Docker risk
     # confirmation yes. Ollama has no executable bulk action, so it is shown
-    # but intentionally does not consume an answer.
-    result = CliRunner().invoke(command, input="2\ny\nn\ny\ny\n")
+    # without a number and intentionally consumes no input.
+    result = CliRunner().invoke(command, input="2\n1,3\ny\n")
 
     assert result.exit_code == 0
     individual_output = result.output.split(
-        "Wybierz kolejno spośród wszystkich możliwych usług:", 1
+        "Wybierz usługi do wyczyszczenia:", 1
     )[1]
     assert individual_output.index("Docker") < individual_output.index("Jetbrains")
     assert individual_output.index("Jetbrains") < individual_output.index("Npm")

{fixos-2.2.48 → fixos-2.2.49}/tests/unit/test_cleanup_safety.py

@@ -87,9 +87,9 @@ class TestInteractiveDryRun:
         def command():
             cleanup_cmd._run_interactive_cleanup(plan, False, scanner, dry_run=True)
 
-        # 2 = individual; Docker yes; Npm yes. No protected-data confirmation
-        # is needed because nothing is executed.
-        result = CliRunner().invoke(command, input="2\ny\ny\n")
+        # 2 = individual; 'all' picks both entries in one input. No
+        # protected-data confirmation is needed because nothing is executed.
+        result = CliRunner().invoke(command, input="2\nall\n")
 
         assert result.exit_code == 0, result.output
         assert scanner.calls == [("docker", True), ("npm", True)]
@@ -132,12 +132,51 @@ class TestInteractiveDryRun:
         assert "Symulacja" not in result.output
 
 
+class TestYesFlag:
+    """`--yes` runs the safe plan with zero interactive input."""
+
+    def _command_with_plan(self, plan, scanner, monkeypatch, argv):
+        scanner.get_cleanup_plan = lambda selected_services=None: plan
+        monkeypatch.setattr(cleanup_cmd, "ServiceDataScanner", lambda **_: scanner)
+        return CliRunner().invoke(cleanup_cmd.cleanup_services, argv)
+
+    def test_yes_runs_all_safe_without_input(self, monkeypatch):
+        scanner = RecordingScanner()
+        plan = _plan(_service("Npm", "safe"), _service("Pip", "safe"))
+        result = self._command_with_plan(plan, scanner, monkeypatch, ["--yes"])
+        assert result.exit_code == 0, result.output
+        assert scanner.calls == [("npm", False), ("pip", False)]
+
+    def test_yes_dry_run_simulates_everything(self, monkeypatch):
+        scanner = RecordingScanner()
+        plan = _plan(_service("Npm", "safe"), _service("Pip", "safe"))
+        result = self._command_with_plan(
+            plan, scanner, monkeypatch, ["--yes", "--dry-run"]
+        )
+        assert result.exit_code == 0, result.output
+        assert scanner.calls == [("npm", True), ("pip", True)]
+        assert "Tryb symulacji (--dry-run)" in result.output
+        assert "Zwolniono" not in result.output
+
+    def test_yes_with_no_safe_services_cleans_nothing(self, monkeypatch):
+        scanner = RecordingScanner()
+        plan = _plan(_service("Docker", "dangerous"))
+        result = self._command_with_plan(plan, scanner, monkeypatch, ["--yes"])
+        assert result.exit_code == 0, result.output
+        assert scanner.calls == []
+        assert "Brak bezpiecznych pozycji" in result.output
+
+
 class TestCleanupCommandSafety:
     def test_logs_service_leaves_xdg_state_alone(self):
         path = "~/.cache/log"
         assert ServiceDataScanner.SERVICE_PATHS[ServiceType.LOGS] == [path]
-        assert ".local/state" not in ServiceCleaner.get_cleanup_command(ServiceType.LOGS, path)
-        assert ".local/state" not in ServiceCleaner.get_preview_command(ServiceType.LOGS, path)
+        assert ".local/state" not in ServiceCleaner.get_cleanup_command(
+            ServiceType.LOGS, path
+        )
+        assert ".local/state" not in ServiceCleaner.get_preview_command(
+            ServiceType.LOGS, path
+        )
 
     def test_multi_word_cache_paths_stay_single_rm_arguments(self):
         for service_type in (ServiceType.DISCORD, ServiceType.SLACK):
@@ -183,9 +222,7 @@ class TestDockerDefaultProposal:
         )
         return cleaner
 
-    def test_default_plan_proposes_stopped_containers_and_images(
-        self, monkeypatch
-    ):
+    def test_default_plan_proposes_stopped_containers_and_images(self, monkeypatch):
         usage = {
             "Containers": {"size_gb": 3.0, "reclaimable_gb": 2.5},
             "Images": {"size_gb": 40.0, "reclaimable_gb": 10.0},
@@ -217,9 +254,7 @@ class TestDockerDefaultProposal:
         }
         cleaner = self._cleaner(self._scanner(usage), monkeypatch)
 
-        kinds = {
-            action["cleanup_kind"] for action in cleaner.build_safe_age_actions()
-        }
+        kinds = {action["cleanup_kind"] for action in cleaner.build_safe_age_actions()}
         assert "docker-containers" not in kinds
         assert "docker-unused" not in kinds
 
@@ -250,8 +285,10 @@ class TestDockerDefaultProposal:
         monkeypatch.setattr(
             ServiceCleaner,
             "cleanup_docker_containers",
-            lambda self, dry_run=False: calls.append(dry_run)
-            or {"success": True, "space_freed_gb": 0.0, "output": ""},
+            lambda self, dry_run=False: (
+                calls.append(dry_run)
+                or {"success": True, "space_freed_gb": 0.0, "output": ""}
+            ),
         )
         svc = _service("Docker (zatrzymane kontenery)", "safe")
         svc["cleanup_kind"] = "docker-containers"
@@ -265,7 +302,9 @@ class TestDockerDefaultProposal:
 class TestScanMeasurement:
     def test_du_total_is_kept_when_a_subdirectory_is_unreadable(self, monkeypatch):
         def fake_run(cmd, **kwargs):
-            return subprocess.CompletedProcess(cmd, 1, stdout="2048\t/data\n", stderr="denied")
+            return subprocess.CompletedProcess(
+                cmd, 1, stdout="2048\t/data\n", stderr="denied"
+            )
 
         def forbidden_walk(*args, **kwargs):
             raise AssertionError("du output must not be discarded")

fixos-2.2.49/tests/unit/test_shell_ux.py

@@ -0,0 +1,98 @@
+"""Interactive UX contracts: shell completion coverage and cleanup selection."""
+
+import click
+import pytest
+
+from fixos.cli.cleanup_cmd import _parse_selection
+from fixos.cli.main import cli
+from fixos.cli.shell_cmd import (
+    MENU_SHORTCUTS,
+    get_command_completer,
+)
+
+
+def _words(node):
+    """Unwrap a NestedCompleter node into its option names."""
+    return set(getattr(node, "options", {}) or {})
+
+
+class TestCompleterCoverage:
+    """The shell completer must expose every registered command and option."""
+
+    def test_all_commands_complete(self):
+        options = _words(get_command_completer())
+        for name in cli.commands:
+            assert name in options, f"command '{name}' missing from completer"
+
+    def test_all_options_complete(self):
+        options = get_command_completer().options
+        for name, command in cli.commands.items():
+            words = _words(options.get(name))
+            for param in getattr(command, "params", []):
+                for opt in param.opts + param.secondary_opts:
+                    assert opt in words, f"{name} {opt} missing from completer"
+
+    def test_group_subcommands_complete(self):
+        options = get_command_completer().options
+        for name, command in cli.commands.items():
+            if not isinstance(command, click.Group):
+                continue
+            words = _words(options.get(name))
+            for sub_name in command.commands:
+                assert sub_name in words, f"{name} {sub_name} missing"
+
+    def test_shell_meta_words_present(self):
+        options = _words(get_command_completer())
+        for word in ("commands", "clear", "menu", "exit", "quit"):
+            assert word in options
+
+    def test_completer_survives_new_options(self):
+        """Options added after this test (e.g. cleanup -c) complete automatically."""
+        words = _words(get_command_completer().options["cleanup"])
+        assert "-c" in words or "--category" in words
+        assert "--docker-all" in words
+
+
+class TestMenuShortcuts:
+    """Menu shortcuts must resolve to real commands or handled meta words."""
+
+    def test_every_shortcut_resolves(self):
+        for shortcut, target in MENU_SHORTCUTS.items():
+            if target == "commands":
+                continue
+            head = target.split()[0]
+            assert head in cli.commands, f"shortcut [{shortcut}] -> '{target}'"
+
+    def test_catalog_covers_every_command(self, capsys):
+        from fixos.cli.shell_cmd import print_command_catalog
+
+        print_command_catalog()
+        out = capsys.readouterr().out
+        for name in cli.commands:
+            assert name in out, f"'{name}' absent from printed catalog"
+
+
+class TestParseSelection:
+    @pytest.mark.parametrize(
+        "raw,expected",
+        [
+            ("", set()),
+            ("none", set()),
+            ("0", set()),
+            ("all", {0, 1, 2, 3, 4}),
+            ("1", {0}),
+            ("1,3,5", {0, 2, 4}),
+            ("2-4", {1, 2, 3}),
+            ("1,3-4", {0, 2, 3}),
+            (" 1 , 3 ", {0, 2}),
+            ("9", set()),  # out of range ignored
+            ("abc", set()),  # garbage ignored
+            ("1,,2", {0, 1}),
+            ("4-2", set()),  # reversed range yields nothing
+        ],
+    )
+    def test_parse(self, raw, expected):
+        assert _parse_selection(raw, 5) == expected
+
+    def test_range_clamps_to_count(self):
+        assert _parse_selection("3-99", 5) == {2, 3, 4}