boomtick-cli 0.7.0__tar.gz → 0.8.0__tar.gz

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boomtick-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: BoomTick CLI — agentic dev-tools for GitHub + AI workflows
 Author: Ariel Anders
 Project-URL: Homepage, https://github.com/arii/boomtick

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/boomtick_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: boomtick-cli
-Version: 0.7.0
+Version: 0.8.0
 Summary: BoomTick CLI — agentic dev-tools for GitHub + AI workflows
 Author: Ariel Anders
 Project-URL: Homepage, https://github.com/arii/boomtick

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/boomtick_cli.egg-info/SOURCES.txt

@@ -117,12 +117,14 @@ dev_tools/workflows/runner.py
 tests/test_build_repo_context.py
 tests/test_config.py
 tests/test_dependency_graph.py
+tests/test_detect_conflicts.py
 tests/test_fail_fast.py
 tests/test_github_diff_parser.py
 tests/test_github_no_gh.py
 tests/test_github_parser.py
 tests/test_install_workflows.py
 tests/test_issue_validation_local.py
+tests/test_issue_view.py
 tests/test_jules_batch_send.py
 tests/test_labels.py
 tests/test_latency_mitigation.py

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/cli.py

@@ -296,6 +296,7 @@ def search_prs(ctx, state, limit, include_drafts, labels):
 @click.option("--labels")
 @click.pass_context
 def search_issues(ctx, state, limit, labels):
+    """Search for GitHub issues (excluding pull requests) in the repository."""
     orch = ctx.obj["ORCHESTRATOR"]
     label_list = [l.strip() for l in labels.split(",")] if labels else None
 
@@ -424,10 +425,15 @@ def create_issue(ctx, title, file, body):
 
 
 @gh.command()
-@click.option("--issue-number", type=int, required=True, help="The GitHub issue number to view")
+@click.argument("issue_number_arg", required=False, type=int)
+@click.option("--issue-number", "issue_number_opt", type=int, help="The GitHub issue number to view")
 @click.pass_context
-def issue_view(ctx, issue_number):
+def issue_view(ctx, issue_number_arg, issue_number_opt):
     """View details of a GitHub issue."""
+    issue_number = issue_number_arg if issue_number_arg is not None else issue_number_opt
+    if issue_number is None:
+        err(ctx, "Provide --issue-number or a positional issue number")
+
     orch = ctx.obj["ORCHESTRATOR"]
     issue = orch.get_issue_details(issue_number)
     msg = f"Issue #{issue.get('number')}: {issue.get('title')}\nState: {issue.get('state')}\n\n{issue.get('body')}"
@@ -686,11 +692,14 @@ def verify_versions(ctx, diff_input):
 
 
 @gh.command()
-@click.option("--pr", type=int)
+@click.option("--pr", type=int, help="PR number to detect conflicts for")
+@click.option("--all", "all_prs", is_flag=True, help="Detect conflicts for all open PRs")
 @click.pass_context
-def detect_conflicts(ctx, pr):
+def detect_conflicts(ctx, pr, all_prs):
+    if pr is not None and all_prs:
+        err(ctx, "Provide either --pr or --all, not both")
     orch = ctx.obj["ORCHESTRATOR"]
-    conflicts = orch.handle_detect_conflicts(pr_num=pr)
+    conflicts = orch.handle_detect_conflicts(pr_num=pr, all_prs=all_prs)
     _render_conflicts(ctx, conflicts)
 
 

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/orchestrator.py

@@ -19,6 +19,8 @@ from dev_tools.ux_report import generate_report
 if TYPE_CHECKING:
     from dev_tools.services.ai_service import AIClient
     from dev_tools.services.vision_service import VisionService
+    from dev_tools.workflows.graph import WorkflowGraph
+    from dev_tools.workflows.context import WorkflowContext
 
 from dev_tools.config import get_config
 from dev_tools.handlers.command_handler import CommandHandler
@@ -477,6 +479,9 @@ class Orchestrator:
         if res is None:
             raise CLIError("Nothing to update. Provide body, labels, or state.")
 
