@dailephd/my-dev-kit-lab 0.3.3 → 0.4.0

package/dist/src/mobile/android/detect/classify.js

@@ -0,0 +1,150 @@
+// ---------------------------------------------------------------------------
+// v0.4.0 Batch 2 — deterministic, evidence-based classification policy.
+//
+// Pure functions only (no filesystem access) so the confidence/classification
+// policy can be unit tested independently of traversal. See agents.txt Batch
+// 2 section 7.4 for the evidence-strength tiers this implements:
+//   - Strong: an Android plugin id, or namespace/applicationId combined with
+//     an Android plugin, or a manifest inside an Android-style source set.
+//   - Supporting: source roots, res/, androidTest, wrapper, settings files,
+//     catalog aliases, Compose dependencies.
+//   - Weak: generic Gradle/Kotlin/Java files or directory names alone.
+// A project must never be confirmed Android from weak evidence alone.
+// ---------------------------------------------------------------------------
+const CONFIDENCE_RANK = { unknown: 0, low: 1, medium: 2, high: 3 };
+export function maxConfidence(a, b) {
+    return CONFIDENCE_RANK[a] >= CONFIDENCE_RANK[b] ? a : b;
+}
+function capConfidence(confidence, cap) {
+    return CONFIDENCE_RANK[confidence] <= CONFIDENCE_RANK[cap] ? confidence : cap;
+}
+// Classifies a single Gradle module from its collected static evidence.
+// Directory naming (e.g. a module literally called "app") is never used as a
+// signal — only plugin declarations, manifest presence, and Android-specific
+// identifiers.
+export function classifyModule(input) {
+    const evidence = [];
+    if (input.hasAndroidApplicationPlugin) {
+        evidence.push("com.android.application plugin declared");
+        const strongCombo = input.hasManifest || Boolean(input.namespace) || Boolean(input.applicationId);
+        if (input.hasManifest)
+            evidence.push("AndroidManifest.xml present in module source set");
+        if (input.namespace)
+            evidence.push(`namespace = "${input.namespace}"`);
+        if (input.applicationId)
+            evidence.push(`applicationId = "${input.applicationId}"`);
+        return { kind: "application", confidence: strongCombo ? "high" : "medium", evidence };
+    }
+    if (input.hasAndroidLibraryPlugin) {
+        evidence.push("com.android.library plugin declared");
+        const strongCombo = input.hasManifest || Boolean(input.namespace);
+        if (input.hasManifest)
+            evidence.push("AndroidManifest.xml present in module source set");
+        if (input.namespace)
+            evidence.push(`namespace = "${input.namespace}"`);
+        return { kind: "library", confidence: strongCombo ? "high" : "medium", evidence };
+    }
+    if (input.hasCatalogAndroidPluginAliasEvidence) {
+        evidence.push("version-catalog plugin alias referencing an Android Gradle Plugin entry");
+        return { kind: "unknown", confidence: "medium", evidence };
+    }
+    // Generic Java/Kotlin source roots are deliberately excluded from this
+    // list: they exist in any JVM project and are not Android-specific, so
+    // they must never by themselves push a module toward Android detection
+    // (agents.txt Batch 2 section 12.4 — generic Gradle/Kotlin/Java evidence
+    // must not trigger Android detection without Android-specific evidence).
+    const weakSignals = [];
+    if (input.hasManifest)
+        weakSignals.push("AndroidManifest.xml present without a resolved Android plugin");
+    if (input.namespace)
+        weakSignals.push(`namespace = "${input.namespace}" without a resolved Android plugin`);
+    if (input.applicationId)
+        weakSignals.push(`applicationId = "${input.applicationId}" without a resolved Android plugin`);
+    if (input.hasResDir)
+        weakSignals.push("res/ directory present");
+    if (weakSignals.length > 0) {
+        evidence.push(...weakSignals);
+        return { kind: "unknown", confidence: "low", evidence };
+    }
+    if (input.hasGenericBuildFile) {
+        evidence.push("Gradle build file present with no Android-specific evidence");
+        return { kind: "non-android", confidence: "medium", evidence };
+    }
+    return { kind: "unknown", confidence: "unknown", evidence: [] };
+}
+// Classifies UI toolkit usage for a single module. Conservative by design:
+// Kotlin usage alone never implies Compose, and res/ alone never implies
+// XML/View classification beyond what's asserted here (a literal layout
+// resource file, not merely a res/ directory).
+export function classifyModuleUiToolkit(input) {
+    const evidence = [];
+    const strongCompose = input.composeBuildFeatureEvidence || input.composeDependencyEvidence || input.composeSourceEvidence;
+    const strongView = input.hasResLayout;
+    if (input.composeBuildFeatureEvidence)
+        evidence.push("buildFeatures { compose = true }");
+    if (input.composeDependencyEvidence)
+        evidence.push("Compose dependency evidence in build file");
+    if (input.composeSourceEvidence)
+        evidence.push("@Composable/androidx.compose import evidence in source");
+    if (input.composePluginEvidence)
+        evidence.push("Compose compiler plugin evidence");
+    if (input.hasResLayout)
+        evidence.push("res/layout XML resource present");
+    if (input.viewSourceEvidence)
+        evidence.push("traditional Android View usage evidence in source");
+    if (strongCompose && strongView) {
+        return { uiToolkit: "mixed", evidence };
+    }
+    if (strongCompose) {
+        return { uiToolkit: "compose", evidence };
+    }
+    if (strongView) {
+        return { uiToolkit: "xml-view", evidence };
+    }
+    return { uiToolkit: "uncertain", evidence };
+}
+// Combines per-module kinds into the overall project-level classification.
+// Uses the widened ANDROID_PROJECT_KINDS vocabulary (see detection.ts) — a
+// project with both application and library modules is "mixed"; more than
+// one Android module of the same kind is "multi-module"; a single confirmed
+// module keeps its own kind; Android-ish-but-unresolved evidence with no
+// confirmed module is "partial"; nothing at all is "non-android".
+export function combineProjectKind(modules, hasUnresolvedAndroidEvidence) {
+    const applicationCount = modules.filter((module) => module.kind === "application").length;
+    const libraryCount = modules.filter((module) => module.kind === "library").length;
+    const unknownCount = modules.filter((module) => module.kind === "unknown").length;
+    if (applicationCount >= 1 && libraryCount >= 1)
+        return "mixed";
+    if (applicationCount + libraryCount > 1)
+        return "multi-module";
+    if (applicationCount === 1)
+        return "application";
+    if (libraryCount === 1)
+        return "library";
+    if (unknownCount > 0 || hasUnresolvedAndroidEvidence)
+        return "partial";
+    return "non-android";
+}
+export function combineProjectUiToolkit(modules) {
+    const androidModules = modules.filter((module) => module.kind === "application" || module.kind === "library");
+    const composeCount = androidModules.filter((module) => module.uiToolkit === "compose").length;
+    const viewCount = androidModules.filter((module) => module.uiToolkit === "xml-view").length;
+    const mixedCount = androidModules.filter((module) => module.uiToolkit === "mixed").length;
+    if (mixedCount > 0 || (composeCount > 0 && viewCount > 0))
+        return "mixed";
+    if (composeCount > 0)
+        return "compose";
+    if (viewCount > 0)
+        return "xml-view";
+    return "uncertain";
+}
+export function combineProjectConfidence(projectKind, moduleConfidences, hasNonAndroidEvidenceOnly) {
+    if (projectKind === "non-android") {
+        return hasNonAndroidEvidenceOnly ? "high" : "unknown";
+    }
+    const strongest = moduleConfidences.reduce((acc, confidence) => maxConfidence(acc, confidence), "unknown");
+    if (projectKind === "partial") {
+        return capConfidence(strongest, "medium");
+    }
+    return strongest;
+}

package/dist/src/mobile/android/detect/detectAndroidProject.js

@@ -0,0 +1,252 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { extractBuildFileEvidence } from "./buildFileEvidence.js";
+import { parseDeclaredModules } from "./settingsModules.js";
+import { extractVersionCatalogEvidence } from "./versionCatalogEvidence.js";
+import { scanSourceRootsForUiEvidence } from "./sourceEvidence.js";
+import { walkAndroidCandidateFiles } from "./traversal.js";
+import { classifyModule, classifyModuleUiToolkit, combineProjectConfidence, combineProjectKind, combineProjectUiToolkit, } from "./classify.js";
+// ---------------------------------------------------------------------------
+// v0.4.0 Batch 2 — Android project detector entry point.
+//
+// Static, deterministic, read-only, network-free. Does not invoke Gradle, the
+// Android SDK, or a Java toolchain. Populates the Batch 1
+// AndroidDetectionResult contract only — manifest content parsing, full
+// Gradle metadata, and verdict calculation are later batches' scope.
+// ---------------------------------------------------------------------------
+function dirOf(relativeFilePath) {
+    const dir = path.posix.dirname(relativeFilePath.replace(/\\/g, "/"));
+    return dir === "." ? "" : dir;
+}
+function baseNameOf(relativeFilePath) {
+    return path.posix.basename(relativeFilePath.replace(/\\/g, "/"));
+}
+function joinRelative(dir, name) {
+    return dir === "" ? name : `${dir}/${name}`;
+}
+function catalogAliasToAccessorSuffix(alias) {
+    return alias.replace(/-/g, ".");
+}
+function readTextSafe(absolutePath) {
+    try {
+        return readFileSync(absolutePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export function detectAndroidProject(targetRoot) {
+    const resolvedRoot = path.resolve(targetRoot);
+    const { relativeFilePaths, skippedSymlinks } = walkAndroidCandidateFiles(resolvedRoot);
+    const fileSet = new Set(relativeFilePaths);
+    const warnings = [];
+    for (const skipped of skippedSymlinks) {
+        warnings.push(`Skipped directory symlink (not followed): ${skipped}`);
+    }
+    // ---- Root-level evidence -------------------------------------------------
+    const rootBuildFiles = relativeFilePaths
+        .filter((p) => dirOf(p) === "" && (baseNameOf(p) === "build.gradle" || baseNameOf(p) === "build.gradle.kts"))
+        .sort((a, b) => a.localeCompare(b));
+    const gradleSettingsFiles = relativeFilePaths
+        .filter((p) => dirOf(p) === "" && (baseNameOf(p) === "settings.gradle" || baseNameOf(p) === "settings.gradle.kts"))
+        .sort((a, b) => a.localeCompare(b));
+    if (gradleSettingsFiles.length > 1) {
+        warnings.push(`Multiple root settings files found (${gradleSettingsFiles.join(", ")}); using "${gradleSettingsFiles[0]}" as the primary evidence source.`);
+    }
+    const hasGradleWrapper = fileSet.has("gradlew") || fileSet.has("gradlew.bat") || fileSet.has("gradle/wrapper/gradle-wrapper.properties");
+    const versionCatalogFiles = relativeFilePaths.filter((p) => p === "gradle/libs.versions.toml");
+    const catalogEvidence = versionCatalogFiles.length > 0
+        ? extractVersionCatalogEvidence(readTextSafe(path.join(resolvedRoot, versionCatalogFiles[0])) ?? "")
+        : { androidPluginAliasEvidence: [], kotlinAndroidPluginAliasEvidence: [], composeAliasEvidence: [] };
+    // ---- Module discovery ------------------------------------------------------
+    const structuralModuleDirs = new Set();
+    for (const p of relativeFilePaths) {
+        const name = baseNameOf(p);
+        if (name === "build.gradle" || name === "build.gradle.kts") {
+            const dir = dirOf(p);
+            if (dir !== "")
+                structuralModuleDirs.add(dir);
+        }
+    }
+    let declaredModulePaths = [];
+    let unsupportedDeclarations = [];
+    if (gradleSettingsFiles.length > 0) {
+        const settingsText = readTextSafe(path.join(resolvedRoot, gradleSettingsFiles[0])) ?? "";
+        const parsed = parseDeclaredModules(settingsText);
+        declaredModulePaths = parsed.declaredModulePaths;
+        unsupportedDeclarations = parsed.unsupportedDeclarations;
+    }
+    for (const declaration of unsupportedDeclarations) {
+        warnings.push(`Unsupported or dynamic module declaration in settings file (preserved, not evaluated): ${declaration}`);
+    }
+    const declaredOnlyDirs = declaredModulePaths.filter((dir) => !structuralModuleDirs.has(dir));
+    for (const dir of declaredOnlyDirs) {
+        warnings.push(`Module "${dir}" is declared in the settings file but no build.gradle(.kts) was found for it.`);
+    }
+    const allModuleDirs = [...new Set([...structuralModuleDirs, ...declaredModulePaths])].sort((a, b) => a.localeCompare(b));
+    // ---- Per-module evidence and classification --------------------------------
+    const modules = [];
+    const javaSourceRoots = [];
+    const kotlinSourceRoots = [];
+    const unitTestSourceRoots = [];
+    const instrumentedTestSourceRoots = [];
+    const manifestPaths = [];
+    let androidGradlePluginEvidence;
+    let kotlinAndroidPluginEvidence;
+    let namespaceEvidence;
+    let applicationIdEvidence;
+    for (const moduleDir of allModuleDirs) {
+        const buildFileRelPath = [`${moduleDir}/build.gradle.kts`, `${moduleDir}/build.gradle`].find((p) => fileSet.has(p));
+        const buildFileText = buildFileRelPath ? readTextSafe(path.join(resolvedRoot, buildFileRelPath)) ?? "" : undefined;
+        const buildEvidence = buildFileText !== undefined ? extractBuildFileEvidence(buildFileText) : undefined;
+        const hasCatalogAliasEvidence = buildFileText !== undefined &&
+            [...catalogEvidence.androidPluginAliasEvidence, ...catalogEvidence.kotlinAndroidPluginAliasEvidence].some((alias) => buildFileText.includes(`libs.plugins.${catalogAliasToAccessorSuffix(alias)}`));
+        const manifestRelPath = `${moduleDir}/src/main/AndroidManifest.xml`;
+        const hasManifest = fileSet.has(manifestRelPath);
+        const moduleManifestPaths = hasManifest ? [manifestRelPath] : [];
+        const javaRootPrefix = `${moduleDir}/src/main/java/`;
+        const kotlinRootPrefix = `${moduleDir}/src/main/kotlin/`;
+        const unitTestPrefix = `${moduleDir}/src/test/`;
+        const instrumentedTestPrefix = `${moduleDir}/src/androidTest/`;
+        const resLayoutPrefix = `${moduleDir}/src/main/res/layout`;
+        // Language is classified by file extension found under each directory,
+        // not by directory name alone — Kotlin sources are conventionally placed
+        // under src/main/java in some older project layouts, so a "java"-named
+        // directory containing only .kt files is a Kotlin source root, not a
+        // Java one (agents.txt Batch 2 section 7.9).
+        const javaRootHasJavaFiles = relativeFilePaths.some((p) => p.startsWith(javaRootPrefix) && p.endsWith(".java"));
+        const javaRootHasKotlinFiles = relativeFilePaths.some((p) => p.startsWith(javaRootPrefix) && p.endsWith(".kt"));
+        const kotlinRootHasKotlinFiles = relativeFilePaths.some((p) => p.startsWith(kotlinRootPrefix) && p.endsWith(".kt"));
+        const kotlinRootHasJavaFiles = relativeFilePaths.some((p) => p.startsWith(kotlinRootPrefix) && p.endsWith(".java"));
+        const hasJavaRoot = javaRootHasJavaFiles || kotlinRootHasJavaFiles;
+        const hasKotlinRoot = javaRootHasKotlinFiles || kotlinRootHasKotlinFiles;
+        const hasUnitTestRoot = relativeFilePaths.some((p) => p.startsWith(unitTestPrefix));
+        const hasInstrumentedTestRoot = relativeFilePaths.some((p) => p.startsWith(instrumentedTestPrefix));
+        const hasResLayout = relativeFilePaths.some((p) => p.startsWith(resLayoutPrefix) && p.endsWith(".xml"));
+        if (javaRootHasJavaFiles)
+            javaSourceRoots.push(`${moduleDir}/src/main/java`);
+        if (kotlinRootHasJavaFiles)
+            javaSourceRoots.push(`${moduleDir}/src/main/kotlin`);
+        if (kotlinRootHasKotlinFiles)
+            kotlinSourceRoots.push(`${moduleDir}/src/main/kotlin`);
+        if (javaRootHasKotlinFiles)
+            kotlinSourceRoots.push(`${moduleDir}/src/main/java`);
+        if (hasUnitTestRoot)
+            unitTestSourceRoots.push(`${moduleDir}/src/test`);
+        if (hasInstrumentedTestRoot)
+            instrumentedTestSourceRoots.push(`${moduleDir}/src/androidTest`);
+        manifestPaths.push(...moduleManifestPaths);
+        const sourceUiEvidence = scanSourceRootsForUiEvidence([javaRootHasJavaFiles || javaRootHasKotlinFiles ? path.join(resolvedRoot, moduleDir, "src", "main", "java") : undefined,
+            kotlinRootHasKotlinFiles || kotlinRootHasJavaFiles ? path.join(resolvedRoot, moduleDir, "src", "main", "kotlin") : undefined]
+            .filter((p) => Boolean(p)));
+        const classification = classifyModule({
+            hasAndroidApplicationPlugin: buildEvidence?.androidApplicationPlugin ?? false,
+            hasAndroidLibraryPlugin: buildEvidence?.androidLibraryPlugin ?? false,
+            hasCatalogAndroidPluginAliasEvidence: hasCatalogAliasEvidence,
+            namespace: buildEvidence?.namespace,
+            applicationId: buildEvidence?.applicationId,
+            hasManifest,
+            hasSrcRoots: hasJavaRoot || hasKotlinRoot,
+            hasResDir: relativeFilePaths.some((p) => p.startsWith(`${moduleDir}/src/main/res/`)),
+            hasGenericBuildFile: buildFileText !== undefined,
+        });
+        const uiClassification = classifyModuleUiToolkit({
+            composeBuildFeatureEvidence: buildEvidence?.composeBuildFeatureEvidence ?? false,
+            composeDependencyEvidence: buildEvidence?.composeDependencyEvidence ?? false,
+            composePluginEvidence: buildEvidence?.composePluginEvidence ?? false,
+            composeSourceEvidence: sourceUiEvidence.composeSourceEvidence,
+            hasResLayout,
+            viewSourceEvidence: sourceUiEvidence.viewSourceEvidence,
+        });
+        if (buildEvidence?.androidApplicationPlugin && !androidGradlePluginEvidence) {
+            androidGradlePluginEvidence = `com.android.application (${buildFileRelPath})`;
+        }
+        if (buildEvidence?.androidLibraryPlugin && !androidGradlePluginEvidence) {
+            androidGradlePluginEvidence = `com.android.library (${buildFileRelPath})`;
+        }
+        if (buildEvidence?.kotlinAndroidPlugin && !kotlinAndroidPluginEvidence) {
+            kotlinAndroidPluginEvidence = `org.jetbrains.kotlin.android (${buildFileRelPath})`;
+        }
+        if (buildEvidence?.namespace && !namespaceEvidence) {
+            namespaceEvidence = buildEvidence.namespace;
+        }
+        if (buildEvidence?.applicationId && !applicationIdEvidence) {
+            applicationIdEvidence = buildEvidence.applicationId;
+        }
+        modules.push({
+            path: moduleDir,
+            kind: classification.kind,
+            manifestPaths: moduleManifestPaths,
+            namespaceEvidence: buildEvidence?.namespace,
+            applicationIdEvidence: buildEvidence?.applicationId,
+            confidence: classification.confidence,
+            evidence: classification.evidence,
+            uiToolkit: uiClassification.uiToolkit,
+        });
+    }
+    // ---- Project-level aggregation ---------------------------------------------
+    const applicationModules = modules.filter((m) => m.kind === "application").map((m) => m.path).sort((a, b) => a.localeCompare(b));
+    const libraryModules = modules.filter((m) => m.kind === "library").map((m) => m.path).sort((a, b) => a.localeCompare(b));
+    const hasUnresolvedAndroidEvidence = declaredOnlyDirs.length > 0 || (rootBuildFiles.length > 0 && modules.some((m) => m.kind === "unknown"));
+    let projectKind = combineProjectKind(modules.map((m) => ({ kind: m.kind, uiToolkit: m.uiToolkit ?? "uncertain" })), hasUnresolvedAndroidEvidence);
+    // A single confirmed application/library module whose manifest is entirely
+    // missing is Android-specific evidence with an incomplete structure, not a
+    // confidently confirmed Android project — downgrade to "partial" rather
+    // than reporting a false-confident "application"/"library" classification
+    // (agents.txt Batch 2 section 12.3). Multi-module/mixed projects where only
+    // some modules lack a manifest keep their combined kind; the missing
+    // manifest is still surfaced via partialOrUnsupportedStructure below.
+    const androidModules = modules.filter((m) => m.kind === "application" || m.kind === "library");
+    const allAndroidModulesMissingManifest = androidModules.length > 0 && androidModules.every((m) => m.manifestPaths.length === 0);
+    if (allAndroidModulesMissingManifest && (projectKind === "application" || projectKind === "library")) {
+        projectKind = "partial";
+    }
+    const uiToolkit = combineProjectUiToolkit(modules.map((m) => ({ kind: m.kind, uiToolkit: m.uiToolkit ?? "uncertain" })));
+    const hasNonAndroidEvidenceOnly = rootBuildFiles.length > 0 || modules.some((m) => m.kind === "non-android");
+    const confidence = combineProjectConfidence(projectKind, modules.filter((m) => m.kind === "application" || m.kind === "library" || m.kind === "unknown").map((m) => m.confidence ?? "unknown"), hasNonAndroidEvidenceOnly);
+    const androidModulesMissingManifest = modules.filter((m) => (m.kind === "application" || m.kind === "library") && m.manifestPaths.length === 0);
+    for (const module of androidModulesMissingManifest) {
+        warnings.push(`No AndroidManifest.xml found for Android module "${module.path}".`);
+    }
+    const partialOrUnsupportedStructure = projectKind === "partial" || androidModulesMissingManifest.length > 0 || unsupportedDeclarations.length > 0 || declaredOnlyDirs.length > 0;
+    const evidence = [];
+    if (applicationModules.length > 0)
+        evidence.push(`${applicationModules.length} application module(s) found: ${applicationModules.join(", ")}`);
+    if (libraryModules.length > 0)
+        evidence.push(`${libraryModules.length} library module(s) found: ${libraryModules.join(", ")}`);
+    if (hasGradleWrapper)
+        evidence.push("Gradle wrapper present");
+    if (gradleSettingsFiles.length > 0)
+        evidence.push(`Gradle settings file(s): ${gradleSettingsFiles.join(", ")}`);
+    if (catalogEvidence.androidPluginAliasEvidence.length > 0) {
+        evidence.push(`Version-catalog Android plugin alias(es): ${catalogEvidence.androidPluginAliasEvidence.join(", ")}`);
+    }
+    if (catalogEvidence.composeAliasEvidence.length > 0) {
+        evidence.push(`Version-catalog Compose alias(es): ${catalogEvidence.composeAliasEvidence.join(", ")}`);
+    }
+    return {
+        detected: projectKind !== "non-android",
+        confidence,
+        evidence,
+        projectKind,
+        uiToolkit,
+        hasGradleWrapper,
+        gradleSettingsFiles,
+        rootBuildFiles,
+        versionCatalogFiles,
+        modules,
+        applicationModules,
+        libraryModules,
+        manifestPaths: [...new Set(manifestPaths)].sort((a, b) => a.localeCompare(b)),
+        javaSourceRoots: [...new Set(javaSourceRoots)].sort((a, b) => a.localeCompare(b)),
+        kotlinSourceRoots: [...new Set(kotlinSourceRoots)].sort((a, b) => a.localeCompare(b)),
+        unitTestSourceRoots: [...new Set(unitTestSourceRoots)].sort((a, b) => a.localeCompare(b)),
+        instrumentedTestSourceRoots: [...new Set(instrumentedTestSourceRoots)].sort((a, b) => a.localeCompare(b)),
+        androidGradlePluginEvidence,
+        kotlinAndroidPluginEvidence,
+        namespaceEvidence,
+        applicationIdEvidence,
+        partialOrUnsupportedStructure,
+        warnings,
+    };
+}

package/dist/src/mobile/android/detect/settingsModules.js

@@ -0,0 +1,60 @@
+// ---------------------------------------------------------------------------
+// v0.4.0 Batch 2 — bounded, deterministic settings.gradle(.kts) module parser.
+//
+// Extracts module declarations from common static `include(...)` syntax
+// (Groovy and Kotlin DSL) using lexical regex scanning. This intentionally
+// does not evaluate Gradle: no variables, functions, conditionals, loops, or
+// included builds are resolved. Anything that cannot be statically resolved
+// is reported as an unsupported declaration rather than guessed.
+// ---------------------------------------------------------------------------
+// Matches `include` (Groovy bare-args or Kotlin-DSL call) but not
+// `includeBuild` (composite builds are out of scope for this batch).
+const INCLUDE_CALL_PATTERN = /\binclude\b(?!Build)\s*(\(([\s\S]*?)\)|([^\n;]*))/g;
+const QUOTED_STRING_PATTERN = /['"]([^'"]*)['"]/g;
+const DYNAMIC_EXPRESSION_PATTERN = /\$\{|\$\w|\bfor\s*\(|\bif\s*\(|\bwhile\s*\(|[+]{1}\s*['"$]/;
+function gradlePathToRelativeDir(gradlePath) {
+    if (!gradlePath.startsWith(":")) {
+        return null;
+    }
+    const segments = gradlePath.split(":").filter((segment) => segment.length > 0);
+    if (segments.length === 0) {
+        return null;
+    }
+    return segments.join("/");
+}
+// Parses declared module paths out of a settings.gradle or settings.gradle.kts
+// file's raw text. Supports common Groovy and Kotlin DSL `include(...)` forms
+// (single or multiple arguments, single-line or simple multiline calls).
+// Dynamic/unresolvable declarations are preserved verbatim (trimmed, bounded)
+// in `unsupportedDeclarations` rather than silently dropped.
+export function parseDeclaredModules(settingsText) {
+    const declaredModulePaths = new Set();
+    const unsupportedDeclarations = [];
+    for (const match of settingsText.matchAll(INCLUDE_CALL_PATTERN)) {
+        const body = match[2] ?? match[3] ?? "";
+        let addedAny = false;
+        let dynamicFound = DYNAMIC_EXPRESSION_PATTERN.test(body);
+        for (const quoted of body.matchAll(QUOTED_STRING_PATTERN)) {
+            const literal = quoted[1];
+            // A quoted literal containing an unresolved `$` interpolation is not a
+            // static module path, even though it matched the quoted-string regex —
+            // it must be reported as unsupported, not silently accepted.
+            if (literal.includes("$")) {
+                dynamicFound = true;
+                continue;
+            }
+            const relativeDir = gradlePathToRelativeDir(literal);
+            if (relativeDir) {
+                declaredModulePaths.add(relativeDir);
+                addedAny = true;
+            }
+        }
+        if (dynamicFound || (!addedAny && body.trim().length > 0)) {
+            unsupportedDeclarations.push(body.trim().slice(0, 200));
+        }
+    }
+    return {
+        declaredModulePaths: [...declaredModulePaths].sort((a, b) => a.localeCompare(b)),
+        unsupportedDeclarations,
+    };
+}

package/dist/src/mobile/android/detect/sourceEvidence.js

@@ -0,0 +1,92 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+// ---------------------------------------------------------------------------
+// v0.4.0 Batch 2 — bounded source inspection for Compose/View UI evidence.
+//
+// Scans a small, capped number of source files under given source roots for
+// lexical markers (@Composable, androidx.compose imports, traditional View
+// APIs). This is not semantic parsing — it is a bounded grep-style scan with
+// hard file-count and file-size caps so detection stays fast and safe on
+// large or adversarial repositories.
+// ---------------------------------------------------------------------------
+const MAX_FILES_SCANNED = 40;
+const MAX_FILE_SIZE_BYTES = 200_000;
+const COMPOSE_SOURCE_PATTERN = /@Composable|androidx\.compose/;
+const VIEW_SOURCE_PATTERN = /\bandroid\.view\.View\b|\bandroid\.widget\.|findViewById|\bViewBinding\b/;
+function collectSourceFiles(root, extensions, budget) {
+    const files = [];
+    const visit = (dir) => {
+        if (budget.remaining <= 0)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (budget.remaining <= 0)
+                return;
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                visit(fullPath);
+                continue;
+            }
+            if (entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext))) {
+                files.push(fullPath);
+                budget.remaining -= 1;
+            }
+        }
+    };
+    visit(root);
+    return files;
+}
+// Scans up to MAX_FILES_SCANNED Kotlin/Java files across the given source
+// roots (already resolved absolute directories) for bounded Compose/View
+// lexical evidence. Missing directories are ignored, not treated as errors.
+export function scanSourceRootsForUiEvidence(sourceRootAbsolutePaths) {
+    const budget = { remaining: MAX_FILES_SCANNED };
+    const files = [];
+    for (const root of sourceRootAbsolutePaths) {
+        if (budget.remaining <= 0)
+            break;
+        try {
+            if (!statSync(root).isDirectory())
+                continue;
+        }
+        catch {
+            continue;
+        }
+        files.push(...collectSourceFiles(root, [".kt", ".java"], budget));
+    }
+    let composeSourceEvidence = false;
+    let viewSourceEvidence = false;
+    let filesScanned = 0;
+    for (const file of files) {
+        let stat;
+        try {
+            stat = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        if (stat.size > MAX_FILE_SIZE_BYTES)
+            continue;
+        let content;
+        try {
+            content = readFileSync(file, "utf8");
+        }
+        catch {
+            continue;
+        }
+        filesScanned += 1;
+        if (!composeSourceEvidence && COMPOSE_SOURCE_PATTERN.test(content)) {
+            composeSourceEvidence = true;
+        }
+        if (!viewSourceEvidence && VIEW_SOURCE_PATTERN.test(content)) {
+            viewSourceEvidence = true;
+        }
+    }
+    return { composeSourceEvidence, viewSourceEvidence, filesScanned };
+}

package/dist/src/mobile/android/detect/traversal.js

@@ -0,0 +1,79 @@
+import { lstatSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { relativeWithinRoot } from "../../../core/pathSafety.js";
+// ---------------------------------------------------------------------------
+// v0.4.0 Batch 2 — bounded, deterministic filesystem traversal for Android
+// detection.
+//
+// A dedicated walker (rather than reusing src/core/fileGlobs.ts) because
+// Android detection needs a wider and different exclusion set (.gradle, out,
+// reports, lab-output, .my-dev-kit, IDE caches) than the generic glob helper
+// currently declares, and widening that shared helper's exclusion list would
+// change behavior for every other consumer of collectFilesForGlobs. Reuses
+// src/core/pathSafety.ts's relativeWithinRoot for containment/normalization
+// so target-root escape guarantees stay centralized.
+// ---------------------------------------------------------------------------
+const EXCLUDED_DIR_NAMES = new Set([
+    ".git",
+    ".gradle",
+    "build",
+    "out",
+    "dist",
+    "node_modules",
+    "coverage",
+    "reports",
+    "lab-output",
+    ".my-dev-kit",
+    ".idea",
+    ".vscode",
+    ".vs",
+]);
+// Walks `root`, returning sorted POSIX-style relative file paths. Directory
+// symlinks are never followed (recorded in `skippedSymlinks` instead), and
+// traversal never leaves `root` (relativeWithinRoot throws on escape, which
+// cannot happen here since paths are built from readdir entries under root).
+export function walkAndroidCandidateFiles(root) {
+    const resolvedRoot = path.resolve(root);
+    const relativeFilePaths = [];
+    const skippedSymlinks = [];
+    const visit = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isSymbolicLink()) {
+                let stat;
+                try {
+                    stat = lstatSync(fullPath);
+                }
+                catch {
+                    continue;
+                }
+                if (stat.isSymbolicLink()) {
+                    skippedSymlinks.push(relativeWithinRoot(resolvedRoot, fullPath));
+                    continue;
+                }
+            }
+            if (entry.isDirectory()) {
+                if (EXCLUDED_DIR_NAMES.has(entry.name)) {
+                    continue;
+                }
+                visit(fullPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                relativeFilePaths.push(relativeWithinRoot(resolvedRoot, fullPath));
+            }
+        }
+    };
+    visit(resolvedRoot);
+    return {
+        relativeFilePaths: relativeFilePaths.sort((a, b) => a.localeCompare(b)),
+        skippedSymlinks: skippedSymlinks.sort((a, b) => a.localeCompare(b)),
+    };
+}