git commit -m "feat(update): add --silent mode with continue-on-failure and unified summary

- Introduce --silent flag for install/update to downgrade per-repo errors to warnings
- Continue processing remaining repositories on pull/install failures
- Emit a single summary at the end (suppress per-repo summaries during update)
- Preserve interactive verification behavior when not silent
- Add integration test covering silent vs non-silent update behavior
- Update e2e tests to use --silent for stability"

https://chatgpt.com/share/693ffcca-f680-800f-9f95-9d8c52a9a678

src/pkgmgr/actions/install/__init__.py

@@ -16,7 +16,7 @@ Responsibilities:
 from __future__ import annotations
 
 import os
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from pkgmgr.core.repository.identifier import get_repo_identifier
 from pkgmgr.core.repository.dir import get_repo_dir
@@ -93,6 +93,7 @@ def _verify_repo(
     repo_dir: str,
     no_verification: bool,
     identifier: str,
+    silent: bool,
 ) -> bool:
     """
     Verify a repository using the configured verification data.
@@ -111,6 +112,11 @@ def _verify_repo(
         print(f"Warning: Verification failed for {identifier}:")
         for err in errors:
             print(f"  - {err}")
+
+        if silent:
+            # Non-interactive mode: continue with a warning.
+            print(f"[Warning] Continuing despite verification failure for {identifier} (--silent).")
+        else:
             choice = input("Continue anyway? [y/N]: ").strip().lower()
             if choice != "y":
                 print(f"Skipping installation for {identifier}.")
@@ -163,6 +169,8 @@ def install_repos(
     clone_mode: str,
     update_dependencies: bool,
     force_update: bool = False,
+    silent: bool = False,
+    emit_summary: bool = True,
 ) -> None:
     """
     Install one or more repositories according to the configured installers