+        if isinstance(res, list) or not isinstance(res, dict) or not all(k in res for k in ["number", "title", "html_url", "state"]):
+            res = self.github.fetch_issue_details(issueNumber)
+
         return {"status": "success", "issue": IssueSummary(**res).model_dump()}
 
     def post_comment(self, entity_number: int, body: Optional[str]) -> Dict[str, Any]:
@@ -593,8 +598,11 @@ class Orchestrator:
             "total_findings": total_findings,
         }
 
-    def handle_detect_conflicts(self, pr_num: Optional[int] = None) -> List[Dict[str, Any]]:
-        conflicts = self.detect_conflicts(pr_num)
+    def handle_detect_conflicts(self, pr_num: Optional[int] = None, all_prs: bool = False) -> List[Dict[str, Any]]:
+        if pr_num is not None and all_prs:
+            raise CLIError("Provide either pr_num or all_prs, not both")
+        target_pr = pr_num if not all_prs else None
+        conflicts = self.detect_conflicts(target_pr)
         formatted = []
         for pr_pair, files in conflicts.items():
             formatted.append({"prs": list(pr_pair), "files": files})
@@ -732,7 +740,7 @@ class Orchestrator:
         review_dir = get_or_create_log_dir("reviews")
         ctx_path = os.path.join(review_dir, f"pr-context-{prNumber}.md")
         rev_path = os.path.join(review_dir, f"pr-review-{prNumber}.md")
-        res = {"pr": prNumber, "files": {}}
+        res: Dict[str, Any] = {"pr": prNumber, "files": {}}
         if fetch:
             repo = get_github_client().get_repo(get_repo_name())
             pr = repo.get_pull(prNumber)
@@ -991,7 +999,7 @@ class Orchestrator:
             try:
                 import importlib_metadata  # type: ignore
             except ImportError:
-                importlib_metadata = None
+                importlib_metadata = None  # type: ignore[assignment]
 
         if importlib_metadata:
             otel_issues = []
@@ -1926,18 +1934,42 @@ Follow the "Audit comment template" in `docs/agent/issue-audit-rules.md` to post
         checks = self.github.fetch_check_runs(head_sha)
         failed_checks = [c for c in checks if c.get("conclusion") == "failure"]
 
-        logs = {}
+        logs: dict[str, str] = {}
         # Get check suites to find workflow runs
         check_suites = self.github.fetch_check_suites(head_sha)
 
-        for suite in check_suites:
-            runs = self.github.fetch_check_runs_for_suite(suite["id"])
-            for run in runs:
-                if include_all or run.get("conclusion") == "failure":
-                    run_id = run.get("id")
-                    if isinstance(run_id, int):
-                        log_content = self.github.fetch_check_run_logs(run_id, external_id=run.get("external_id"))
-                        logs[run["name"]] = log_content[:10000]
+        all_runs = []
+        import concurrent.futures
+        if check_suites:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(check_suites))) as executor:
+                suite_futures = {executor.submit(self.github.fetch_check_runs_for_suite, suite["id"]): suite for suite in check_suites}
+                for future in concurrent.futures.as_completed(suite_futures):
+                    try:
+                        runs = future.result()
+                        all_runs.extend(runs)
+                    except Exception as e:
+                        suite = suite_futures[future]
+                        log_warn(f"Failed to fetch runs for suite {suite.get('id')}: {e}")
+
+        runs_to_fetch = [run for run in all_runs if include_all or run.get("conclusion") == "failure"]
+
+        def fetch_log(run):
+            run_id = run.get("id")
+            if isinstance(run_id, int):
+                return run["name"], self.github.fetch_check_run_logs(run_id, external_id=run.get("external_id"))
+            return None, None
+
+        if runs_to_fetch:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(runs_to_fetch))) as executor:
+                log_futures = {executor.submit(fetch_log, run): run for run in runs_to_fetch}
+                for future in concurrent.futures.as_completed(log_futures):
+                    try:
+                        name, log_content = future.result()
+                        if name and isinstance(name, str) and log_content and isinstance(log_content, str):
+                            logs[name] = log_content[:10000]
+                    except Exception as e:
+                        run = log_futures[future]
+                        log_warn(f"Failed to fetch log for run {run.get('id')}: {e}")
 
         return {"checks": checks, "failedChecks": failed_checks, "logs": logs}
 
