deepdebug-local-agent 1.0.19 → 1.0.21

package/Dockerfile

@@ -2,7 +2,7 @@
 # ║          DeepDebug Local Agent - Enterprise Docker           ║
 # ║                                                              ║
 # ║  Security-hardened container for enterprise deployments      ║
-# ║  Supports: Kubernetes, OpenShift, Docker Compose             ║
+# ║  Supports: Cloud Run with NFS (GCP Filestore)                ║
 # ╚══════════════════════════════════════════════════════════════╝
 
 # ===========================================
@@ -12,14 +12,9 @@ FROM node:20-alpine AS builder
 
 WORKDIR /build
 
-# Copy package files first (better cache)
 COPY package*.json ./
-
-# Install dependencies (production only)
-# Using npm install instead of npm ci for repos without package-lock.json
 RUN npm install --omit=dev && npm cache clean --force
 
-# Copy source code
 COPY src/ ./src/
 
 # ===========================================
@@ -27,48 +22,71 @@ COPY src/ ./src/
 # ===========================================
 FROM node:20-alpine AS production
 
-# Security: Add labels for compliance
 LABEL org.opencontainers.image.title="DeepDebug Local Agent"
 LABEL org.opencontainers.image.description="Enterprise debugging agent for code analysis"
 LABEL org.opencontainers.image.vendor="InspTech AI"
-LABEL org.opencontainers.image.version="1.0.0"
+LABEL org.opencontainers.image.version="1.2.0"
 LABEL org.opencontainers.image.licenses="Proprietary"
 LABEL security.scan.required="true"
 
-# Security: Create non-root user
+# Create non-root user
 RUN addgroup -g 1001 -S deepdebug && \
     adduser -u 1001 -S deepdebug -G deepdebug
 
-# Security: Install security updates
+# Install dependencies including Java 17 for Maven wrapper support
 RUN apk update && \
     apk upgrade --no-cache && \
     apk add --no-cache \
         dumb-init \
         git \
         curl \