@@ -170,12 +178,17 @@ def install_repos(
 
     If force_update=True, installers of the currently active layer are allowed
     to run again (upgrade/refresh), even if that layer is already loaded.
+
+    If silent=True, repository failures are downgraded to warnings and the
+    overall command never exits non-zero because of per-repository failures.
     """
     pipeline = InstallationPipeline(INSTALLERS)
+    failures: List[Tuple[str, str]] = []
 
     for repo in selected_repos:
         identifier = get_repo_identifier(repo, all_repos)
 
+        try:
             repo_dir = _ensure_repo_dir(
                 repo=repo,
                 repositories_base_dir=repositories_base_dir,
@@ -186,6 +199,7 @@ def install_repos(
                 identifier=identifier,
             )
             if not repo_dir:
+                failures.append((identifier, "clone/ensure repo directory failed"))
                 continue
 
             if not _verify_repo(
@@ -193,6 +207,7 @@ def install_repos(
                 repo_dir=repo_dir,
                 no_verification=no_verification,
                 identifier=identifier,
+                silent=silent,
             ):
                 continue
 
@@ -212,3 +227,23 @@ def install_repos(
             )
 
             pipeline.run(ctx)
+
+        except SystemExit as exc:
+            code = exc.code if isinstance(exc.code, int) else str(exc.code)
+            failures.append((identifier, f"installer failed (exit={code})"))
+            if not quiet:
+                print(f"[Warning] install: repository {identifier} failed (exit={code}). Continuing...")
+            continue
+        except Exception as exc:
+            failures.append((identifier, f"unexpected error: {exc}"))
+            if not quiet:
+                print(f"[Warning] install: repository {identifier} hit an unexpected error: {exc}. Continuing...")
+            continue
+
+    if failures and emit_summary and not quiet:
+        print("\n[pkgmgr] Installation finished with warnings:")
+        for ident, msg in failures:
+            print(f"  - {ident}: {msg}")
+
+    if failures and not silent:
+        raise SystemExit(1)

src/pkgmgr/actions/update/manager.py

@@ -3,7 +3,7 @@
 
 from __future__ import annotations
 
-from typing import Any, Iterable
+from typing import Any, Iterable, List, Tuple
 
 from pkgmgr.actions.update.system_updater import SystemUpdater
 
@@ -30,22 +30,42 @@ class UpdateManager:
         quiet: bool,
         update_dependencies: bool,
         clone_mode: str,
+        silent: bool = False,
         force_update: bool = True,
     ) -> None:
         from pkgmgr.actions.install import install_repos
         from pkgmgr.actions.repository.pull import pull_with_verification
+        from pkgmgr.core.repository.identifier import get_repo_identifier
 
+        failures: List[Tuple[str, str]] = []
+
+        for repo in list(selected_repos):
+            identifier = get_repo_identifier(repo, all_repos)
+
+            try:
                 pull_with_verification(
-            selected_repos,
+                    [repo],
                     repositories_base_dir,
                     all_repos,
                     [],
                     no_verification,
                     preview,
                 )
+            except SystemExit as exc:
+                code = exc.code if isinstance(exc.code, int) else str(exc.code)
+                failures.append((identifier, f"pull failed (exit={code})"))
+                if not quiet:
+                    print(f"[Warning] update: pull failed for {identifier} (exit={code}). Continuing...")
+                continue
+            except Exception as exc:
+                failures.append((identifier, f"pull failed: {exc}"))
+                if not quiet:
+                    print(f"[Warning] update: pull failed for {identifier}: {exc}. Continuing...")
+                continue
 
+            try:
                 install_repos(
-            selected_repos,
+                    [repo],
                     repositories_base_dir,
                     bin_dir,
                     all_repos,
@@ -55,7 +75,28 @@ class UpdateManager:
                     clone_mode,
                     update_dependencies,
                     force_update=force_update,
+                    silent=silent,
+                    emit_summary=False,
                 )
+            except SystemExit as exc:
+                code = exc.code if isinstance(exc.code, int) else str(exc.code)
+                failures.append((identifier, f"install failed (exit={code})"))
+                if not quiet:
+                    print(f"[Warning] update: install failed for {identifier} (exit={code}). Continuing...")
+                continue
+            except Exception as exc:
+                failures.append((identifier, f"install failed: {exc}"))
+                if not quiet:
+                    print(f"[Warning] update: install failed for {identifier}: {exc}. Continuing...")
+                continue
+
+        if failures and not quiet:
+            print("\n[pkgmgr] Update finished with warnings:")
+            for ident, msg in failures:
+                print(f"  - {ident}: {msg}")
+
+        if failures and not silent:
+            raise SystemExit(1)
 
         if system_update:
             self._system_updater.run(preview=preview)

src/pkgmgr/cli/commands/repos.py

@@ -68,6 +68,7 @@ def handle_repos_command(
             args.clone_mode,
             args.dependencies,
             force_update=getattr(args, "update", False),
+            silent=getattr(args, "silent", False),
         )
         return
 

src/pkgmgr/cli/dispatch.py

@@ -105,6 +105,7 @@ def dispatch_command(args, ctx: CLIContext) -> None:
 
     if args.command == "update":
         from pkgmgr.actions.update import UpdateManager
+
         UpdateManager().run(
             selected_repos=selected,
             repositories_base_dir=ctx.repositories_base_dir,
@@ -116,6 +117,7 @@ def dispatch_command(args, ctx: CLIContext) -> None:
             quiet=args.quiet,
             update_dependencies=args.dependencies,
             clone_mode=args.clone_mode,
+            silent=getattr(args, "silent", False),
             force_update=True,
         )
         return

src/pkgmgr/cli/parser/common.py

@@ -168,3 +168,10 @@ def add_install_update_arguments(subparser: argparse.ArgumentParser) -> None:
         default="ssh",
         help="Specify clone mode (default: ssh).",
     )
+
+    _add_option_if_missing(
+        subparser,
+        "--silent",
+        action="store_true",
+        help="Continue with other repositories if one fails; downgrade errors to warnings.",
+    )

tests/e2e/test_update_all_no_system.py

@@ -96,6 +96,7 @@ class TestIntegrationUpdateAllshallowNoSystem(unittest.TestCase):
                 "--clone-mode",
                 "shallow",
                 "--no-verification",
+                "--silent",
             ]
             self._run_cmd(["pkgmgr", *args], label="pkgmgr", env=env)
             pkgmgr_help_debug()
@@ -110,6 +111,7 @@ class TestIntegrationUpdateAllshallowNoSystem(unittest.TestCase):
                 "--clone-mode",
                 "shallow",
                 "--no-verification",
+                "--silent",
             ]
             self._run_cmd(
                 ["nix", "run", ".#pkgmgr", "--", *args],

tests/integration/test_update_silent_continues.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+import unittest
+from unittest.mock import patch
+
+from pkgmgr.actions.update.manager import UpdateManager
+
+
+class TestUpdateSilentContinues(unittest.TestCase):
+    def test_update_continues_on_failures_and_silent_controls_exit_code(self) -> None:
+        """
+        Integration test for UpdateManager:
+          - pull failure on repo A should not stop repo B/C
+          - install failure on repo B should not stop repo C
+          - without silent -> SystemExit(1) at end if any failures
+          - with silent -> no SystemExit even if there are failures
+        """
+
+        repos = [
+            {"provider": "github", "account": "example", "repository": "repo-a"},
+            {"provider": "github", "account": "example", "repository": "repo-b"},
+            {"provider": "github", "account": "example", "repository": "repo-c"},
+        ]
+
+        # We patch the internal calls used by UpdateManager:
+        # - pull_with_verification is called once per repo
+        # - install_repos is called once per repo that successfully pulled
+        #
+        # We simulate:
+        #   repo-a: pull fails
+        #   repo-b: pull ok, install fails
+        #   repo-c: pull ok, install ok
+        pull_calls = []
+        install_calls = []
+
+        def pull_side_effect(selected_repos, *_args, **_kwargs):
+            # selected_repos is a list with exactly one repo in our implementation.
+            repo = selected_repos[0]
+            pull_calls.append(repo["repository"])
+            if repo["repository"] == "repo-a":
+                raise SystemExit(2)
+            return None
+
+        def install_side_effect(selected_repos, *_args, **kwargs):
+            repo = selected_repos[0]
+            install_calls.append((repo["repository"], kwargs.get("silent"), kwargs.get("emit_summary")))
+            if repo["repository"] == "repo-b":
+                raise SystemExit(3)
+            return None
+
+        # Patch at the exact import locations used inside UpdateManager.run()
+        with patch("pkgmgr.actions.repository.pull.pull_with_verification", side_effect=pull_side_effect), patch(
+            "pkgmgr.actions.install.install_repos", side_effect=install_side_effect
+        ):
+            # 1) silent=True: should NOT raise (even though failures happened)
+            UpdateManager().run(
+                selected_repos=repos,
+                repositories_base_dir="/tmp/repos",
+                bin_dir="/tmp/bin",
+                all_repos=repos,
+                no_verification=True,
+                system_update=False,
+                preview=True,
+                quiet=True,
+                update_dependencies=False,
+                clone_mode="shallow",
+                silent=True,
+                force_update=True,
+            )
+
+            # Ensure it tried all pulls, and installs happened for B and C only.
+            self.assertEqual(pull_calls, ["repo-a", "repo-b", "repo-c"])
+            self.assertEqual([r for r, _silent, _emit in install_calls], ["repo-b", "repo-c"])
+
+            # Ensure UpdateManager suppressed install summary spam by passing emit_summary=False.
+            for _repo_name, _silent, emit_summary in install_calls:
+                self.assertFalse(emit_summary)
+
+            # Reset tracking for the non-silent run
+            pull_calls.clear()
+            install_calls.clear()
+
+            # 2) silent=False: should raise SystemExit(1) at end due to failures
+            with self.assertRaises(SystemExit) as cm:
+                UpdateManager().run(
+                    selected_repos=repos,
+                    repositories_base_dir="/tmp/repos",
+                    bin_dir="/tmp/bin",
+                    all_repos=repos,
+                    no_verification=True,
+                    system_update=False,
+                    preview=True,
+                    quiet=True,
+                    update_dependencies=False,
+                    clone_mode="shallow",
+                    silent=False,
+                    force_update=True,
+                )
+            self.assertEqual(cm.exception.code, 1)
+
+            # Still must have processed all repos (continue-on-failure behavior).
+            self.assertEqual(pull_calls, ["repo-a", "repo-b", "repo-c"])
+            self.assertEqual([r for r, _silent, _emit in install_calls], ["repo-b", "repo-c"])
+
+
+if __name__ == "__main__":
+    unittest.main()