@@ -1957,8 +1989,11 @@ Follow the "Audit comment template" in `docs/agent/issue-audit-rules.md` to post
         # Limit to latest 20 jobs to avoid extreme memory usage
         for run in check_runs[:20]:
             # Fetch logs via API to avoid terminal paging/buffering issues
-            log_content = self.github.fetch_check_run_logs(run.get("id"), external_id=run.get("external_id"))
-            header = f"--- LOGS FOR JOB: {run['name']} (ID: {run['id']}) ---"
+            run_id = run.get("id")
+            if not isinstance(run_id, int):
+                continue
+            log_content = self.github.fetch_check_run_logs(run_id, external_id=run.get("external_id"))
+            header = f"--- LOGS FOR JOB: {run['name']} (ID: {run_id}) ---"
             all_logs.append(header)
             # Truncate each log to 20k chars to balance detail vs memory
             all_logs.append(log_content[-20000:])
@@ -2232,9 +2267,21 @@ Follow the "Audit comment template" in `docs/agent/issue-audit-rules.md` to post
         aggregate_body = ""
         successfully_merged = []
 
+        import concurrent.futures
+        pr_details_map = {}
+        if prNumbers:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(prNumbers))) as executor:
+                future_to_pr = {executor.submit(self.github.fetch_pr_details, pr_num): pr_num for pr_num in prNumbers}
+                for future in concurrent.futures.as_completed(future_to_pr):
+                    pr_num = future_to_pr[future]
+                    try:
+                        pr_details_map[pr_num] = future.result()
+                    except Exception as e:
+                        raise CLIError(f"Failed to fetch PR #{pr_num}: {e}")
+
         for pr_num in prNumbers:
             # 2. Sequential Extraction & Deterministic Sequence
-            pr_data = self.github.fetch_pr_details(pr_num)
+            pr_data = pr_details_map.get(pr_num) or {}
             head_ref = pr_data.get("head", {}).get("ref")
             title = pr_data.get("title")
             body = pr_data.get("body") or ""
@@ -2370,15 +2417,15 @@ Follow the "Audit comment template" in `docs/agent/issue-audit-rules.md` to post
 
         if os.path.exists(impact_script):
             # Use check=False to swallow errors from impact analysis in the planning phase
