feat(manifest): cover Android Gradle Plugin variants in --facts

Adds an android-library fixture (AGP 8.7.3, compileSdk 34) and the
minimum machinery the init script needs to scrape AGP-flavored
classpaths without blowing up.

Two changes to socket-facts.init.gradle:
- Skip configurations matching *AndroidTest* (instrumented tests).
  Their resolution needs device-vs-host target attributes the init
  script doesn't set, and they fail before producing useful data.
- Wrap per-configuration resolution in try/catch. AGP unit-test
  classpaths (releaseUnitTestCompileClasspath etc.) pull in the
  project's own debugApiElements, which exposes multiple variants
  (android-classes-jar, r-class-jar, android-lint, ...); without
  consumer-side build-type attributes we hit "variant ambiguity"
  errors. We log "[socket-facts] skipping <cfg>: ..." and continue
  so other classpaths still produce output. Production (release +
  debug compile/runtime) variants resolve fine.

The e2e test skips the Android case when neither ANDROID_HOME nor
ANDROID_SDK_ROOT is set — same auto-skip posture as the rest of the
gradle suite. Asserts that androidx.annotation:annotation is captured
as a direct dep, confirming AGP variant configs are being walked.

Still pending: principled discovery via androidComponents.onVariants
(AGP 7+) or android.libraryVariants — current name-pattern matching
catches Android variant configs by suffix and gets the job done, but
isn't AGP-aware in the strict sense.

Author: jfblaa

.gitignore

@@ -26,6 +26,7 @@ test/fixtures/commands/manifest/gradle-facts/**/.gradle/
 test/fixtures/commands/manifest/gradle-facts/**/build/
 test/fixtures/commands/manifest/gradle-facts/**/.socket.facts.json
 test/fixtures/commands/manifest/gradle-facts/**/pom.xml
