fix: honor view_path scoping in ha_config_get_dashboard get mode (#2023)

* fix: honor view_path scoping in ha_config_get_dashboard get mode

Get mode accepted view_path but returned the full multi-view config
regardless (the parameter only selected the screenshot render view), so a
single-view read on a large dashboard blew up the response. view_path now
scopes the get-mode payload to the matched view: the response carries
view + view_index instead of config (so the view object cannot be pushed
back as a full-config replacement), while config_hash still covers the
full config so python_transform optimistic locking works unchanged. The
matcher is shared with screenshot view resolution, so semantics and
errors (unknown/empty/strategy paths) stay identical, and scoping works
without the screenshot beta feature.

Also adds the standard fields= projection to ha_report_issue, whose full
response repeats the captured logs in the raw keys and in each template.

Closes #2010

* fix: address CI drift check and review findings

- Register ha_report_issue in the fields-projection drift check
  (TOOL_SPECS) and enumerate all projectable keys in the fields=
  description ('Available keys: ...') — fixes the Unit Tests CI failure.
- Warn when view_path is passed to mode='search' (cross-dashboard
  search-all), matching the ignored-parameter warning the other non-get
  modes already emit instead of silently dropping it.
- Start the ha_report_issue docstring with an approved action verb
  (Codex review).
- Broaden the _note_screenshot_ignored docstring to cover view_path and
  tighten two Field description wordings.
- Add tests: non-dict config with view_path, screenshot-option
  view_path branch selection, CSV-string fields form, search-all
  ignored-view_path warning.

---------

Co-authored-by: kingpanther13 <kingpanther13@users.noreply.github.com>

Author: kingpanther13

src/ha_mcp/dashboard_screenshot/paths.py

@@ -347,42 +347,28 @@ async def fetch_dashboard_render_config(
     return cast(dict[str, Any], config)
 
 
-def resolve_dashboard_view(
+def match_dashboard_view(
     dashboard_url_path: str,
     config: dict[str, Any],
-    view_path: str | None,
-) -> DashboardRenderTarget:
-    """Resolve one named Lovelace view to a canonical frontend route."""
-    base_path = dashboard_frontend_path(dashboard_url_path)
-    if view_path is None:
-        views = config.get("views")
-        has_static_views = isinstance(views, list) and bool(views)
-        if "strategy" in config:
-            warning = (
-                "No view_path was supplied; this strategy dashboard generates "
-                "its views at runtime, so only the base route is available."
-            )
-        elif has_static_views:
-            warning = (
-                "No view_path was supplied; the dashboard base route renders "
-                "the first view visible to Puppet's Home Assistant user."
-            )
-        else:
-            warning = (
-                "No view_path was supplied and the dashboard has no static views; "
-                "only the base route is available."
-            )
-        return DashboardRenderTarget(
-            dashboard_url_path=base_path,
-            view_path=None,
-            render_path=base_path,
-            view_index=None,
-            stable=False,
-            warnings=(warning,),
-        )
-
-    cleaned_view_path = view_path
-    if not cleaned_view_path.strip():
+    view_path: str,
+    *,
+    strategy_suggestions: tuple[str, ...] = (
+        "Use dashboard_path with the frontend route instead",
+    ),
+) -> tuple[int, dict[str, Any]]:
+    """Match one named Lovelace view by its configured ``views[].path``.
+
+    Shared by screenshot view resolution and get-mode view scoping so both
+    honour identical semantics: exact match on the configured path, with
+    structured errors for an empty path, a strategy dashboard (no static
+    views to match), and a missing/ambiguous path (the not-found error lists
+    the available paths). Returns ``(view_index, view)``.
+
+    ``strategy_suggestions`` lets each caller phrase the strategy-dashboard
+    remediation in its own vocabulary (the screenshot tools have a
+    ``dashboard_path`` route parameter; config scoping does not).
+    """
+    if not view_path.strip():
         raise_tool_error(
             create_error_response(
                 ErrorCode.VALIDATION_INVALID_PARAMETER,
@@ -397,9 +383,9 @@ def resolve_dashboard_view(
                 "Strategy dashboards do not expose static named view paths.",
                 context={
                     "dashboard_url_path": dashboard_url_path,
-                    "view_path": cleaned_view_path,
+                    "view_path": view_path,
                 },
-                suggestions=["Use dashboard_path with the frontend route instead"],
+                suggestions=list(strategy_suggestions),
             )
         )
     views = config.get("views")
@@ -408,7 +394,7 @@ def resolve_dashboard_view(
     matches = [
         (index, view)
         for index, view in enumerate(views)
-        if _configured_view_path(view) == cleaned_view_path
+        if _configured_view_path(view) == view_path
     ]
     if len(matches) != 1:
         available = [
@@ -420,17 +406,57 @@ def resolve_dashboard_view(
         raise_tool_error(
             create_error_response(
                 ErrorCode.RESOURCE_NOT_FOUND,
-                f"Dashboard view path '{cleaned_view_path}' is {reason}.",
+                f"Dashboard view path '{view_path}' is {reason}.",
                 context={
                     "dashboard_url_path": dashboard_url_path,
-                    "view_path": cleaned_view_path,
+                    "view_path": view_path,
                     "available_view_paths": available,
                 },
                 suggestions=["Use a view_path returned by ha_config_get_dashboard"],
             )
         )
+    return matches[0]
+
 
-    view_index, _ = matches[0]
+def resolve_dashboard_view(
+    dashboard_url_path: str,
+    config: dict[str, Any],
+    view_path: str | None,
+) -> DashboardRenderTarget:
+    """Resolve one named Lovelace view to a canonical frontend route."""
+    base_path = dashboard_frontend_path(dashboard_url_path)
+    if view_path is None:
+        views = config.get("views")
+        has_static_views = isinstance(views, list) and bool(views)
+        if "strategy" in config:
+            warning = (
+                "No view_path was supplied; this strategy dashboard generates "
+                "its views at runtime, so only the base route is available."
+            )
+        elif has_static_views:
+            warning = (
+                "No view_path was supplied; the dashboard base route renders "
+                "the first view visible to Puppet's Home Assistant user."
+            )
+        else:
+            warning = (
+                "No view_path was supplied and the dashboard has no static views; "
+                "only the base route is available."
+            )
+        return DashboardRenderTarget(
+            dashboard_url_path=base_path,
+            view_path=None,
+            render_path=base_path,
+            view_index=None,
+            stable=False,
+            warnings=(warning,),
+        )
+
+    view_index, _ = match_dashboard_view(dashboard_url_path, config, view_path)
+    cleaned_view_path = view_path
+    views = config.get("views")
+    if not isinstance(views, list):
+        views = []
     render_path = _safe_named_render_path(base_path, cleaned_view_path)
     if render_path is None:
         return _fallback_view_target(

src/ha_mcp/tools/tools_bug_report.py

@@ -34,7 +34,7 @@
 )
 from .component_api import get_component_caps
 from .helpers import log_tool_usage, register_tool_methods
-from .util_helpers import ANSI_ESCAPE_RE
+from .util_helpers import ANSI_ESCAPE_RE, JSON_STRING_COERCION, project_fields
 
 logger = logging.getLogger(__name__)
 
@@ -676,10 +676,38 @@ async def ha_report_issue(
                 ),
             ),
         ] = 10,
+        fields: Annotated[
+            str | list[str] | None,
+            JSON_STRING_COERCION,
+            Field(
+                default=None,
+                description=(
+                    "Return only the specified top-level response keys — the "
+                    "full response (both templates + logs + diagnostics, with "
+                    "log content repeated across the raw keys and templates) "
+                    "is very large. "
+                    "None = full response. Typical for a runtime bug: "
+                    "'runtime_bug_template,suggested_title,"
+                    "runtime_bug_submit_url,duplicate_check_urls,"
+                    "anonymization_guide,instructions'; for agent feedback "
+                    "swap in agent_behavior_template and "
+                    "agent_behavior_submit_url. The templates already embed "
+                    "the relevant logs, so the raw log keys are only needed "
+                    "for your own analysis. "
+                    "Available keys: diagnostic_info, recent_logs, "
+                    "startup_logs, addon_logs, core_error_log, log_count, "
+                    "startup_log_count, formatted_report, "
+                    "runtime_bug_template, agent_behavior_template, "
+                    "anonymization_guide, suggested_title, "
+                    "runtime_bug_submit_url, agent_behavior_submit_url, "
+                    "duplicate_check_urls, missing_tool_hint, instructions."
+                ),
+            ),
+        ] = None,
         ctx: Context | None = None,
     ) -> dict[str, Any]:
         """
-        Collect diagnostic information for filing issue reports or feedback.
+        Get diagnostic information and templates for filing issue reports or feedback.
 
         This tool generates templates for TWO types of reports:
         1. **Runtime Bug Report** - For ha-mcp errors, failures, unexpected behavior
@@ -709,7 +737,10 @@ async def ha_report_issue(
         - "That was inefficient"
 
         **OUTPUT:**
-        Returns both templates plus diagnostic data. Key fields:
+        Returns both templates plus diagnostic data. The full response is
+        LARGE (the captured logs appear in the raw log keys AND inside each
+        template) — pass fields=... to fetch only the keys you need once you
+        know which template applies. Key fields:
         - `runtime_bug_template`, `agent_behavior_template` — pick based on context
         - `recent_logs`, `startup_logs` — captured ha-mcp tool/server log entries
         - `addon_logs` — addon container stdout/stderr (HA add-on installs only;
@@ -843,7 +874,7 @@ async def ha_report_issue(
             for keyword in search_keywords[:3]  # Limit to top 3 keywords
         ]
 
-        return {
+        result: dict[str, Any] = {
             "success": True,
             "diagnostic_info": diagnostic_info,
             "recent_logs": recent_logs,
@@ -934,6 +965,7 @@ async def ha_report_issue(
                 "CRITICAL: Always ANONYMIZE the report BEFORE presenting it in markdown code blocks!"
             ),
         }
+        return project_fields(result, fields)
 
 
 def register_bug_report_tools(mcp: Any, client: Any, **kwargs: Any) -> None: