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.

Replace the unconditional `!startsWith("@@")` filter with a shape-aware
fallback:

  - Compute a "buildable workspace" set that excludes BOTH `@@canonical`
    transitives AND `//external:<apparent>` bridges.
  - If that set is non-empty (mixed WORKSPACE + bzlmod, or WORKSPACE-only
    shapes), emit it — preserves pre-existing granularity, avoids leaking
    tens of thousands of `@@` transitives into the impacted set on a
    single flaky `bazel query`.
  - If it is empty (bzlmod-only shape), fall through to `allTargets.keys`
    so the downstream filter has something to keep — rebuild-everything
    signal rather than a directly-buildable label list.

Adds a mixed-shape regression test asserting that `@@` transitives and
`//external:*` bridges do NOT leak into the fallback when buildable
workspace labels are present, complementing the existing bzlmod-only
test. An unconditional `allTargets.keys` fallback fails the new test;
the pre-commit `!startsWith("@@")` filter fails the existing bzlmod-only
one. Only the shape-aware fallback passes both.

Author: rdark

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

@@ -373,8 +373,18 @@ class CalculateImpactedTargetsInteractor : KoinComponent {
         logger.i { "Found ${rdepLabels.size} workspace targets depending on changed modules" }
         impactedTargets.addAll(rdepLabels)
       } catch (e: Exception) {
-        logger.e(e) { "Unioned rdeps query failed - conservatively marking all workspace targets impacted" }
-        impactedTargets.addAll(allTargets.keys.filter { !it.startsWith("@@") })
+        logger.e(e) { "Unioned rdeps query failed - conservatively marking all targets impacted" }
+        // Emit the buildable workspace subset when it exists; otherwise
+        // (bzlmod-only shape) fall through to every hashed label so the
+        // downstream `excludeExternalTargets` strip does not reduce the
+        // fallback to empty.
+        val buildableWorkspaceTargets = allTargets.keys.filter {
+          !it.startsWith("@@") && !it.startsWith("//external:")
+        }
+        impactedTargets.addAll(
+            if (buildableWorkspaceTargets.isEmpty()) allTargets.keys
+            else buildableWorkspaceTargets
+        )
       }
     }
 

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

@@ -328,6 +328,65 @@ class CalculateImpactedTargetsInteractorModuleQueryTest : KoinTest {
     assertThat(queryCaptor.firstValue).contains("@@abseil-cpp+//...")
   } }
 
+  @Test
+  fun queryFailureOnBzlmodOnlyShapeEmitsAllHashedLabels() { runBlocking {
+    // No workspace-local `//...` labels, so the fallback must surface the
+    // full hash set. Otherwise the downstream `excludeExternalTargets`
+    // strip reduces it to empty.
+    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"))
+
+    assertThat(outputLines(writer)).containsExactlyInAnyOrder(
+        "@@abseil-cpp+//absl:strings",
+        "@@abseil-cpp+//absl:base",
+        "//external:com_google_absl")
+  } }
+
+  @Test
+  fun queryFailureOnMixedWorkspacePreservesGranularity() { runBlocking {
+    // Fallback must return only the buildable `//...` subset when one
+    // exists, not every hashed label.
+    val hashes = mapOf(
+        "//app:app" to TargetHash("Rule", "a", "a"),
+        "//lib:util" to TargetHash("Rule", "b", "b"),
+        "@@abseil-cpp+//absl:strings" to TargetHash("Rule", "c", "c"),
+        "@@other+//x:y" to TargetHash("Rule", "d", "d"),
+        "//external:abseil-cpp" to TargetHash("Rule", "e", "e"))
+
+    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"))
+
+    assertThat(outputLines(writer)).containsExactlyInAnyOrder(
+        "//app:app", "//lib:util")
+  } }
+
   @Test
   fun executeWithDistancesRunsModuleQueryPath() { runBlocking {
     // Covers the parallel module-query call site in `executeWithDistances`.