+        nfs-utils \
+        openjdk17-jdk \
+        maven \
+        python3 \
     && rm -rf /var/cache/apk/*
 
+# Set JAVA_HOME so ./mvnw can find Java
+# Alpine stores JVM under java-17-openjdk with arch suffix - use readlink to resolve
+RUN ln -sf $(dirname $(dirname $(readlink -f $(which java)))) /usr/local/java-home
+ENV JAVA_HOME=/usr/local/java-home
+ENV PATH="$JAVA_HOME/bin:$PATH"
+
+# Create NFS mount point with correct ownership
+RUN mkdir -p /mnt/workspaces && \
+    chown deepdebug:deepdebug /mnt/workspaces
+
+# Install cloudflared for tunnel support (Vibe preview)
+RUN wget -q https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64 \
+    -O /usr/local/bin/cloudflared && \
+    chmod +x /usr/local/bin/cloudflared && \
+    cloudflared --version
+
+# Install GitHub CLI (gh) for PR creation
+RUN wget -q https://github.com/cli/cli/releases/download/v2.63.2/gh_2.63.2_linux_amd64.tar.gz \
+    -O /tmp/gh.tar.gz && \
+    tar -xzf /tmp/gh.tar.gz -C /tmp && \
+    mv /tmp/gh_2.63.2_linux_amd64/bin/gh /usr/local/bin/gh && \
+    chmod +x /usr/local/bin/gh && \
+    rm -rf /tmp/gh* && \
+    gh --version
+
 WORKDIR /app
 
-# Copy from builder with correct ownership
 COPY --from=builder --chown=deepdebug:deepdebug /build/node_modules ./node_modules
 COPY --from=builder --chown=deepdebug:deepdebug /build/src ./src
 COPY --chown=deepdebug:deepdebug package*.json ./
 
-# Security: Switch to non-root user
 USER deepdebug
 
-# Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
     CMD curl -f http://localhost:5055/health || exit 1
 
-# Environment
 ENV NODE_ENV=production
 ENV PORT=5055
+ENV WORKSPACES_MOUNT=/mnt/workspaces
 
-# Expose port
 EXPOSE 5055
 
-# Security: Use dumb-init to handle signals properly
 ENTRYPOINT ["dumb-init", "--"]
 CMD ["node", "src/server.js"]

package/Dockerfile.full

@@ -0,0 +1,63 @@
+# ================================================================
+# DeepDebug Local Agent - Full Stack (with build tools)
+# ================================================================
+# This image includes Java 17, Maven, Node.js, Python, and Git
+# for compilation and testing in Cloud Engineer provisioned
+# environments. Used when the client has OAuth connected and
+# we provision a compilation container in their cloud.
+# ================================================================
+
+# Stage 1: Build Node.js agent
+FROM node:20-slim AS builder
+
+WORKDIR /build
+COPY package*.json ./
+RUN npm install --omit=dev && npm cache clean --force
+COPY src/ ./src/
+
+# Stage 2: Full runtime with build tools
+FROM node:20-slim
+
+# Install Java 17 + Maven for Spring Boot projects
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+        openjdk-17-jdk-headless \
+        maven \
+        git \
+        curl \
+        openssh-client \
+        python3 \
+        python3-pip \
+        && rm -rf /var/lib/apt/lists/*
+
+ENV JAVA_HOME=/usr/lib/jvm/java-17-openjdk-amd64
+ENV PATH=$PATH:$JAVA_HOME/bin:/usr/share/maven/bin
+
+# Verify all tools are installed
+RUN java -version && mvn -version && node -v && git --version
+
+# Git safe directory for NFS mounted workspaces
+RUN git config --global --add safe.directory '*'
+
+# Create non-root user
+RUN groupadd -r deepdebug && useradd -r -g deepdebug -m deepdebug
+
+WORKDIR /app
+
+# Copy built Node.js agent
+COPY --from=builder /build/node_modules ./node_modules
+COPY --from=builder /build/src ./src
+COPY --from=builder /build/package*.json ./
+
+# Maven dependencies cache directory
+RUN mkdir -p /home/deepdebug/.m2 && chown -R deepdebug:deepdebug /home/deepdebug
+
+# Workspace mount point
+RUN mkdir -p /mnt/workspaces && chown -R deepdebug:deepdebug /mnt/workspaces
+
+EXPOSE 8080
+
+ENV NODE_ENV=production
+ENV PORT=8080
+
+CMD ["node", "src/server.js"]

package/cloudbuild-agent-qa.yaml

@@ -0,0 +1,43 @@
+steps:
+  # Step 1: Build Docker image
+  - name: 'gcr.io/cloud-builders/docker'
+    args:
+      - 'build'
+      - '--platform=linux/amd64'
+      - '-t'
+      - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+      - '.'
+    timeout: '600s'
+
+  # Step 2: Push to Artifact Registry
+  - name: 'gcr.io/cloud-builders/docker'
+    args:
+      - 'push'
+      - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+
+  # Step 3: Deploy to Cloud Run QA
+  - name: 'gcr.io/google.com/cloudsdktool/cloud-sdk'
+    entrypoint: 'gcloud'
+    args:
+      - 'run'
+      - 'deploy'
+      - 'deepdebug-local-agent-qa'
+      - '--image=us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+      - '--region=us-central1'
+      - '--platform=managed'
+      - '--allow-unauthenticated'
+      - '--memory=1Gi'
+      - '--cpu=1'
+      - '--min-instances=1'
+      - '--max-instances=3'
+      - '--port=5055'
+      - '--timeout=300'
+      - '--update-env-vars=NODE_ENV=qa'
+
+images:
+  - 'us-central1-docker.pkg.dev/insptechai/deepdebug-docker/local-agent-qa:latest'
+
+options:
+  logging: CLOUD_LOGGING_ONLY
+
+timeout: '1200s'

package/docker-compose.yml

@@ -52,8 +52,8 @@ services:
     # Volumes
     # ─────────────────────────────────────────
     volumes:
-      # Project source code (read-only for security)
-      - ${PROJECT_PATH:-/path/to/projects}:/workspace:ro
+      # Project source code - writable so agent can apply patches
+      - /Users/macintosh/IdeaProjects:/workspace
       # Temp directory for container writes
       - agent-tmp:/tmp
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.19",
+  "version": "1.0.21",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",
@@ -37,6 +37,7 @@
     "cors": "^2.8.5",
     "express": "^4.19.2",
     "js-yaml": "^4.1.0",
+    "pg": "^8.20.0",
     "pidusage": "^3.0.2",
     "properties-reader": "^2.3.0",
     "strip-ansi": "^7.1.0",
@@ -45,8 +46,8 @@
   },
   "devDependencies": {
     "esbuild": "^0.20.0",
-    "pkg": "^5.8.1",
-    "eslint": "^8.57.0"
+    "eslint": "^8.57.0",
+    "pkg": "^5.8.1"
   },
   "engines": {
     "node": ">=18.0.0"

package/src/detectors/language-detector.js

@@ -17,12 +17,18 @@ export class LanguageDetector {
     findMarkers() {
         const markers = {
             java: this.files.some(f => f.name === 'pom.xml' || f.name === 'build.gradle'),
+            kotlin: this.files.some(f => f.name === 'build.gradle.kts'),
             node: this.files.some(f => f.name === 'package.json'),
             python: this.files.some(f => f.name === 'requirements.txt' || f.name === 'pyproject.toml'),
-            dotnet: this.files.some(f => f.name.endsWith('.csproj') || f.name.endsWith('.sln')),
+            dotnet: this.files.some(f => f.name?.endsWith('.csproj') || f.name?.endsWith('.sln')),
             go: this.files.some(f => f.name === 'go.mod'),
             php: this.files.some(f => f.name === 'composer.json'),
-            ruby: this.files.some(f => f.name === 'Gemfile')
+            ruby: this.files.some(f => f.name === 'Gemfile' || f.name === 'Rakefile'),
+            rust: this.files.some(f => f.name === 'Cargo.toml'),
+            dart: this.files.some(f => f.name === 'pubspec.yaml'),
+            elixir: this.files.some(f => f.name === 'mix.exs'),
+            docker: this.files.some(f => f.name === 'Dockerfile'),
+            static: this.files.some(f => f.name === 'index.html'),
         };
         return markers;
     }
@@ -37,20 +43,24 @@ export class LanguageDetector {
     }
 
     determinePrimaryLanguage(markers, extensions) {
-        // Prioridade: markers > extensões
         const detected = Object.entries(markers)
             .filter(([_, exists]) => exists)
             .map(([lang]) => lang);
 
         if (detected.length === 1) return detected[0];
         if (detected.length > 1) {
-            // Múltiplas linguagens, escolhe por extensões
-            const sortedExts = Object.entries(extensions)
-                .sort((a, b) => b[1] - a[1]);
-            return this.mapExtToLang(sortedExts[0]?.[0]);
+            // Filter out meta-markers (docker, static) if real languages exist
+            const realLangs = detected.filter(l => l !== 'docker' && l !== 'static');
+            if (realLangs.length === 1) return realLangs[0];
+            if (realLangs.length > 1) {
+                const sortedExts = Object.entries(extensions)
+                    .sort((a, b) => b[1] - a[1]);
+                return this.mapExtToLang(sortedExts[0]?.[0]) || realLangs[0];
+            }
+            return detected[0];
         }
 
-        // Fallback: extensão mais comum
+        // Fallback: most common extension
         const sortedExts = Object.entries(extensions)
             .sort((a, b) => b[1] - a[1]);
         return this.mapExtToLang(sortedExts[0]?.[0]) || 'unknown';
@@ -59,6 +69,7 @@ export class LanguageDetector {
     mapExtToLang(ext) {
         const map = {
             '.java': 'java',
+            '.kt': 'kotlin',
             '.js': 'node',
             '.ts': 'node',
             '.jsx': 'node',
@@ -67,7 +78,13 @@ export class LanguageDetector {
             '.cs': 'dotnet',
             '.go': 'go',
             '.php': 'php',
-            '.rb': 'ruby'
+            '.rb': 'ruby',
+            '.rs': 'rust',
+            '.dart': 'dart',
+            '.ex': 'elixir',
+            '.exs': 'elixir',
+            '.swift': 'swift',
+            '.scala': 'scala',
         };
         return map[ext] || null;
     }
@@ -77,13 +94,13 @@ export class LanguageDetector {
         return Object.keys(extensions)
             .map(ext => this.mapExtToLang(ext))
             .filter(lang => lang && lang !== primary)
-            .filter((v, i, a) => a.indexOf(v) === i); // unique
+            .filter((v, i, a) => a.indexOf(v) === i);
     }
 
     calculateConfidence(markers) {
         const markerCount = Object.values(markers).filter(Boolean).length;
         if (markerCount === 0) return 0.3;
         if (markerCount === 1) return 0.9;
-        return 0.7; // Múltiplos markers = projeto polyglot
+        return 0.7;
     }
-}
+}

package/src/detectors.js

@@ -2,27 +2,310 @@ import path from "path";
 import { exists, readFile } from "./fs-utils.js";
 
 export async function detectProject(root) {
+    const fs = (await import("fs")).promises;
+    const pathModule = await import("path");
+    const pathExt = pathModule.default || pathModule;
+
+    // Phase 1: Check well-known marker files
+    // Swift / iOS markers go FIRST so a Package.swift at the root beats a
+    // stray Java pom.xml sitting next to an xcworkspace (VisionHammer slice
+    // 5 hardening).
     const markers = [
+        { file: "Package.swift", lang: "swift", buildTool: "swiftpm" },
+        { file: "Podfile", lang: "swift", buildTool: "cocoapods" },
+        { file: "Podfile.lock", lang: "swift", buildTool: "cocoapods" },
         { file: "pom.xml", lang: "java", buildTool: "maven" },
         { file: "build.gradle", lang: "java", buildTool: "gradle" },
+        { file: "build.gradle.kts", lang: "kotlin", buildTool: "gradle" },
         { file: "package.json", lang: "node", buildTool: "npm" },
         { file: "pyproject.toml", lang: "python", buildTool: "poetry" },
         { file: "requirements.txt", lang: "python", buildTool: "pip" },
-        { file: "go.mod", lang: "go", buildTool: "go" }
+        { file: "go.mod", lang: "go", buildTool: "go" },
+        { file: "Gemfile", lang: "ruby", buildTool: "bundler" },
+        { file: "Rakefile", lang: "ruby", buildTool: "rake" },
+        { file: "pubspec.yaml", lang: "dart", buildTool: "flutter" },
+        { file: "composer.json", lang: "php", buildTool: "composer" },
+        { file: "Cargo.toml", lang: "rust", buildTool: "cargo" },
+        { file: "mix.exs", lang: "elixir", buildTool: "mix" },
     ];
 
     for (const m of markers) {
-        if (await exists(path.join(root, m.file))) {
-            return { language: m.lang, buildTool: m.buildTool, marker: m.file };
+        const fullPath = path.join(root, m.file);
+        if (await exists(fullPath)) {
+            const result = { language: m.lang, buildTool: m.buildTool, marker: m.file };
+
+            // Refine: build.gradle.kts with kotlin plugin -> kotlin
+            if (m.file === "build.gradle" || m.file === "build.gradle.kts") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("org.jetbrains.kotlin") || content.includes("kotlin(")) {
+                        result.language = "kotlin";
+                    }
+                } catch (_) {}
+            }
+
+            // Refine: Gemfile -> detect Rails vs Sinatra
+            if (m.file === "Gemfile") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("rails")) result.framework = "rails";
+                    else if (content.includes("sinatra")) result.framework = "sinatra";
+                } catch (_) {}
+            }
+
+            // Refine: package.json -> detect framework
+            if (m.file === "package.json") {
+                try {
+                    const pkg = JSON.parse(await fs.readFile(fullPath, "utf8"));
+                    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+                    if (deps["next"]) result.framework = "next";
+                    else if (deps["nuxt"]) result.framework = "nuxt";
+                    else if (deps["react"]) result.framework = "react";
+                    else if (deps["vue"]) result.framework = "vue";
+                    else if (deps["express"]) result.framework = "express";
+                    else if (deps["fastify"]) result.framework = "fastify";
+                    else if (deps["@angular/core"]) result.framework = "angular";
+                    else if (deps["svelte"]) result.framework = "svelte";
+                } catch (_) {}
+            }
+
+            // Refine: pom.xml -> detect Spring Boot
+            if (m.file === "pom.xml") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("spring-boot")) result.framework = "spring-boot";
+                    else if (content.includes("quarkus")) result.framework = "quarkus";
+                    else if (content.includes("micronaut")) result.framework = "micronaut";
+                } catch (_) {}
+            }
+
+            // Refine: pubspec.yaml -> detect Flutter
+            if (m.file === "pubspec.yaml") {
+                try {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (content.includes("flutter:")) result.framework = "flutter";
+                } catch (_) {}
+            }
+
+            return result;
         }
     }
 
-    // .NET: procura primeiro nível
-    const dotnet = (await (await import("fs")).promises.readdir(root))
-        .find(f => f.endsWith(".csproj") || f.endsWith(".sln"));
-    if (dotnet) return { language: ".net", buildTool: "dotnet", marker: dotnet };
+    // Phase 2: native mobile — iOS / Android
+    let rootFiles;
+    try {
+        rootFiles = await fs.readdir(root);
+    } catch (_) {
+        return { language: "unknown", buildTool: "unknown", marker: null };
+    }
+
+    const hasRootFile = name => rootFiles.includes(name);
+    const hasRootDirSuffix = suffix => rootFiles.some(f => f.endsWith(suffix));
+
+    if (hasRootFile("Podfile") || hasRootFile("Podfile.lock") || hasRootFile("Package.swift")
+        || hasRootDirSuffix(".xcodeproj") || hasRootDirSuffix(".xcworkspace")) {
+        const framework = await detectAppleFramework(root, fs, pathExt);
+        return {
+            language: "ios",
+            buildTool: "xcodebuild",
+            framework,
+            marker: hasRootFile("Podfile") ? "Podfile"
+                : hasRootFile("Package.swift") ? "Package.swift"
+                : rootFiles.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+        };
+    }
+
+    // Phase 2b: recursive scan up to 2 levels for *.xcodeproj / *.xcworkspace
+    // so iOS apps living under ios/, apps/ios/, etc. are still detected.
+    try {
+        for (const entry of rootFiles) {
+            const level1 = path.join(root, entry);
+            let level1Stat;
+            try { level1Stat = await fs.stat(level1); } catch (_) { continue; }
+            if (!level1Stat.isDirectory()) continue;
+            let level1Entries;
+            try { level1Entries = await fs.readdir(level1); } catch (_) { continue; }
+            if (level1Entries.some(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))) {
+                const framework = await detectAppleFramework(level1, fs, pathExt);
+                return {
+                    language: "ios",
+                    buildTool: "xcodebuild",
+                    framework,
+                    marker: level1Entries.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+                };
+            }
+            for (const sub of level1Entries) {
+                const level2 = path.join(level1, sub);
+                let level2Stat;
+                try { level2Stat = await fs.stat(level2); } catch (_) { continue; }
+                if (!level2Stat.isDirectory()) continue;
+                let level2Entries;
+                try { level2Entries = await fs.readdir(level2); } catch (_) { continue; }
+                if (level2Entries.some(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))) {
+                    const framework = await detectAppleFramework(level2, fs, pathExt);
+                    return {
+                        language: "ios",
+                        buildTool: "xcodebuild",
+                        framework,
+                        marker: level2Entries.find(f => f.endsWith(".xcodeproj") || f.endsWith(".xcworkspace"))
+                    };
+                }
+            }
+        }
+    } catch (_) {}
+
+    if (hasRootFile("gradlew") || hasRootFile("gradlew.bat") || hasRootFile("settings.gradle")
+        || hasRootFile("settings.gradle.kts") || hasRootFile("gradle.properties")
+        || await exists(path.join(root, "app", "src", "main", "AndroidManifest.xml"))
+        || await exists(path.join(root, "AndroidManifest.xml"))) {
+        const framework = await detectAndroidFramework(root, fs, pathExt);
+        return {
+            language: "android",
+            buildTool: "gradle",
+            framework,
+            marker: hasRootFile("gradlew") ? "gradlew"
+                : hasRootFile("settings.gradle") ? "settings.gradle"
+                : hasRootFile("settings.gradle.kts") ? "settings.gradle.kts"
+                : "AndroidManifest.xml"
+        };
+    }
+
+    // Phase 3: .NET — check for .csproj or .sln in root
+
+    const dotnetFile = rootFiles.find(f => f.endsWith(".csproj") || f.endsWith(".sln"));
+    if (dotnetFile) {
+        return { language: "dotnet", buildTool: "dotnet", marker: dotnetFile };
+    }
+
+    // Phase 4: Docker-only — Dockerfile without any other language marker
+    if (rootFiles.includes("Dockerfile") || rootFiles.includes("docker-compose.yml") || rootFiles.includes("docker-compose.yaml")) {
+        return { language: "docker", buildTool: "docker", marker: "Dockerfile" };
+    }
+
+    // Phase 5: Static site — index.html without backend markers
+    if (rootFiles.includes("index.html")) {
+        return { language: "static", buildTool: "none", marker: "index.html" };
+    }
+
+    // Phase 6: Infer from file extensions
+    const extCount = {};
+    for (const f of rootFiles) {
+        const ext = path.extname(f).toLowerCase();
+        if (ext) extCount[ext] = (extCount[ext] || 0) + 1;
+    }
+    // Also scan one level deep (src/ or lib/)
+    for (const dir of ["src", "lib", "app", "cmd"]) {
+        try {
+            const subFiles = await fs.readdir(path.join(root, dir));
+            for (const f of subFiles) {
+                const ext = path.extname(f).toLowerCase();
+                if (ext) extCount[ext] = (extCount[ext] || 0) + 1;
+            }
+        } catch (_) {}
+    }
+
+    const extMap = {
+        ".java": "java", ".kt": "kotlin", ".scala": "scala",
+        ".js": "node", ".ts": "node", ".jsx": "node", ".tsx": "node",
+        ".py": "python",
+        ".go": "go",
+        ".rb": "ruby",
+        ".rs": "rust",
+        ".cs": "dotnet",
+        ".php": "php",
+        ".dart": "dart",
+        ".ex": "elixir", ".exs": "elixir",
+        ".swift": "swift",
+    };
+
+    const langCount = {};
+    for (const [ext, count] of Object.entries(extCount)) {
+        const lang = extMap[ext];
+        if (lang) langCount[lang] = (langCount[lang] || 0) + count;
+    }
+
+    const sorted = Object.entries(langCount).sort((a, b) => b[1] - a[1]);
+    if (sorted.length > 0) {
+        const [lang, count] = sorted[0];
+        console.log(`[detectProject] Inferred ${lang} from ${count} files (extensions: ${JSON.stringify(extCount)})`);
+        return { language: lang, buildTool: "unknown", marker: `inferred from ${count} .${lang} files` };
+    }
+
+    // Phase 7: Unknown — log root files for diagnostics
+    console.warn(`[detectProject] Unknown stack in ${root}. Root files: ${rootFiles.join(", ")}`);
+    return { language: "unknown", buildTool: "unknown", marker: null, rootFiles };
+}
+
+async function detectAppleFramework(root, fs, pathExt) {
+    const swiftSources = await collectFiles(root, fs, pathExt, file => file.endsWith(".swift"), 4);
+    for (const file of swiftSources.slice(0, 12)) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("import SwiftUI") || content.includes("SwiftUI")) return "swiftui";
+            if (content.includes("UIKit")) return "uikit";
+        } catch (_) {}
+    }
+    return "ios";
+}
+
+async function detectAndroidFramework(root, fs, pathExt) {
+    const candidateFiles = [
+        path.join(root, "app", "build.gradle"),
+        path.join(root, "app", "build.gradle.kts"),
+        path.join(root, "build.gradle"),
+        path.join(root, "build.gradle.kts"),
+    ];
+
+    for (const file of candidateFiles) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("androidx.compose") || content.includes("compose = true")) {
+                return "jetpack-compose";
+            }
+        } catch (_) {}
+    }
+
+    const kotlinSources = await collectFiles(root, fs, pathExt, file => file.endsWith(".kt"), 4);
+    for (const file of kotlinSources.slice(0, 12)) {
+        try {
+            const content = await fs.readFile(file, "utf8");
+            if (content.includes("androidx.compose")) return "jetpack-compose";
+        } catch (_) {}
+    }
+
+    return "android";
+}
+
+async function collectFiles(root, fs, pathExt, predicate, maxDepth) {
+    const results = [];
+    const ignored = new Set([".git", "node_modules", "build", ".build", "DerivedData", ".gradle"]);
+
+    async function walk(dir, depth) {
+        if (depth > maxDepth) return;
+        let entries = [];
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        } catch (_) {
+            return;
+        }
+
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (!ignored.has(entry.name)) {
+                    await walk(fullPath, depth + 1);
+                }
+                continue;
+            }
+
+            if (predicate(fullPath, entry)) {
+                results.push(fullPath);
+            }
+        }
+    }
 
-    return { language: "unknown", buildTool: "unknown", marker: null };
+    await walk(root, 0);
+    return results;
 }
 
 export async function readText(root, relPath) {