exit with status code 1 if anything went wrong

Author: guilherme-puida

startriage/cli.py

@@ -358,23 +358,25 @@ def _outputcfg_from_args(args: argparse.Namespace, persistor: BugPersistor | Non
 
 def main() -> None:
     try:
-        asyncio.run(_run())
+        had_errors = asyncio.run(_run())
     except KeyboardInterrupt:
         sys.exit(130)
+    if had_errors:
+        sys.exit(1)
 
 
-async def _run() -> None:
+async def _run() -> bool:
     parser = _build_parser()
     args = parser.parse_args()
 
     log_setup(args.verbose - args.quiet)
 
     config = load_config(args.config)
 
-    await args.func(args, config)
+    return bool(await args.func(args, config))
 
 
-async def _run_triage(args: argparse.Namespace, config: StarTriageConfig) -> None:
+async def _run_triage(args: argparse.Namespace, config: StarTriageConfig) -> bool:
     provider = None
     output_cfg = _outputcfg_from_args(args)
     if args.ai is not None:
@@ -401,7 +403,7 @@ async def _run_triage(args: argparse.Namespace, config: StarTriageConfig) -> Non
         general = general.model_copy(update={"proposed_min_age": args.proposed_min_age})
     config.general = general
 
-    results = await run_triage(config, filter, output_cfg)
+    results, had_errors = await run_triage(config, filter, output_cfg)
 
     if args.ai is not None:
         from .ai import emit_ai_report, run_ai_over_triage_results
@@ -410,8 +412,10 @@ async def _run_triage(args: argparse.Namespace, config: StarTriageConfig) -> Non
         if report is not None:
             emit_ai_report(report, output_cfg.markdown_path)
 
+    return had_errors
 
-async def _run_todo(args: argparse.Namespace, config: StarTriageConfig) -> None:
+
+async def _run_todo(args: argparse.Namespace, config: StarTriageConfig) -> bool:
     if args.flag_recent is None and not args.subscribed:
         args.flag_recent = 6  # default flag-recent for todo mode
 
@@ -426,36 +430,37 @@ async def _run_todo(args: argparse.Namespace, config: StarTriageConfig) -> None:
 
     output_cfg = _outputcfg_from_args(args, BugPersistor(save_cfg))
 
-    await run_todo(
+    return await run_todo(
         config,
         filter,
         output_cfg=output_cfg,
         subscribed=args.subscribed,
     )
 
 
-async def _run_analyze(args: argparse.Namespace, config: StarTriageConfig) -> None:
+async def _run_analyze(args: argparse.Namespace, config: StarTriageConfig) -> bool:
     if args.ai is None:
         from .ai import describe_bug_specs
 
         report = await describe_bug_specs(args.bug)
         if report is None:
             print("No valid bugs found.", file=sys.stderr)
-            return
+            return True
         print(report)
-        return
+        return False
 
     from .ai import build_provider, run_ai_over_bug_specs
 
     provider = build_provider(config.ai, args.ai)
     report = await run_ai_over_bug_specs(config, args.bug, provider=provider)
     if report is None:
         print("No valid bugs to triage.", file=sys.stderr)
-        return
+        return True
     print(report)
+    return False
 
 
-async def _set_config_settings(args: argparse.Namespace, _config: StarTriageConfig) -> None:
+async def _set_config_settings(args: argparse.Namespace, _config: StarTriageConfig) -> bool:
     updates: dict[str, dict] = {}
 
     if args.default_team:
@@ -489,13 +494,14 @@ async def _set_config_settings(args: argparse.Namespace, _config: StarTriageConf
 
     if not updates:
         print("No settings to update.")
-        return
+        return False
 
     sensitive = "github_token" in updates.get("general", {}) or bool(
         {"github_token", "openrouter_api_key"} & updates.get("ai", {}).keys()
     )
     path = update_user_config(updates, config_path=args.config, sensitive=sensitive)
     print(f"Settings saved to {path!r}")
+    return False
 
 
 async def _show_config(args: argparse.Namespace, config: StarTriageConfig) -> None:

startriage/triage.py

@@ -49,11 +49,12 @@ async def run_triage(
     config: StarTriageConfig,
     opts: TaskFilterOptions,
     output_cfg: OutputConfig,
-) -> list[tuple[str, TriageResult]]:
+) -> tuple[list[tuple[str, TriageResult]], bool]:
     """Daily triage: fetch all sources concurrently, print sections in order as they complete.
 
-    Returns the ``(source_name, result)`` pairs that were fetched successfully so
-    callers (e.g. ``triage --ai``) can reuse them without re-fetching.
+    Returns a tuple of the ``(source_name, result)`` pairs that were fetched
+    successfully (so callers such as ``triage --ai`` can reuse them without
+    re-fetching) and a ``had_errors`` flag indicating whether any source failed.
     """
 
     range = triage_task_note = ""
@@ -99,7 +100,7 @@ async def run_triage(
     for source in opts.sources:
         fetch_tasks[source.name] = asyncio.create_task(source.find(config, opts, FetchMode.triage))
 
-    results = await _output_results(output_cfg, fetch_tasks)
+    results, had_errors = await _output_results(output_cfg, fetch_tasks)
 
     # create markdown template
     if output_cfg.markdown_path:
@@ -126,20 +127,22 @@ async def run_triage(
 
         logging.info("Markdown written to %s", output_cfg.markdown_path)
 
-    return results
+    return results, had_errors
 
 
 async def run_todo(
     config: StarTriageConfig,
     filter: TaskFilterOptions,
     output_cfg: OutputConfig,
     subscribed: bool = False,
-) -> None:
+) -> bool:
     """Todo / housekeeping triage: tag-filtered bugs, no date filter.
 
     All sources in *filter.sources* are optional — pass a subset to fetch only
     that source.  *subscribed* only controls LP fetch mode (subscription list
     vs. todo tag); GitHub is filtered by label regardless.
+
+    Returns ``had_errors``, ``True`` if any source failed to fetch.
     """
     mode = FetchMode.subscribed if subscribed else FetchMode.todo
 
@@ -150,17 +153,20 @@ async def run_todo(
     for source in filter.sources:
         fetch_tasks[source.name] = asyncio.create_task(source.find(config, filter, mode))
 
+    had_errors = False
     if output_cfg.bug_persistor is not None:
-        results = await _output_results(output_cfg, fetch_tasks)
+        results, had_errors = await _output_results(output_cfg, fetch_tasks)
         for _, result in results:
             await result.record(output_cfg.bug_persistor)
 
         output_cfg.bug_persistor.save()
 
+    return had_errors
+
 
 async def _output_results(
     output_cfg: OutputConfig, fetch_tasks: dict[str, asyncio.Task[TriageResult]]
-) -> list[tuple[str, TriageResult]]:
+) -> tuple[list[tuple[str, TriageResult]], bool]:
     async with Spinner(set(fetch_tasks.keys())) as spinner:
         gathered: list[tuple[str, TriageResult | Exception]] = await asyncio.gather(
             *[_await_and_print(output_cfg, source, task, spinner) for source, task in fetch_tasks.items()]
@@ -172,7 +178,8 @@ async def _output_results(
             print(f"\nError fetching {source!r}:", file=sys.stderr)
             traceback.print_exception(exc, file=sys.stderr)
 
-    return [(s, r) for s, r in gathered if not isinstance(r, Exception)]
+    results = [(s, r) for s, r in gathered if not isinstance(r, Exception)]
+    return results, bool(errors)
 
 
 # Print sections in canonical order as each completes