+test/fixtures/commands/manifest/gradle-facts/**/local.properties
 
 /.claude/*
 !/.claude/agents/

src/commands/manifest/socket-facts-init-gradle.e2e.test.mts

@@ -181,6 +181,37 @@ describeOrSkip('socket-facts.init.gradle', () => {
     })
   })
 
+  describe('android-library fixture', () => {
+    const fixture = path.join(fixturesRoot, 'android-library')
+    const output = path.join(fixture, '.socket.facts.json')
+
+    const androidSdk =
+      process.env['ANDROID_HOME'] || process.env['ANDROID_SDK_ROOT']
+    const androidDescribeOrSkip = androidSdk ? describe : describe.skip
+
+    androidDescribeOrSkip('with ANDROID_HOME set', () => {
+      it('resolves Android variant classpaths (debug + release)', async () => {
+        clean(output)
+        await runFacts(fixture)
+        expect(existsSync(output)).toBe(true)
+        const facts = readFacts(output)
+        // The androidx.annotation dep is declared as `implementation` and
+        // should appear via debug/release runtime classpaths. Its
+        // qualifiers.ext should be 'jar' or 'aar' (annotation 1.7.1 ships
+        // both — Android uses the aar via variant resolution).
+        const annotation = findById(
+          facts,
+          c => c.namespace === 'androidx.annotation' && c.name === 'annotation',
+        )
+        expect(
+          annotation.length,
+          `androidx.annotation:annotation present (got ${facts.components.length} components total)`,
+        ).toBeGreaterThan(0)
+        expect(annotation.some(c => c.direct === true)).toBe(true)
+      })
+    })
+  })
+
   describe('multi-module-java fixture', () => {
     const fixture = path.join(fixturesRoot, 'multi-module-java')
     const rootOut = path.join(fixture, '.socket.facts.json')

src/commands/manifest/socket-facts.init.gradle

@@ -128,18 +128,26 @@ allprojects { project ->
       // `testCompileClasspath`, `testRuntimeClasspath`), Kotlin Gradle Plugin
       // (`jvmMainCompileClasspath`, `linuxX64MainRuntimeClasspath`, ...) and
       // AGP per-variant (`debugCompileClasspath`, `releaseRuntimeClasspath`,
-      // `debugUnitTestRuntimeClasspath`, ...). A future revision should
-      // switch to Gradle data-model discovery (source sets, KMP compilations,
-      // AGP variants), but until we have fixtures covering each of those, a
-      // name-based whitelist gives us broad coverage with one code path.
+      // `debugUnitTestRuntimeClasspath`, ...).
+      //
+      // We exclude AGP's instrumented-test classpaths (`*AndroidTest*`)
+      // because their variant resolution requires consumer attributes
+      // (target SDK, device/host runtime) that an init-script-driven
+      // resolution doesn't set, and they produce ambiguity errors at
+      // resolution time. Unit-test classpaths (`*UnitTest*`) resolve fine.
+      // A future revision should switch to Gradle data-model discovery
+      // (source sets, KMP compilations, AGP variants).
       def isClasspath = { String name ->
         def lower = name.toLowerCase()
         lower.endsWith('compileclasspath') || lower.endsWith('runtimeclasspath')
       }
+      def isAndroidInstrumentedTest = { String name ->
+        name.toLowerCase().contains('androidtest')
+      }
       def isTestClasspath = { String name -> name.toLowerCase().contains('test') }
 
       def targetConfigs = project.configurations.findAll {
-        it.canBeResolved && isClasspath(it.name)
+        it.canBeResolved && isClasspath(it.name) && !isAndroidInstrumentedTest(it.name)
       }
 
       // The project being scanned is the SBOM target itself, not one of its
@@ -149,20 +157,29 @@ allprojects { project ->
       // first-level edges so consumers don't need a synthetic root node.
       targetConfigs.each { cfg ->
         def isProd = !isTestClasspath(cfg.name)
-        def lenient = cfg.resolvedConfiguration.lenientConfiguration
-        def cache = [:]
-        lenient.firstLevelModuleDependencies.each { dep ->
-          directIds.addAll(visit(dep, isProd, cache))
-        }
-        lenient.unresolvedModuleDependencies.each { dep ->
-          def coord = [
-            groupId   : dep.selector.group ?: '',
-            artifactId: dep.selector.name,
-            version   : dep.selector.version ?: '',
-            classifier: '',
-            ext       : '',
-          ]
-          directIds.add(upsertNode(coord, isProd))
+        // Per-configuration try/catch: AGP-style configurations can fail with
+        // "variant ambiguity" when resolved from an init-script context that
+        // doesn't carry the consumer attributes AGP sets internally. We log
+        // and continue so a single ambiguous config doesn't sink the whole
+        // facts file — the other classpaths still produce useful output.
+        try {
+          def lenient = cfg.resolvedConfiguration.lenientConfiguration
+          def cache = [:]
+          lenient.firstLevelModuleDependencies.each { dep ->
+            directIds.addAll(visit(dep, isProd, cache))
+          }
+          lenient.unresolvedModuleDependencies.each { dep ->
+            def coord = [
+              groupId   : dep.selector.group ?: '',
+              artifactId: dep.selector.name,
+              version   : dep.selector.version ?: '',
+              classifier: '',
+              ext       : '',
+            ]
+            directIds.add(upsertNode(coord, isProd))
+          }
+        } catch (Exception e) {
+          println "[socket-facts] skipping ${cfg.name}: ${e.message?.readLines()?.first()}"
         }
       }
 

test/fixtures/commands/manifest/gradle-facts/android-library/build.gradle

@@ -0,0 +1,32 @@
+// Minimal AGP fixture for socket-facts.init.gradle. Exercises Android's
+// per-variant compile/runtime classpath configurations (debugCompileClasspath,
+// releaseRuntimeClasspath, debugUnitTestRuntimeClasspath, ...) that the Java
+// SourceSetContainer doesn't surface.
+//
+// Requires:
+//   - JDK 17+
+//   - Gradle 8.7+ (matched to the AGP version below)
+//   - An Android SDK reachable via ANDROID_HOME / ANDROID_SDK_ROOT or
+//     local.properties (gitignored).
+plugins {
+    id 'com.android.library' version '8.7.3'
+}
+
+android {
+    namespace 'com.example.socket.androidlib'
+    compileSdk 34
+
+    defaultConfig {
+        minSdk 24
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+}
+
+dependencies {
+    implementation 'androidx.annotation:annotation:1.7.1'
+    testImplementation 'junit:junit:4.13.2'
+}

test/fixtures/commands/manifest/gradle-facts/android-library/gradle.properties

@@ -0,0 +1 @@
+android.useAndroidX=true

test/fixtures/commands/manifest/gradle-facts/android-library/settings.gradle

@@ -0,0 +1,16 @@
+pluginManagement {
+    repositories {
+        google()
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = 'android-library'