-            res = run_command(
+            impact_res = run_command(
                 ["npx", "tsx", impact_script],
                 check=False,
                 log_on_error=False,
             )
-            if isinstance(res, subprocess.CompletedProcess):
-                impact_output = (res.stdout or "") + (res.stderr or "")
-                if res.returncode != 0:
-                    impact_output = f"Impact analysis failed (exit {res.returncode}):\n{impact_output}"
+            if isinstance(impact_res, subprocess.CompletedProcess):
+                impact_output = (impact_res.stdout or "") + (impact_res.stderr or "")
+                if impact_res.returncode != 0:
+                    impact_output = f"Impact analysis failed (exit {impact_res.returncode}):\n{impact_output}"
 
         # 6. Existing Review Data
         gemini_review = "None."
@@ -2809,17 +2856,28 @@ Overlapping functionality identified and resolved.
         file_to_prs: Dict[str, set[int]] = defaultdict(set)
         pr_hunks = {}
 
-        for pr_num in prNumbers:
+        def fetch_pr_info(pr_num: int):
             details = self.github.fetch_pr_details(pr_num)
-            pr_details[pr_num] = details
             files = self.github.fetch_pr_files(pr_num)
             diff = self.github.fetch_pr_diff(pr_num)
-            pr_hunks[pr_num] = self._extract_diff_hunks(diff)
-
-            # Explicitly cast to str to satisfy type checkers
-            pr_files = {str(f.get("filename")) for f in files if f.get("filename")}
-            for filename_str in pr_files:
-                file_to_prs[filename_str].add(pr_num)
+            hunks = self._extract_diff_hunks(diff)
+            return pr_num, details, files, hunks
+
+        import concurrent.futures
+        if prNumbers:
+            with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(prNumbers))) as executor:
+                future_to_pr = {executor.submit(fetch_pr_info, pr_num): pr_num for pr_num in prNumbers}
+                for future in concurrent.futures.as_completed(future_to_pr):
+                    pr_num = future_to_pr[future]
+                    try:
+                        pr_num, details, files, hunks = future.result()
+                        pr_details[pr_num] = details
+                        pr_hunks[pr_num] = hunks
+                        pr_files = {str(f.get("filename")) for f in files if f.get("filename")}
+                        for filename_str in pr_files:
+                            file_to_prs[filename_str].add(pr_num)
+                    except Exception as e:
+                        raise CLIError(f"Failed to fetch info for PR #{pr_num}: {e}")
 
         overlapping_files: Dict[str, List[int]] = {
             f: sorted(list(prs)) for f, prs in file_to_prs.items() if len(prs) > 1

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/pr_overlap.py

@@ -1,7 +1,7 @@
 # pylint: disable=invalid-name,line-too-long,missing-docstring,no-value-for-parameter
 import sys
 from collections import defaultdict
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Set, Tuple
 
 import click
 from dev_tools.services.github import GitHubClient
@@ -57,17 +57,17 @@ def get_pr_overlaps(github: GitHubClient, limit: int) -> List[Dict[str, Any]]:
     # We use a simple disjoint-set or just group by overlap.
     # For PR consolidation, we want to see pairs/groups that have overlaps.
 
-    overlaps: Dict[tuple, set] = defaultdict(set)
+    overlaps: Dict[Tuple[int, ...], Set[str]] = defaultdict(set)
     for filename, pr_set in file_to_prs.items():
         if len(pr_set) > 1:
             pr_tuple_key = tuple(sorted(list(pr_set)))
             overlaps[pr_tuple_key].add(filename)
 
     clusters: List[Dict[str, Any]] = []
-    for pr_tuple_key, files in overlaps.items():
+    for pr_tuple_key, overlapping_files in overlaps.items():
         clusters.append({
             "prs": list(pr_tuple_key),
-            "files": sorted(list(files)),
+            "files": sorted(list(overlapping_files)),
             "metadata": {num: pr_metadata[num] for num in pr_tuple_key}
         })
 

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/services/ai_service.py

@@ -147,7 +147,7 @@ class AIClient:
         url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent"
         headers = {"Content-Type": "application/json", "x-goog-api-key": self.gemini_api_key}
 
-        payload = {"contents": [{"parts": [{"text": prompt}]}]}
+        payload: Dict[str, Any] = {"contents": [{"parts": [{"text": prompt}]}]}
 
         if schema:
             payload["generationConfig"] = {
@@ -366,8 +366,8 @@ class AIClient:
                     needs_specialist = bool(triage_data.get("needsSpecialistReview", True))
                     fast_feedback_text = triage_data.get("fastFeedback", "")
                     log_info(f"[AI Triage Success] Triage complete. Needs specialist: {needs_specialist}. Model: {triage_model_used}")
-            except Exception as err:
-                log_warn(f"⚠️ Triage Agent failed, falling back to Specialist review: {err}")
+            except Exception as e:
+                log_warn(f"⚠️ Triage Agent failed, falling back to Specialist review: {e}")
 
         if not needs_specialist and fast_feedback_text:
             log_info("[AI Triage] Fast triage review sufficient. Bypassing specialist review.")
@@ -500,7 +500,8 @@ class AIClient:
         # CI guard: never approve if checks are failing
         if has_ci_failures and final.get("recommendation") == "Approved":
             final["recommendation"] = "Not Approved"
-            final["reviewComment"] = f"CI checks are failing ({failing_names}). Recommendation downgraded.\n\n" + (final.get("reviewComment") or "")
+            final_comment = final.get("reviewComment") or ""
+            final["reviewComment"] = f"CI checks are failing ({failing_names}). Recommendation downgraded.\n\n{final_comment}"
 
         self._write_review_file(pr_num, pr, final, chunks, file_reviews)
         return final

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/services/dependency_graph.py

@@ -3,17 +3,16 @@ from collections import deque
 import json
 import os
 import subprocess
-from typing import Dict, List, Set
+from typing import Any, Dict, List, Set
 
 from dev_tools.utils import CLIError, log_error, log_warn
 
-
 def validate_and_sanitize_graph_data(data: dict) -> dict:
     """Validates and sanitizes the dependency graph data structure."""
     if not isinstance(data, dict):
         raise ValueError("Graph data must be a dictionary")
 
-    sanitized = {}
+    sanitized: Dict[str, Any] = {}
     if "modules" in data:
         if not isinstance(data["modules"], list):
             raise ValueError("modules must be a list")
@@ -21,7 +20,7 @@ def validate_and_sanitize_graph_data(data: dict) -> dict:
         for mod in data["modules"]:
             if not isinstance(mod, dict):
                 raise ValueError("Module must be a dictionary")
-            sanitized_mod = {}
+            sanitized_mod: Dict[str, Any] = {}
             if "source" in mod:
                 if not isinstance(mod["source"], str):
                     raise ValueError("source must be a string")
@@ -33,7 +32,7 @@ def validate_and_sanitize_graph_data(data: dict) -> dict:
                 for dep in mod["dependencies"]:
                     if not isinstance(dep, dict):
                         raise ValueError("Dependency must be a dictionary")
-                    sanitized_dep = {}
+                    sanitized_dep: Dict[str, Any] = {}
                     if "resolved" in dep:
                         if not isinstance(dep["resolved"], str):
                             raise ValueError("resolved must be a string")
@@ -125,20 +124,21 @@ class DependencyGraph:
     def _parse_modules(self, modules: List[Dict]):
         for mod in modules:
             source = mod.get("source")
-            deps = mod.get("dependencies", [])
-            self.graph[source] = deps
+            if isinstance(source, str):
+                deps = mod.get("dependencies", [])
+                self.graph[source] = deps
 
-            for dep in deps:
-                resolved = dep.get("resolved")
-                if resolved:
-                    if resolved not in self.reverse_graph:
-                        self.reverse_graph[resolved] = []
-                    self.reverse_graph[resolved].append(source)
+                for dep in deps:
+                    resolved = dep.get("resolved")
+                    if isinstance(resolved, str):
+                        if resolved not in self.reverse_graph:
+                            self.reverse_graph[resolved] = []
+                        self.reverse_graph[resolved].append(source)
 
     def get_dependencies(self, filepath: str) -> List[str]:
         """Returns files that the given file depends on."""
         deps = self.graph.get(filepath, [])
-        return [d.get("resolved") for d in deps if d.get("resolved")]
+        return [str(d.get("resolved")) for d in deps if isinstance(d.get("resolved"), str)]
 
     def get_dependents(self, filepath: str) -> List[str]:
         """Returns files that depend on the given file."""

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/dev_tools/utils/__init__.py

@@ -8,7 +8,7 @@ import sys
 import time
 import urllib.parse
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union, Literal, overload
 
 import requests  # type: ignore[import-untyped]
 
@@ -60,7 +60,7 @@ def run_git_commands(
     commands: List[List[str]], cwd: Optional[str] = None
 ) -> List[Union[str, subprocess.CompletedProcess[str]]]:
     """Executes a sequence of git commands."""
-    results = []
+    results: List[Union[str, subprocess.CompletedProcess[str]]] = []
     for cmd in commands:
         results.append(run_command(cmd, cwd=cwd))
     return results
@@ -712,6 +712,28 @@ def call_ai_service(
     return None
 
 
+@overload
+def run_command(
+    cmd: Union[str, List[str]],
+    shell: bool = False,
+    check: Literal[True] = True,
+    input_str: Optional[str] = None,
+    log_on_error: bool = True,
+    **kwargs: Any,
+) -> str: ...
+
+
+@overload
+def run_command(
+    cmd: Union[str, List[str]],
+    shell: bool = False,
+    check: Literal[False] = False,
+    input_str: Optional[str] = None,
+    log_on_error: bool = True,
+    **kwargs: Any,
+) -> subprocess.CompletedProcess[str]: ...
+
+
 def run_command(
     cmd: Union[str, List[str]],
     shell: bool = False,

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "boomtick-cli"
-version = "0.7.0"
+version = "0.8.0"
 description = "BoomTick CLI — agentic dev-tools for GitHub + AI workflows"
 authors = [{name = "Ariel Anders"}]
 readme = "README.md"

boomtick_cli-0.8.0/tests/test_detect_conflicts.py

@@ -0,0 +1,83 @@
+# pylint: disable=missing-docstring,protected-access,redefined-outer-name
+import json
+from unittest.mock import patch, MagicMock
+
+import pytest
+from click.testing import CliRunner
+from dev_tools.cli import cli
+from dev_tools.orchestrator import Orchestrator
+
+
+@pytest.fixture
+def orchestrator():
+    with patch("dev_tools.orchestrator.GitHubClient") as mock_gh:
+        orch = Orchestrator()
+        orch._github = mock_gh.return_value
+        yield orch
+
+
+def test_orchestrator_detect_conflicts_specific_pr(orchestrator):
+    with patch.object(orchestrator, "detect_conflicts") as mock_detect:
+        mock_detect.return_value = {(1, 2): ["shared.py"]}
+        res = orchestrator.handle_detect_conflicts(pr_num=1)
+        mock_detect.assert_called_once_with(1)
+        assert len(res) == 1
+        assert res[0]["prs"] == [1, 2]
+        assert res[0]["files"] == ["shared.py"]
+
+
+def test_orchestrator_detect_conflicts_all_prs(orchestrator):
+    with patch.object(orchestrator, "detect_conflicts") as mock_detect:
+        mock_detect.return_value = {(1, 2): ["shared.py"], (3, 4): ["other.py"]}
+        res = orchestrator.handle_detect_conflicts(all_prs=True)
+        mock_detect.assert_called_once_with(None)
+        assert len(res) == 2
+
+
+def test_cli_detect_conflicts_all():
+    runner = CliRunner()
+
+    with patch("dev_tools.cli.LazyOrchestrator") as mock_lazy:
+        mock_orch = MagicMock()
+        mock_lazy.return_value = mock_orch
+
+        # Mock handle_detect_conflicts response
+        mock_orch.handle_detect_conflicts.return_value = [
+            {"prs": [1, 2], "files": ["shared.py"]}
+        ]
+
+        # Invoke CLI command in JSON mode (default)
+        result = runner.invoke(cli, ["gh", "detect-conflicts", "--all"])
+
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["status"] == "success"
+        assert len(data["conflicts"]) == 1
+        assert data["conflicts"][0]["prs"] == [1, 2]
+        mock_orch.handle_detect_conflicts.assert_called_once_with(pr_num=None, all_prs=True)
+
+
+def test_cli_detect_conflicts_specific_pr():
+    runner = CliRunner()
+
+    with patch("dev_tools.cli.LazyOrchestrator") as mock_lazy:
+        mock_orch = MagicMock()
+        mock_lazy.return_value = mock_orch
+
+        mock_orch.handle_detect_conflicts.return_value = []
+
+        result = runner.invoke(cli, ["gh", "detect-conflicts", "--pr", "123"])
+
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["status"] == "success"
+        mock_orch.handle_detect_conflicts.assert_called_once_with(pr_num=123, all_prs=False)
+
+
+def test_cli_detect_conflicts_mutually_exclusive():
+    runner = CliRunner()
+
+    result = runner.invoke(cli, ["gh", "detect-conflicts", "--pr", "123", "--all"])
+
+    assert result.exit_code != 0
+    assert "Provide either --pr or --all, not both" in result.output

boomtick_cli-0.8.0/tests/test_issue_view.py

@@ -0,0 +1,75 @@
+# pylint: disable=missing-docstring,protected-access,redefined-outer-name
+import json
+from unittest.mock import patch, MagicMock
+
+from click.testing import CliRunner
+from dev_tools.cli import cli
+
+
+def test_cli_issue_view_positional():
+    runner = CliRunner()
+
+    with patch("dev_tools.cli.LazyOrchestrator") as mock_lazy:
+        mock_orch = MagicMock()
+        mock_lazy.return_value = mock_orch
+
+        # Mock get_issue_details response
+        mock_orch.get_issue_details.return_value = {
+            "number": 123,
+            "title": "Bug in issue-view",
+            "html_url": "https://github.com/owner/repo/issues/123",
+            "state": "open",
+            "body": "This is a bug report body.",
+        }
+
+        # Invoke CLI with positional argument
+        result = runner.invoke(cli, ["gh", "issue-view", "123"])
+
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["status"] == "success"
+        assert data["issue"]["number"] == 123
+        assert data["issue"]["title"] == "Bug in issue-view"
+        mock_orch.get_issue_details.assert_called_once_with(123)
+
+
+def test_cli_issue_view_flag():
+    runner = CliRunner()
+
+    with patch("dev_tools.cli.LazyOrchestrator") as mock_lazy:
+        mock_orch = MagicMock()
+        mock_lazy.return_value = mock_orch
+
+        mock_orch.get_issue_details.return_value = {
+            "number": 123,
+            "title": "Bug in issue-view",
+            "html_url": "https://github.com/owner/repo/issues/123",
+            "state": "open",
+            "body": "This is a bug report body.",
+        }
+
+        # Invoke CLI with --issue-number flag
+        result = runner.invoke(cli, ["gh", "issue-view", "--issue-number", "123"])
+
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert data["status"] == "success"
+        assert data["issue"]["number"] == 123
+        mock_orch.get_issue_details.assert_called_once_with(123)
+
+
+def test_cli_issue_view_missing():
+    runner = CliRunner()
+
+    with patch("dev_tools.cli.LazyOrchestrator") as mock_lazy:
+        mock_orch = MagicMock()
+        mock_lazy.return_value = mock_orch
+
+        # Invoke CLI with no arguments
+        result = runner.invoke(cli, ["gh", "issue-view"])
+
+        assert result.exit_code != 0
+        data = json.loads(result.output)
+        assert data["status"] == "error"
+        assert "Provide --issue-number or a positional issue number" in data["message"]
+        mock_orch.get_issue_details.assert_not_called()

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/tests/test_labels.py

@@ -83,6 +83,16 @@ class TestLabels(unittest.TestCase):
         self.orch.github.add_labels.assert_called_once_with(123, ["l1"])
         self.orch.github.update_issue.assert_called_once_with(123, body="new body", state=None)
 
+    def test_orchestrator_update_issue_add_labels_returns_list(self):
+        # Reset setup mocks and make add_labels return a list of labels (as GitHub API actually does)
+        self.orch.github.add_labels.return_value = [{"name": "l1"}]
+        # When update_issue detects a list or non-IssueSummary dictionary, it fetches full issue details
+        res = self.orch.update_issue(123, add_labels=["l1"])
+        self.orch.github.add_labels.assert_called_once_with(123, ["l1"])
+        self.orch.github.fetch_issue_details.assert_called_once_with(123)
+        self.assertEqual(res["status"], "success")
+        self.assertEqual(res["issue"]["number"], 123)
+
 
 if __name__ == "__main__":
     unittest.main()

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/tests/test_latency_mitigation.py

@@ -19,8 +19,10 @@ def test_disk_cache_basic(tmp_path):
     assert cache.get(key) == val
 
     # Test expiration
-    cache.set(key, val, ttl=0.1)
+    cache.set(key, val, ttl=5.0)
     assert cache.get(key) == val
+
+    cache.set(key, val, ttl=0.1)
     time.sleep(0.2)
     assert cache.get(key) is None
 

{boomtick_cli-0.7.0 → boomtick_cli-0.8.0}/tests/test_search_issues.py

@@ -1,4 +1,5 @@
 # pylint: disable=missing-docstring,protected-access,redefined-outer-name
+import json
 from unittest.mock import patch, MagicMock
 
 import pytest
@@ -67,7 +68,6 @@ def test_cli_search_issues():
         result = runner.invoke(cli, ["gh", "search-issues", "--state", "open", "--limit", "10", "--labels", "bug,high"])
 
         assert result.exit_code == 0
-        import json
         data = json.loads(result.output)
         assert data["status"] == "success"
         assert len(data["issues"]) == 1