Fix query-failure fallback for bzlmod-only workspaces

The per-repo rdeps query-failure fallback filtered out every `@@` label
on the assumption that the hash set was mostly workspace-local `//...`
targets. That assumption does not hold on bzlmod-only workspaces where
`generate-hashes` emits almost entirely `@@canonical` labels plus a
small number of `//external:<apparent>` bzlmod-synthetic bridges, with
zero workspace-local targets.

On such workspaces, a single failed `rdeps(//..., @@<repo>//...)` query
(for example, one caused by an unrelated loading error elsewhere in the
dep graph) left the filter with only the `//external:*` bridges, which
the downstream `excludeExternalTargets=true` default (Tinder#334) then strips
entirely — producing silently-empty impacted output on what should be a
"conservatively rebuild everything" signal.

Mirror the outer catch at line 401 and mark every hashed target as
impacted on per-repo query failure. Downstream filters (`targetTypes`,
`excludeExternalTargets`) remain the caller's responsibility, which is
the whole point of surfacing the full set upstream.

Add a regression test in CalculateImpactedTargetsInteractorModuleQueryTest
that constructs a bzlmod-shaped hash set (two `@@abseil-cpp+` targets +
one `//external:*` bridge, no workspace targets), stubs
`queryService.query` to throw, and asserts all three labels appear in
the output.

Author: rdark

cli/src/main/kotlin/com/bazel_diff/interactor/CalculateImpactedTargetsInteractor.kt

@@ -374,7 +374,18 @@ class CalculateImpactedTargetsInteractor : KoinComponent {
         } catch (e: Exception) {
           logger.w { "Failed to query rdeps for @@$repoName: ${e.message}" }
           logger.w { "Conservatively marking all targets as impacted for this module" }
-          impactedTargets.addAll(allTargets.keys.filter { !it.startsWith("@@") })
+          // Mirror the outer catch: mark every hashed target as impacted.
+          //
+          // Previously this filtered out `@@...` labels on the assumption that
+          // the hash set was mostly workspace-local `//...` targets. That
+          // assumption breaks on bzlmod-only workspaces where `generate-hashes`
+          // emits almost entirely `@@` canonical-repo labels and
+          // `//external:<apparent>` bridges, with zero `//...` workspace
+          // targets. The filter then left nothing, which — after the downstream
+          // `excludeExternalTargets=true` default strip of `//external:*` —
+          // produced silently-empty impacted output on query failure instead of
+          // the intended "conservatively rebuild" signal.
+          impactedTargets.addAll(allTargets.keys)
         }
       }
 

cli/src/test/kotlin/com/bazel_diff/interactor/CalculateImpactedTargetsInteractorModuleQueryTest.kt

@@ -312,6 +312,44 @@ class CalculateImpactedTargetsInteractorModuleQueryTest : KoinTest {
     verify(queryService).query(eq("rdeps(//..., @@abseil-cpp+//...)"), eq(false))
   } }
 
+  @Test
+  fun queryFailureMarksAllHashedTargetsImpactedIncludingExternal() { runBlocking {
+    // On bzlmod-only workspaces the hash set is almost entirely `@@canonical`
+    // and `//external:<apparent>` bridges with zero workspace-local `//...`
+    // targets. If the per-repo rdeps query fails, the conservative fallback
+    // must still surface a non-empty impacted set — otherwise the downstream
+    // `excludeExternalTargets=true` default strips the only remaining labels
+    // and the CLI reports zero impacted targets on what is really a
+    // "rebuild everything" condition.
+    val hashes = mapOf(
+        "@@abseil-cpp+//absl:strings" to TargetHash("Rule", "a", "a"),
+        "@@abseil-cpp+//absl:base" to TargetHash("Rule", "b", "b"),
+        "//external:com_google_absl" to TargetHash("Rule", "c", "c"))
+
+    whenever(queryService.discoverRepoMapping())
+        .thenReturn(mapOf("abseil-cpp" to "abseil-cpp+"))
+    whenever(queryService.query(any(), any()))
+        .thenThrow(RuntimeException("simulated bazel query failure"))
+
+    val writer = StringWriter()
+    CalculateImpactedTargetsInteractor().execute(
+        from = hashes,
+        to = hashes,
+        outputWriter = writer,
+        targetTypes = null,
+        fromModuleGraphJson = graph("abseil-cpp", "20240116.2"),
+        toModuleGraphJson = graph("abseil-cpp", "20240722.0"))
+
+    verify(queryService).query(eq("rdeps(//..., @@abseil-cpp+//...)"), eq(false))
+    // Every hashed label must appear in the fallback output, including `@@`
+    // and `//external:*`. Downstream filters (targetTypes, excludeExternalTargets)
+    // are the caller's responsibility.
+    assertThat(outputLines(writer)).containsExactlyInAnyOrder(
+        "@@abseil-cpp+//absl:strings",
+        "@@abseil-cpp+//absl:base",
+        "//external:com_google_absl")
+  } }
+
   @Test
   fun executeWithDistancesRunsModuleQueryPath() { runBlocking {
     // Covers the parallel module-query call site in `executeWithDistances`.