@creative-ia/cortex 1.0.5

package/dist/tools/reverse-engineer.js

@@ -0,0 +1,956 @@
+/**
+ * Tool: reverse_engineer
+ * Analisa um repositório local ou remoto (Git URL) e gera artefato .md completo de engenharia reversa:
+ * - Stack detection (linguagens, frameworks, package managers)
+ * - Estrutura de módulos (pastas, camadas)
+ * - Dependências (package.json, pom.xml, build.gradle, requirements.txt, etc.)
+ * - APIs e contratos (REST endpoints, GraphQL schemas)
+ * - Padrões de arquitetura (MVC, Clean, Hexagonal, etc.)
+ * - Métricas (arquivos, linhas, testes)
+ *
+ * Repos remotos: aceita URLs Git (https:// ou git@). O token de acesso e lido
+ * das env vars configuradas no mcp.json do cliente:
+ *   GITHUB_TOKEN, GITLAB_TOKEN, BITBUCKET_TOKEN, AZURE_DEVOPS_TOKEN
+ */
+import { readdir, readFile, writeFile, rm } from "node:fs/promises";
+import { join, extname, basename, relative } from "node:path";
+import { existsSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { tmpdir } from "node:os";
+// ============================================================
+// CONSTANTS
+// ============================================================
+const IGNORE_DIRS = new Set([
+    "node_modules", ".git", ".svn", "dist", "build", "out", ".next",
+    ".nuxt", "target", "__pycache__", ".gradle", ".idea", ".vscode",
+    "coverage", ".nyc_output", "vendor", "bower_components", ".terraform",
+    "cdk.out", ".serverless", ".aws-sam", "bin", "obj",
+    // Artefatos gerados
+    "wiki", "generated-diagrams",
+    // Mobile build artifacts (React Native)
+    "Pods", "ios", "android",
+]);
+const CODE_EXTENSIONS = new Set([
+    ".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs",
+    ".java", ".kt", ".scala", ".groovy",
+    ".py", ".pyx",
+    ".go", ".rs", ".rb", ".php", ".cs", ".fs",
+    ".swift", ".m", ".mm",
+    ".c", ".cpp", ".h", ".hpp",
+    ".vue", ".svelte", ".astro",
+    ".sql", ".graphql", ".gql", ".proto",
+]);
+const CONFIG_EXTENSIONS = new Set([
+    ".json", ".yaml", ".yml", ".toml", ".xml", ".ini", ".env",
+    ".config", ".cfg", ".properties",
+]);
+const TEST_PATTERNS = [
+    /\.test\./i, /\.spec\./i, /\.e2e\./i, /__tests__/i,
+    /test[/\\]/i, /tests[/\\]/i, /spec[/\\]/i,
+];
+const LANG_MAP = {
+    ".ts": "TypeScript", ".tsx": "TypeScript (React)", ".js": "JavaScript",
+    ".jsx": "JavaScript (React)", ".mjs": "JavaScript (ESM)", ".cjs": "JavaScript (CJS)",
+    ".java": "Java", ".kt": "Kotlin", ".scala": "Scala", ".groovy": "Groovy",
+    ".py": "Python", ".go": "Go", ".rs": "Rust", ".rb": "Ruby",
+    ".php": "PHP", ".cs": "C#", ".fs": "F#", ".swift": "Swift",
+    ".c": "C", ".cpp": "C++", ".h": "C/C++ Header",
+    ".vue": "Vue", ".svelte": "Svelte", ".astro": "Astro",
+    ".sql": "SQL", ".graphql": "GraphQL", ".gql": "GraphQL", ".proto": "Protobuf",
+};
+// ============================================================
+// REMOTE REPO SUPPORT
+// ============================================================
+/** Detecta se o input e uma URL Git remota */
+function isRemoteUrl(input) {
+    return /^https?:\/\//i.test(input) || /^git@/i.test(input);
+}
+/** Identifica o provider Git a partir da URL */
+function detectGitProvider(url) {
+    const lower = url.toLowerCase();
+    if (lower.includes("github.com") || lower.includes("github"))
+        return "github";
+    if (lower.includes("gitlab.com") || lower.includes("gitlab"))
+        return "gitlab";
+    if (lower.includes("bitbucket.org") || lower.includes("bitbucket"))
+        return "bitbucket";
+    if (lower.includes("dev.azure.com") || lower.includes("visualstudio.com"))
+        return "azure";
+    return "unknown";
+}
+/** Busca o token do provider nas env vars */
+function getProviderToken(provider) {
+    const envMap = {
+        github: ["GITHUB_TOKEN", "GH_TOKEN", "GITHUB_TOKEN_COR", "GITHUB_TOKEN_PAR"],
+        gitlab: ["GITLAB_TOKEN", "GL_TOKEN"],
+        bitbucket: ["BITBUCKET_TOKEN", "BB_TOKEN"],
+        azure: ["AZURE_DEVOPS_TOKEN", "AZURE_DEVOPS_PAT", "AZURE_TOKEN"],
+        unknown: ["GIT_TOKEN"],
+    };
+    const keys = envMap[provider] || envMap.unknown;
+    for (const key of keys) {
+        if (process.env[key])
+            return process.env[key];
+    }
+    return undefined;
+}
+/** Injeta token na URL HTTPS para autenticacao */
+function injectTokenInUrl(url, token, provider) {
+    // https://github.com/org/repo.git → https://x-access-token:TOKEN@github.com/org/repo.git
+    if (provider === "github") {
+        return url.replace(/^https:\/\//, `https://x-access-token:${token}@`);
+    }
+    if (provider === "gitlab") {
+        return url.replace(/^https:\/\//, `https://oauth2:${token}@`);
+    }
+    if (provider === "bitbucket") {
+        return url.replace(/^https:\/\//, `https://x-token-auth:${token}@`);
+    }
+    if (provider === "azure") {
+        return url.replace(/^https:\/\//, `https://pat:${token}@`);
+    }
+    // fallback generico
+    return url.replace(/^https:\/\//, `https://token:${token}@`);
+}
+/** Extrai nome do repo a partir da URL */
+function repoNameFromUrl(url) {
+    // Remove .git suffix, pega ultimo segmento
+    const clean = url.replace(/\.git\s*$/, "").replace(/\/+$/, "");
+    const parts = clean.split("/");
+    return parts[parts.length - 1] || "repo";
+}
+/** Clona repo remoto em /tmp e retorna path local + cleanup function */
+async function cloneRemoteRepo(url) {
+    const provider = detectGitProvider(url);
+    const token = getProviderToken(provider);
+    const repoName = repoNameFromUrl(url);
+    const cloneDir = join(tmpdir(), `re-${randomUUID().slice(0, 8)}`);
+    let cloneUrl = url;
+    if (token && url.startsWith("https://")) {
+        cloneUrl = injectTokenInUrl(url, token, provider);
+    }
+    // Clone com depth 1 para performance
+    try {
+        execSync(`git clone --depth 1 --single-branch "${cloneUrl}" "${cloneDir}"`, {
+            timeout: 120_000,
+            stdio: "pipe",
+        });
+    }
+    catch (err) {
+        const msg = err.stderr?.toString() || err.message || "Erro desconhecido";
+        // Limpar token da mensagem de erro
+        const safeMsg = token ? msg.replace(new RegExp(token, "g"), "***") : msg;
+        throw new Error(`Falha ao clonar ${url}: ${safeMsg}`);
+    }
+    return {
+        localDir: cloneDir,
+        repoName,
+        cleanup: async () => {
+            try {
+                await rm(cloneDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+        },
+    };
+}
+// ============================================================
+// FILE WALKER
+// ============================================================
+async function walkDir(dir, maxDepth = 12, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const files = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            if (entry.name.startsWith(".") && entry.name !== ".env")
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                const sub = await walkDir(fullPath, maxDepth, depth + 1);
+                files.push(...sub);
+            }
+            else {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch { /* permission denied, etc */ }
+    return files;
+}
+// ============================================================
+// STACK DETECTION
+// ============================================================
+async function detectStack(repoDir, allFiles) {
+    const languages = new Map();
+    const frameworks = new Set();
+    const packageManagers = new Set();
+    const runtimes = new Set();
+    // Pastas cujo conteudo nao deve ser contado como codigo-fonte do repo
+    const NON_SOURCE_SEGMENTS = new Set(["docs", "documentation", "knowledge", "examples", "samples", "fixtures", "testdata"]);
+    // Count languages by extension (skip files inside non-source folders)
+    for (const f of allFiles) {
+        const rel = relative(repoDir, f);
+        const segments = rel.split("/");
+        const inNonSource = segments.some(s => NON_SOURCE_SEGMENTS.has(s.toLowerCase()));
+        if (inNonSource)
+            continue;
+        const ext = extname(f).toLowerCase();
+        const lang = LANG_MAP[ext];
+        if (lang)
+            languages.set(lang, (languages.get(lang) || 0) + 1);
+    }
+    // Detect package managers
+    const rootFiles = new Set(allFiles.filter(f => relative(repoDir, f).split("/").length === 1).map(f => basename(f)));
+    if (rootFiles.has("package.json"))
+        packageManagers.add("npm/yarn");
+    if (rootFiles.has("yarn.lock"))
+        packageManagers.add("Yarn");
+    if (rootFiles.has("pnpm-lock.yaml"))
+        packageManagers.add("pnpm");
+    if (rootFiles.has("package-lock.json"))
+        packageManagers.add("npm");
+    if (rootFiles.has("pom.xml"))
+        packageManagers.add("Maven");
+    if (rootFiles.has("build.gradle") || rootFiles.has("build.gradle.kts"))
+        packageManagers.add("Gradle");
+    if (rootFiles.has("requirements.txt") || rootFiles.has("Pipfile") || rootFiles.has("pyproject.toml"))
+        packageManagers.add("pip/Poetry");
+    if (rootFiles.has("go.mod"))
+        packageManagers.add("Go Modules");
+    if (rootFiles.has("Cargo.toml"))
+        packageManagers.add("Cargo");
+    if (rootFiles.has("Gemfile"))
+        packageManagers.add("Bundler");
+    if (rootFiles.has("composer.json"))
+        packageManagers.add("Composer");
+    // Detect frameworks from package.json
+    const pkgPath = join(repoDir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+            const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (allDeps["react"])
+                frameworks.add("React");
+            if (allDeps["react-native"])
+                frameworks.add("React Native");
+            if (allDeps["next"])
+                frameworks.add("Next.js");
+            if (allDeps["nuxt"] || allDeps["nuxt3"])
+                frameworks.add("Nuxt");
+            if (allDeps["vue"])
+                frameworks.add("Vue.js");
+            if (allDeps["@angular/core"])
+                frameworks.add("Angular");
+            if (allDeps["svelte"])
+                frameworks.add("Svelte");
+            if (allDeps["express"])
+                frameworks.add("Express");
+            if (allDeps["fastify"])
+                frameworks.add("Fastify");
+            if (allDeps["nestjs"] || allDeps["@nestjs/core"])
+                frameworks.add("NestJS");
+            if (allDeps["hapi"] || allDeps["@hapi/hapi"])
+                frameworks.add("Hapi");
+            if (allDeps["koa"])
+                frameworks.add("Koa");
+            if (allDeps["apollo-server"] || allDeps["@apollo/server"])
+                frameworks.add("Apollo Server");
+            if (allDeps["@apollo/client"])
+                frameworks.add("Apollo Client");
+            if (allDeps["graphql"])
+                frameworks.add("GraphQL");
+            if (allDeps["prisma"] || allDeps["@prisma/client"])
+                frameworks.add("Prisma");
+            if (allDeps["typeorm"])
+                frameworks.add("TypeORM");
+            if (allDeps["sequelize"])
+                frameworks.add("Sequelize");
+            if (allDeps["mongoose"])
+                frameworks.add("Mongoose");
+            if (allDeps["redux"] || allDeps["@reduxjs/toolkit"])
+                frameworks.add("Redux");
+            if (allDeps["zustand"])
+                frameworks.add("Zustand");
+            if (allDeps["tailwindcss"])
+                frameworks.add("Tailwind CSS");
+            if (allDeps["jest"])
+                frameworks.add("Jest");
+            if (allDeps["vitest"])
+                frameworks.add("Vitest");
+            if (allDeps["mocha"])
+                frameworks.add("Mocha");
+            if (allDeps["cypress"])
+                frameworks.add("Cypress");
+            if (allDeps["playwright"] || allDeps["@playwright/test"])
+                frameworks.add("Playwright");
+            if (allDeps["storybook"] || allDeps["@storybook/react"])
+                frameworks.add("Storybook");
+            if (allDeps["aws-cdk-lib"])
+                frameworks.add("AWS CDK");
+            if (allDeps["serverless"])
+                frameworks.add("Serverless Framework");
+            if (allDeps["@aws-sdk/client-s3"] || allDeps["aws-sdk"])
+                frameworks.add("AWS SDK");
+            if (allDeps["datadog-lambda-js"] || allDeps["dd-trace"])
+                frameworks.add("Datadog");
+            if (allDeps["@sentry/node"] || allDeps["@sentry/react"])
+                frameworks.add("Sentry");
+            // Runtime detection
+            if (pkg.engines?.node)
+                runtimes.add(`Node.js ${pkg.engines.node}`);
+            if (allDeps["typescript"])
+                runtimes.add(`TypeScript ${allDeps["typescript"]}`);
+        }
+        catch { /* ignore */ }
+    }
+    // Detect from pom.xml
+    const pomPath = join(repoDir, "pom.xml");
+    if (existsSync(pomPath)) {
+        try {
+            const pom = await readFile(pomPath, "utf-8");
+            if (pom.includes("spring-boot"))
+                frameworks.add("Spring Boot");
+            if (pom.includes("quarkus"))
+                frameworks.add("Quarkus");
+            if (pom.includes("micronaut"))
+                frameworks.add("Micronaut");
+            runtimes.add("JVM");
+        }
+        catch { /* ignore */ }
+    }
+    // Detect from requirements.txt / pyproject.toml
+    for (const pyFile of ["requirements.txt", "pyproject.toml"]) {
+        const pyPath = join(repoDir, pyFile);
+        if (existsSync(pyPath)) {
+            try {
+                const content = await readFile(pyPath, "utf-8");
+                if (content.includes("django"))
+                    frameworks.add("Django");
+                if (content.includes("flask"))
+                    frameworks.add("Flask");
+                if (content.includes("fastapi"))
+                    frameworks.add("FastAPI");
+                if (content.includes("boto3"))
+                    frameworks.add("AWS SDK (Python)");
+                runtimes.add("Python");
+            }
+            catch { /* ignore */ }
+        }
+    }
+    return {
+        languages,
+        frameworks: [...frameworks],
+        packageManagers: [...packageManagers],
+        runtimes: [...runtimes],
+    };
+}
+// ============================================================
+// DEPENDENCY ANALYSIS
+// ============================================================
+async function analyzeDependencies(repoDir) {
+    const deps = [];
+    // package.json
+    const pkgPath = join(repoDir, "package.json");
+    if (existsSync(pkgPath)) {
+        try {
+            const pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+            deps.push({
+                file: "package.json",
+                type: "npm",
+                dependencies: pkg.dependencies || {},
+                devDependencies: pkg.devDependencies || {},
+            });
+        }
+        catch { /* ignore */ }
+    }
+    // Check for monorepo workspaces
+    const pkgJsonFiles = await findFiles(repoDir, "package.json", 3);
+    for (const pf of pkgJsonFiles) {
+        const rel = relative(repoDir, pf);
+        if (rel === "package.json")
+            continue;
+        try {
+            const pkg = JSON.parse(await readFile(pf, "utf-8"));
+            if (pkg.name) {
+                deps.push({
+                    file: rel,
+                    type: "npm (workspace)",
+                    dependencies: pkg.dependencies || {},
+                    devDependencies: pkg.devDependencies || {},
+                });
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return deps;
+}
+async function findFiles(dir, filename, maxDepth, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const results = [];
+    try {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                results.push(...await findFiles(fullPath, filename, maxDepth, depth + 1));
+            }
+            else if (entry.name === filename) {
+                results.push(fullPath);
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return results;
+}
+// ============================================================
+// MODULE STRUCTURE ANALYSIS
+// ============================================================
+async function analyzeModules(repoDir) {
+    const modules = [];
+    try {
+        const entries = await readdir(repoDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (IGNORE_DIRS.has(entry.name))
+                continue;
+            if (entry.name.startsWith("."))
+                continue;
+            const dirPath = join(repoDir, entry.name);
+            const files = await walkDir(dirPath, 10);
+            const codeFiles = files.filter(f => CODE_EXTENSIONS.has(extname(f).toLowerCase()));
+            let type = "directory";
+            if (entry.name === "src")
+                type = "source root";
+            else if (entry.name === "lib" || entry.name === "libs")
+                type = "library";
+            else if (entry.name === "test" || entry.name === "tests" || entry.name === "__tests__")
+                type = "tests";
+            else if (entry.name === "config" || entry.name === "configs")
+                type = "configuration";
+            else if (entry.name === "scripts")
+                type = "scripts";
+            else if (entry.name === "docs" || entry.name === "documentation")
+                type = "documentation";
+            else if (entry.name === "api")
+                type = "API layer";
+            else if (entry.name === "components")
+                type = "UI components";
+            else if (entry.name === "pages" || entry.name === "views" || entry.name === "screens")
+                type = "views/pages";
+            else if (entry.name === "services")
+                type = "services";
+            else if (entry.name === "models" || entry.name === "entities")
+                type = "data models";
+            else if (entry.name === "utils" || entry.name === "helpers")
+                type = "utilities";
+            else if (entry.name === "hooks")
+                type = "React hooks";
+            else if (entry.name === "store" || entry.name === "redux")
+                type = "state management";
+            else if (entry.name === "middleware" || entry.name === "middlewares")
+                type = "middleware";
+            else if (entry.name === "routes" || entry.name === "router")
+                type = "routing";
+            else if (entry.name === "modules" || entry.name === "features")
+                type = "feature modules";
+            else if (entry.name === "infra" || entry.name === "infrastructure")
+                type = "infrastructure";
+            else if (entry.name === "domain")
+                type = "domain layer";
+            else if (entry.name === "application")
+                type = "application layer";
+            else if (entry.name === "presentation")
+                type = "presentation layer";
+            // Deeper analysis for src/
+            if (entry.name === "src") {
+                const subModules = await analyzeModules(dirPath);
+                modules.push(...subModules.map(m => ({ ...m, path: `src/${m.path}` })));
+            }
+            modules.push({
+                path: entry.name,
+                type,
+                files: codeFiles.length,
+                description: `${codeFiles.length} code files`,
+            });
+        }
+    }
+    catch { /* ignore */ }
+    return modules;
+}
+// ============================================================
+// API DETECTION
+// ============================================================
+async function detectApis(repoDir, allFiles) {
+    const endpoints = [];
+    const NON_SOURCE_SEGMENTS = new Set(["docs", "documentation", "knowledge", "examples", "samples", "fixtures", "testdata"]);
+    const codeFiles = allFiles.filter(f => {
+        const ext = extname(f).toLowerCase();
+        if (![".ts", ".js", ".tsx", ".jsx", ".py", ".java", ".go", ".rb", ".php"].includes(ext))
+            return false;
+        const rel = relative(repoDir, f);
+        return !rel.split("/").some(s => NON_SOURCE_SEGMENTS.has(s.toLowerCase()));
+    });
+    // Limit to first 500 files to avoid timeout
+    const filesToScan = codeFiles.slice(0, 500);
+    for (const file of filesToScan) {
+        try {
+            const content = await readFile(file, "utf-8");
+            const lines = content.split("\n");
+            const rel = relative(repoDir, file);
+            // Track Spring @RequestMapping class-level prefix
+            let classPrefix = "";
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // --- Express/Fastify/Koa/Hapi patterns ---
+                const routeMatch = line.match(/\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/i);
+                if (routeMatch) {
+                    endpoints.push({ method: routeMatch[1].toUpperCase(), path: routeMatch[2], file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- Express router.route().get/post chain ---
+                const routeChain = line.match(/\.route\s*\(\s*['"`]([^'"`]+)['"`]\s*\)\s*\.(get|post|put|patch|delete)/i);
+                if (routeChain) {
+                    endpoints.push({ method: routeChain[2].toUpperCase(), path: routeChain[1], file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- NestJS decorators ---
+                const nestMatch = line.match(/@(Get|Post|Put|Patch|Delete)\s*\(\s*['"`]?([^'"`)\s]*)['"`]?\s*\)/i);
+                if (nestMatch) {
+                    endpoints.push({ method: nestMatch[1].toUpperCase(), path: nestMatch[2] || "/", file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- Spring Boot: class-level @RequestMapping ---
+                const classMapping = line.match(/@RequestMapping\s*\(\s*(?:value\s*=\s*)?['"`]([^'"`]+)['"`]/);
+                if (classMapping) {
+                    classPrefix = classMapping[1];
+                    continue;
+                }
+                // --- Spring Boot: method-level mappings (with or without path) ---
+                const springAnnotation = line.match(/@(GetMapping|PostMapping|PutMapping|DeleteMapping|PatchMapping)\b/i);
+                if (springAnnotation) {
+                    const method = springAnnotation[1].replace("Mapping", "").toUpperCase();
+                    let springPath = "/";
+                    // Try explicit value= or path= attribute
+                    const valueAttr = line.match(/@\w+Mapping\s*\(.*?(?:value|path)\s*=\s*['"`]([^'"`]*)['"`]/i);
+                    if (valueAttr) {
+                        springPath = valueAttr[1] || "/";
+                    }
+                    else {
+                        // Try first positional string arg (must NOT be preceded by a key like consumes=, produces=, etc.)
+                        const positionalArg = line.match(/@\w+Mapping\s*\(\s*['"`]([^'"`]*)['"`]/i);
+                        if (positionalArg) {
+                            springPath = positionalArg[1] || "/";
+                        }
+                    }
+                    const fullPath = classPrefix ? `${classPrefix}${springPath === "/" ? "" : springPath}` : springPath;
+                    endpoints.push({ method, path: fullPath, file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- FastAPI / Flask ---
+                const pyMatch = line.match(/@(?:app|router)\.(get|post|put|patch|delete)\s*\(\s*['"`]([^'"`]+)['"`]/i);
+                if (pyMatch) {
+                    endpoints.push({ method: pyMatch[1].toUpperCase(), path: pyMatch[2], file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- GraphQL: schema field definitions ---
+                // Pattern: fieldName: { type: ..., resolve: ... } (in *Queries.js / *Mutations.js)
+                const isQueryFile = /quer/i.test(rel);
+                const isMutationFile = /mutat/i.test(rel);
+                if (isQueryFile || isMutationFile) {
+                    const gqlField = line.match(/^\s{2,}(\w+)\s*:\s*\{/);
+                    if (gqlField) {
+                        const fieldName = gqlField[1];
+                        if (!["type", "args", "resolve", "description", "deprecationReason"].includes(fieldName)) {
+                            endpoints.push({
+                                method: isMutationFile ? "MUTATION" : "QUERY",
+                                path: fieldName,
+                                file: rel,
+                                line: i + 1,
+                            });
+                            continue;
+                        }
+                    }
+                }
+                // --- GraphQL: resolver return object ---
+                // Pattern: return { getKeys, createKey, ... } (in *Resolver.js)
+                if (/resolver/i.test(rel) && /^\s*return\s*\{/.test(line)) {
+                    // Collect all fields from the return block
+                    let block = line;
+                    for (let j = i; j < Math.min(i + 80, lines.length); j++) {
+                        block += " " + lines[j];
+                        if (lines[j].includes("};"))
+                            break;
+                    }
+                    const fields = block.match(/\b(\w+)\s*[,}]/g);
+                    if (fields) {
+                        for (const f of fields) {
+                            const name = f.replace(/[,}\s]/g, "");
+                            if (name && name.length > 2 && !["module", "exports", "require", "const", "let", "var"].includes(name)) {
+                                endpoints.push({ method: "RESOLVER", path: name, file: rel, line: i + 1 });
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // --- GraphQL typeDefs: type Query { field } / type Mutation { field } ---
+                const gqlTypeDef = line.match(/^\s*(type\s+(?:Query|Mutation)\s*\{)/i);
+                if (gqlTypeDef) {
+                    const isMut = /mutation/i.test(gqlTypeDef[1]);
+                    // Scan next lines for field definitions
+                    for (let j = i + 1; j < Math.min(i + 50, lines.length); j++) {
+                        if (lines[j].includes("}"))
+                            break;
+                        const fieldMatch = lines[j].match(/^\s*(\w+)\s*[\(:]/);
+                        if (fieldMatch) {
+                            endpoints.push({
+                                method: isMut ? "MUTATION" : "QUERY",
+                                path: fieldMatch[1],
+                                file: rel,
+                                line: j + 1,
+                            });
+                        }
+                    }
+                }
+                // --- Kafka consumer/producer ---
+                const kafkaConsumer = line.match(/(?:consumer|subscribe)\s*\(\s*\{?\s*(?:topic|topics)\s*:\s*['"`]([^'"`]+)['"`]/i);
+                if (kafkaConsumer) {
+                    endpoints.push({ method: "KAFKA_CONSUMER", path: kafkaConsumer[1], file: rel, line: i + 1 });
+                    continue;
+                }
+                const kafkaProducer = line.match(/(?:producer|send)\s*\(\s*\{?\s*topic\s*:\s*['"`]([^'"`]+)['"`]/i);
+                if (kafkaProducer) {
+                    endpoints.push({ method: "KAFKA_PRODUCER", path: kafkaProducer[1], file: rel, line: i + 1 });
+                    continue;
+                }
+                // --- Lambda handler ---
+                const lambdaHandler = line.match(/exports\.handler\s*=|export\s+(?:async\s+)?function\s+handler|module\.exports\s*=\s*\{?\s*handler/);
+                if (lambdaHandler) {
+                    endpoints.push({ method: "LAMBDA", path: "handler", file: rel, line: i + 1 });
+                    continue;
+                }
+            }
+        }
+        catch { /* ignore binary files, etc */ }
+    }
+    return endpoints;
+}
+// ============================================================
+// ARCHITECTURE PATTERN DETECTION
+// ============================================================
+function detectArchitecturePatterns(modules, allFiles, repoDir) {
+    const patterns = [];
+    const dirs = new Set(modules.map(m => m.path.toLowerCase()));
+    const relFiles = allFiles.map(f => relative(repoDir, f).toLowerCase());
+    // Clean Architecture / Hexagonal
+    if (dirs.has("domain") && (dirs.has("application") || dirs.has("use-cases") || dirs.has("usecases"))) {
+        patterns.push("Clean Architecture / Hexagonal");
+    }
+    // MVC
+    if ((dirs.has("models") || dirs.has("entities")) && (dirs.has("views") || dirs.has("pages")) && dirs.has("controllers")) {
+        patterns.push("MVC (Model-View-Controller)");
+    }
+    // MVVM
+    if ((dirs.has("models") || dirs.has("entities")) && dirs.has("viewmodels") && (dirs.has("views") || dirs.has("screens"))) {
+        patterns.push("MVVM (Model-View-ViewModel)");
+    }
+    // Feature-based / Modular
+    if (dirs.has("modules") || dirs.has("features")) {
+        patterns.push("Feature-based / Modular");
+    }
+    // Layered
+    if (dirs.has("services") && (dirs.has("controllers") || dirs.has("routes")) && (dirs.has("models") || dirs.has("repositories"))) {
+        patterns.push("Layered Architecture");
+    }
+    // BFF (Backend for Frontend)
+    if (relFiles.some(f => f.includes("resolver")) && (relFiles.some(f => f.includes("graphql")) || relFiles.some(f => f.endsWith(".graphql") || f.endsWith(".gql")))) {
+        patterns.push("BFF (Backend for Frontend) — GraphQL");
+    }
+    else if (dirs.has("resolvers") || relFiles.some(f => f.includes("resolver"))) {
+        patterns.push("GraphQL Resolvers");
+    }
+    // GraphQL API
+    if (relFiles.some(f => f.endsWith(".graphql") || f.endsWith(".gql") || f.includes("schema.graphql") || f.includes("typedef"))) {
+        patterns.push("GraphQL API");
+    }
+    // Monorepo
+    if (dirs.has("packages") || dirs.has("apps") || relFiles.some(f => f.includes("lerna.json") || f.includes("turbo.json"))) {
+        patterns.push("Monorepo");
+    }
+    // Serverless
+    if (relFiles.some(f => f.includes("serverless.yml") || f.includes("serverless.yaml") || f.includes("template.yaml") || f.includes("cdk.json") || f.includes("sam.json"))) {
+        patterns.push("Serverless / IaC");
+    }
+    // Terraform
+    if (relFiles.some(f => f.endsWith(".tf") || f.includes("terraform"))) {
+        patterns.push("Terraform (IaC)");
+    }
+    // Docker
+    if (relFiles.some(f => f.includes("docker-compose"))) {
+        patterns.push("Containerized (Docker Compose)");
+    }
+    if (relFiles.some(f => f.includes("dockerfile"))) {
+        patterns.push("Docker");
+    }
+    // Kafka / Event-driven
+    if (relFiles.some(f => f.includes("kafka") || f.includes("consumer") || f.includes("producer"))) {
+        patterns.push("Event-Driven (Kafka)");
+    }
+    // REST
+    if (relFiles.some(f => f.includes("swagger") || f.includes("openapi"))) {
+        patterns.push("REST API (OpenAPI/Swagger)");
+    }
+    // Spring Boot
+    if (relFiles.some(f => f.includes("application.properties") || f.includes("application.yml") || f.includes("application.yaml"))) {
+        if (relFiles.some(f => f.endsWith(".java"))) {
+            patterns.push("Spring Boot");
+        }
+    }
+    // React Native
+    if (relFiles.some(f => f.includes("android/") || f.includes("ios/")) && relFiles.some(f => f.includes("app.json") || f.includes("react-native"))) {
+        patterns.push("React Native (Mobile)");
+    }
+    // Component Library
+    if (dirs.has("components") && (relFiles.some(f => f.includes("storybook")) || relFiles.some(f => f.includes("stories")))) {
+        patterns.push("Component Library (Storybook)");
+    }
+    // Interceptors / Middleware pattern
+    if (dirs.has("interceptors") || dirs.has("middleware") || dirs.has("middlewares")) {
+        patterns.push("Middleware / Interceptor Pattern");
+    }
+    // Adapters pattern
+    if (dirs.has("adapters") || dirs.has("gateways")) {
+        patterns.push("Adapter / Gateway Pattern");
+    }
+    if (patterns.length === 0)
+        patterns.push("Convencional (sem padrao arquitetural forte detectado)");
+    return patterns;
+}
+// ============================================================
+// METRICS
+// ============================================================
+async function computeMetrics(repoDir, allFiles) {
+    const byExtension = new Map();
+    let totalLines = 0;
+    let codeFiles = 0;
+    let testFiles = 0;
+    let configFiles = 0;
+    const NON_SOURCE_SEGMENTS = new Set(["docs", "documentation", "knowledge", "examples", "samples", "fixtures", "testdata"]);
+    for (const f of allFiles) {
+        const ext = extname(f).toLowerCase();
+        byExtension.set(ext, (byExtension.get(ext) || 0) + 1);
+        // Nao contar arquivos em pastas de documentacao como codigo-fonte
+        const rel = relative(repoDir, f);
+        const segments = rel.split("/");
+        const inNonSource = segments.some(s => NON_SOURCE_SEGMENTS.has(s.toLowerCase()));
+        if (CODE_EXTENSIONS.has(ext) && !inNonSource) {
+            codeFiles++;
+            if (TEST_PATTERNS.some(p => p.test(rel)))
+                testFiles++;
+            try {
+                const content = await readFile(f, "utf-8");
+                totalLines += content.split("\n").length;
+            }
+            catch { /* binary */ }
+        }
+        else if (CONFIG_EXTENSIONS.has(ext)) {
+            configFiles++;
+        }
+    }
+    return { totalFiles: allFiles.length, totalLines, codeFiles, testFiles, configFiles, byExtension };
+}
+// ============================================================
+// MARKDOWN REPORT GENERATOR
+// ============================================================
+function generateReport(repoDir, stack, deps, modules, apis, patterns, metrics, repoName) {
+    const date = new Date().toISOString().slice(0, 10);
+    let md = `# Engenharia Reversa — ${repoName}\n\n`;
+    md += `> Data: ${date}\n`;
+    md += `> Repositório: ${repoName}\n`;
+    md += `> Caminho: ${repoDir}\n\n---\n\n`;
+    // 1. Stack
+    md += `## 1. Stack Tecnológica\n\n`;
+    md += `| Camada | Tecnologia | Arquivos |\n|--------|-----------|----------|\n`;
+    const sortedLangs = [...stack.languages.entries()].sort((a, b) => b[1] - a[1]);
+    for (const [lang, count] of sortedLangs) {
+        md += `| Linguagem | ${lang} | ${count} |\n`;
+    }
+    if (stack.frameworks.length > 0) {
+        for (const fw of stack.frameworks) {
+            md += `| Framework | ${fw} | — |\n`;
+        }
+    }
+    if (stack.packageManagers.length > 0) {
+        md += `| Package Manager | ${stack.packageManagers.join(", ")} | — |\n`;
+    }
+    if (stack.runtimes.length > 0) {
+        md += `| Runtime | ${stack.runtimes.join(", ")} | — |\n`;
+    }
+    md += `\n`;
+    // 2. Padrões de Arquitetura
+    md += `## 2. Padrões de Arquitetura\n\n`;
+    for (const p of patterns) {
+        md += `- ${p}\n`;
+    }
+    md += `\n`;
+    // 3. Estrutura de Módulos
+    md += `## 3. Estrutura de Módulos\n\n`;
+    md += `| Pasta | Tipo | Arquivos |\n|-------|------|----------|\n`;
+    const topModules = modules.filter(m => !m.path.includes("/")).sort((a, b) => b.files - a.files);
+    for (const m of topModules) {
+        md += `| \`${m.path}/\` | ${m.type} | ${m.files} |\n`;
+    }
+    // Sub-modules (src/)
+    const srcModules = modules.filter(m => m.path.startsWith("src/") && m.path.split("/").length === 2);
+    if (srcModules.length > 0) {
+        md += `\n### Detalhamento src/\n\n`;
+        md += `| Pasta | Tipo | Arquivos |\n|-------|------|----------|\n`;
+        for (const m of srcModules.sort((a, b) => b.files - a.files)) {
+            md += `| \`${m.path}/\` | ${m.type} | ${m.files} |\n`;
+        }
+    }
+    md += `\n`;
+    // 4. Dependências
+    md += `## 4. Dependências\n\n`;
+    for (const dep of deps) {
+        const depCount = Object.keys(dep.dependencies).length;
+        const devCount = Object.keys(dep.devDependencies).length;
+        md += `### ${dep.file} (${dep.type})\n\n`;
+        md += `- **Dependências de produção**: ${depCount}\n`;
+        md += `- **Dependências de desenvolvimento**: ${devCount}\n\n`;
+        if (depCount > 0) {
+            md += `| Pacote | Versão |\n|--------|--------|\n`;
+            const sorted = Object.entries(dep.dependencies).sort((a, b) => a[0].localeCompare(b[0]));
+            for (const [name, version] of sorted) {
+                md += `| ${name} | ${version} |\n`;
+            }
+            md += `\n`;
+        }
+        if (devCount > 0) {
+            md += `**Dev Dependencies:**\n\n`;
+            md += `| Pacote | Versão |\n|--------|--------|\n`;
+            const sorted = Object.entries(dep.devDependencies).sort((a, b) => a[0].localeCompare(b[0]));
+            for (const [name, version] of sorted) {
+                md += `| ${name} | ${version} |\n`;
+            }
+            md += `\n`;
+        }
+    }
+    // 5. APIs e Contratos
+    md += `## 5. APIs e Contratos\n\n`;
+    if (apis.length === 0) {
+        md += `Nenhum endpoint REST/GraphQL detectado automaticamente.\n\n`;
+    }
+    else {
+        md += `${apis.length} endpoints detectados:\n\n`;
+        md += `| Método | Path | Arquivo | Linha |\n|--------|------|---------|-------|\n`;
+        for (const api of apis.slice(0, 100)) {
+            md += `| ${api.method} | \`${api.path}\` | ${api.file} | ${api.line} |\n`;
+        }
+        if (apis.length > 100) {
+            md += `\n> ... e mais ${apis.length - 100} endpoints (truncado)\n`;
+        }
+        md += `\n`;
+    }
+    // 6. Métricas
+    md += `## 6. Métricas\n\n`;
+    md += `| Métrica | Valor |\n|---------|-------|\n`;
+    md += `| Total de arquivos | ${metrics.totalFiles.toLocaleString()} |\n`;
+    md += `| Arquivos de código | ${metrics.codeFiles.toLocaleString()} |\n`;
+    md += `| Arquivos de teste | ${metrics.testFiles.toLocaleString()} |\n`;
+    md += `| Arquivos de configuração | ${metrics.configFiles.toLocaleString()} |\n`;
+    md += `| Total de linhas de código | ${metrics.totalLines.toLocaleString()} |\n`;
+    md += `\n### Distribuição por extensão\n\n`;
+    md += `| Extensão | Arquivos |\n|----------|----------|\n`;
+    const sortedExt = [...metrics.byExtension.entries()].sort((a, b) => b[1] - a[1]).slice(0, 20);
+    for (const [ext, count] of sortedExt) {
+        md += `| ${ext} | ${count} |\n`;
+    }
+    md += `\n`;
+    return md;
+}
+// ============================================================
+// MAIN EXPORT
+// ============================================================
+export async function reverseEngineer(req) {
+    const { repoDir: inputDir, processId, processDir, outputFilename } = req;
+    // Detectar se e URL remota
+    const isRemote = isRemoteUrl(inputDir);
+    let repoDir;
+    let repoName;
+    let cleanup;
+    if (isRemote) {
+        try {
+            const cloneResult = await cloneRemoteRepo(inputDir);
+            repoDir = cloneResult.localDir;
+            repoName = cloneResult.repoName;
+            cleanup = cloneResult.cleanup;
+        }
+        catch (err) {
+            return { success: false, message: err.message || `Erro ao clonar: ${inputDir}` };
+        }
+    }
+    else {
+        if (!existsSync(inputDir)) {
+            return { success: false, message: `Diretório não encontrado: ${inputDir}` };
+        }
+        repoDir = inputDir;
+        repoName = basename(repoDir);
+    }
+    try {
+        // 1. Walk all files
+        const allFiles = await walkDir(repoDir);
+        if (allFiles.length === 0) {
+            return { success: false, message: `Nenhum arquivo encontrado em: ${inputDir}` };
+        }
+        // 2. Run all analyses in parallel
+        const [stack, deps, modules, apis, metrics] = await Promise.all([
+            detectStack(repoDir, allFiles),
+            analyzeDependencies(repoDir),
+            analyzeModules(repoDir),
+            detectApis(repoDir, allFiles),
+            computeMetrics(repoDir, allFiles),
+        ]);
+        // 3. Detect architecture patterns
+        const patterns = detectArchitecturePatterns(modules, allFiles, repoDir);
+        // 4. Generate markdown report
+        const displayDir = isRemote ? inputDir : repoDir;
+        const report = generateReport(displayDir, stack, deps, modules, apis, patterns, metrics, repoName);
+        // 5. Write output file
+        const filename = outputFilename || `engenharia-reversa-${repoName}.md`;
+        let outputPath;
+        if (processDir && existsSync(processDir)) {
+            outputPath = join(processDir, filename);
+        }
+        else if (isRemote) {
+            // Repo remoto sem processDir: salva no cwd
+            outputPath = join(process.cwd(), filename);
+        }
+        else {
+            outputPath = join(repoDir, filename);
+        }
+        await writeFile(outputPath, report, "utf-8");
+        // 6. Summary
+        const topLangs = [...stack.languages.entries()].sort((a, b) => b[1] - a[1]).slice(0, 3).map(([l]) => l).join(", ");
+        const source = isRemote ? `(remoto) ${repoName}` : repoName;
+        const summary = `${source}: ${metrics.codeFiles} code files, ${metrics.totalLines.toLocaleString()} lines, ${topLangs}. ${stack.frameworks.length} frameworks, ${apis.length} endpoints, ${patterns.join(", ")}.`;
+        return {
+            success: true,
+            message: `Engenharia reversa concluída. Artefato salvo em: ${outputPath}`,
+            outputFile: outputPath,
+            summary,
+        };
+    }
+    finally {
+        // Limpar clone temporario
+        if (cleanup)
+            await cleanup();
+    }
+}