deepdebug-local-agent 0.3.1

package/src/routes/workspace.route.js

@@ -0,0 +1,528 @@
+import express from "express";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const router = express.Router();
+
+// 🔹 Caminho global do workspace (inicializado com fallback padrão)
+let workspacePath =
+    process.env.WORKSPACE_BASE ||
+    path.join(os.homedir(), "Documents", "Projects");
+
+// --------------------------------------------------
+// 🧩 1️⃣ GET /workspace/info
+// Retorna informações sobre o workspace atual
+// --------------------------------------------------
+router.get("/info", async (req, res) => {
+    try {
+        return res.json({
+            workspacePath,
+            exists: fs.existsSync(workspacePath),
+            isDirectory: fs.existsSync(workspacePath)
+                ? fs.lstatSync(workspacePath).isDirectory()
+                : false,
+        });
+    } catch (err) {
+        console.error("❌ Error reading workspace info:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 2️⃣ POST /workspace
+// Atualiza o diretório de workspace selecionado pelo usuário
+// --------------------------------------------------
+router.post("/", async (req, res) => {
+    try {
+        console.log(workspacePath)
+        const { workspacePath: newPath } = req.body;
+        if (!newPath) {
+            return res.status(400).json({ error: "Missing workspacePath" });
+        }
+
+        // 🔹 Resolve o caminho completo (garante formato absoluto)
+        const resolvedPath = path.resolve(newPath);
+
+        if (!fs.existsSync(resolvedPath) || !fs.lstatSync(resolvedPath).isDirectory()) {
+            return res
+                .status(400)
+                .json({ error: `Invalid directory path: ${resolvedPath}` });
+        }
+
+        workspacePath = resolvedPath;
+        console.log(`📂 Workspace updated to: ${workspacePath}`);
+
+        return res.json({ success: true, workspacePath });
+    } catch (err) {
+        console.error("❌ Error updating workspace:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 3️⃣ GET /workspace/files
+// Lista arquivos .java (até 3 níveis de profundidade)
+// --------------------------------------------------
+router.get("/files", async (req, res) => {
+    try {
+        if (!workspacePath || !fs.existsSync(workspacePath)) {
+            return res.status(400).json({ error: "Workspace not configured or invalid" });
+        }
+
+        const files = [];
+
+        function walk(dir, depth = 0) {
+            if (depth > 3) return;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                } else if (entry.isFile() && entry.name.endsWith(".java")) {
+                    files.push(fullPath);
+                }
+            }
+        }
+
+        walk(workspacePath);
+        return res.json({ workspacePath, files });
+    } catch (err) {
+        console.error("❌ Error listing files:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 4️⃣ GET /workspace/file
+// Lê o conteúdo de um arquivo específico dentro do workspace
+// --------------------------------------------------
+router.get("/file", async (req, res) => {
+    try {
+        const { path: requestedPath } = req.query;
+
+        if (!requestedPath) {
+            return res.status(400).json({ error: "Missing 'path' query parameter" });
+        }
+
+        // 🔹 Corrige o caminho caso venha relativo (ex: "src/...") ou com prefixo incorreto
+        let fullPath = requestedPath;
+
+        if (!path.isAbsolute(requestedPath) || !requestedPath.startsWith(workspacePath)) {
+            fullPath = path.join(workspacePath, requestedPath.replace(/^\//, ""));
+        }
+
+        fullPath = path.resolve(fullPath);
+
+        console.log(`📄 Attempting to read: ${fullPath}`);
+
+        if (!fs.existsSync(fullPath)) {
+            return res.status(404).json({
+                error: "File not found",
+                receivedPath: requestedPath,
+                resolvedPath: fullPath,
+                workspacePath,
+            });
+        }
+
+        const content = fs.readFileSync(fullPath, "utf8");
+        const stats = fs.statSync(fullPath);
+
+        return res.json({
+            workspacePath,
+            fullPath,
+            relativePath: path.relative(workspacePath, fullPath),
+            size: stats.size,
+            modified: stats.mtime,
+            content,
+        });
+    } catch (err) {
+        console.error("❌ Error reading file:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 5️⃣ POST /workspace/resolve
+// Resolve caminho absoluto do projeto pelo nome da pasta
+// (usado quando o dev escolhe o workspace no Setup Wizard)
+// --------------------------------------------------
+router.post("/resolve", async (req, res) => {
+    try {
+        const { folderName } = req.body;
+        if (!folderName) {
+            return res.status(400).json({ error: "Missing folderName" });
+        }
+
+        const base = path.join(os.homedir(), "Documents", "Projects");
+        const resolved = path.resolve(base, folderName);
+
+        if (!fs.existsSync(resolved)) {
+            return res.status(400).json({ error: `Folder not found: ${resolved}` });
+        }
+
+        workspacePath = resolved;
+        console.log(`🧩 Resolved workspace path: ${workspacePath}`);
+
+        return res.json({ absolutePath: workspacePath });
+    } catch (err) {
+        console.error("❌ Error resolving absolute path:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 6️⃣ GET /workspace/detect
+// Detecta tipo de projeto (Maven / Gradle / Outro)
+// --------------------------------------------------
+router.get("/detect", async (req, res) => {
+    try {
+        if (!workspacePath || !fs.existsSync(workspacePath)) {
+            return res.status(400).json({ error: "Workspace not configured" });
+        }
+
+        const files = fs.readdirSync(workspacePath);
+        const type = files.includes("pom.xml")
+            ? "maven"
+            : files.includes("build.gradle")
+                ? "gradle"
+                : "unknown";
+
+        return res.json({ type, workspacePath });
+    } catch (err) {
+        console.error("❌ Error detecting project type:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// ==========================================
+// ✅ NOVOS ENDPOINTS - Investigation Mode (Sprint 1.1.5)
+// ==========================================
+
+// --------------------------------------------------
+// 🧩 7️⃣ POST /workspace/search-file
+// Busca recursiva por nome de arquivo no workspace
+// Usado pelo InvestigationModeService para encontrar arquivos por hint
+// --------------------------------------------------
+router.post("/search-file", async (req, res) => {
+    try {
+        const { fileName } = req.body;
+
+        if (!fileName) {
+            return res.status(400).json({ error: "Missing fileName" });
+        }
+
+        if (!workspacePath || !fs.existsSync(workspacePath)) {
+            return res.status(400).json({ error: "Workspace not configured or invalid" });
+        }
+
+        console.log(`🔍 [search-file] Searching for: ${fileName} in ${workspacePath}`);
+
+        let foundPath = null;
+        const matches = [];
+
+        // Função de busca recursiva
+        function searchRecursive(dir, depth = 0) {
+            if (depth > 10 || foundPath) return; // Limitar profundidade
+
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    // Ignorar diretórios comuns
+                    if (entry.name.startsWith('.') ||
+                        entry.name === 'node_modules' ||
+                        entry.name === 'target' ||
+                        entry.name === 'build' ||
+                        entry.name === '.git') {
+                        continue;
+                    }
+
+                    const fullPath = path.join(dir, entry.name);
+
+                    if (entry.isDirectory()) {
+                        searchRecursive(fullPath, depth + 1);
+                    } else if (entry.isFile()) {
+                        // Match exato ou parcial
+                        if (entry.name === fileName ||
+                            entry.name.toLowerCase() === fileName.toLowerCase()) {
+                            foundPath = path.relative(workspacePath, fullPath);
+                            matches.push({
+                                path: foundPath,
+                                matchType: 'exact'
+                            });
+                        } else if (entry.name.includes(fileName.replace('.java', ''))) {
+                            matches.push({
+                                path: path.relative(workspacePath, fullPath),
+                                matchType: 'partial'
+                            });
+                        }
+                    }
+                }
+            } catch (err) {
+                // Ignorar erros de permissão
+                console.warn(`⚠️ Cannot read directory: ${dir}`);
+            }
+        }
+
+        searchRecursive(workspacePath);
+
+        if (foundPath) {
+            console.log(`✅ [search-file] Found: ${foundPath}`);
+            return res.json({
+                found: true,
+                path: foundPath,
+                matches: matches.slice(0, 10) // Limitar matches
+            });
+        }
+
+        // Se não encontrou match exato, retornar matches parciais
+        if (matches.length > 0) {
+            console.log(`🔶 [search-file] Partial matches found: ${matches.length}`);
+            return res.json({
+                found: true,
+                path: matches[0].path,
+                matches: matches.slice(0, 10)
+            });
+        }
+
+        console.log(`❌ [search-file] Not found: ${fileName}`);
+        return res.json({ found: false, matches: [] });
+
+    } catch (err) {
+        console.error("❌ Error searching file:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 8️⃣ GET /workspace/recent-files
+// Lista arquivos recentemente modificados
+// Usado pelo InvestigationModeService como última estratégia
+// --------------------------------------------------
+router.get("/recent-files", async (req, res) => {
+    try {
+        const limit = parseInt(req.query.limit) || 10;
+
+        if (!workspacePath || !fs.existsSync(workspacePath)) {
+            return res.status(400).json({ error: "Workspace not configured or invalid" });
+        }
+
+        console.log(`🕐 [recent-files] Getting ${limit} recent files from ${workspacePath}`);
+
+        const allFiles = [];
+
+        // Coletar todos os arquivos com data de modificação
+        function collectFiles(dir, depth = 0) {
+            if (depth > 5) return; // Limitar profundidade
+
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    // Ignorar diretórios comuns
+                    if (entry.name.startsWith('.') ||
+                        entry.name === 'node_modules' ||
+                        entry.name === 'target' ||
+                        entry.name === 'build' ||
+                        entry.name === '.git') {
+                        continue;
+                    }
+
+                    const fullPath = path.join(dir, entry.name);
+
+                    if (entry.isDirectory()) {
+                        collectFiles(fullPath, depth + 1);
+                    } else if (entry.isFile() &&
+                        (entry.name.endsWith('.java') ||
+                            entry.name.endsWith('.js') ||
+                            entry.name.endsWith('.ts'))) {
+                        try {
+                            const stats = fs.statSync(fullPath);
+                            allFiles.push({
+                                path: path.relative(workspacePath, fullPath),
+                                name: entry.name,
+                                modified: stats.mtime,
+                                size: stats.size
+                            });
+                        } catch (e) {
+                            // Ignorar arquivos que não podem ser lidos
+                        }
+                    }
+                }
+            } catch (err) {
+                // Ignorar erros de permissão
+            }
+        }
+
+        collectFiles(workspacePath);
+
+        // Ordenar por data de modificação (mais recente primeiro)
+        allFiles.sort((a, b) => b.modified - a.modified);
+
+        // Retornar apenas os N mais recentes
+        const recentFiles = allFiles.slice(0, limit);
+
+        console.log(`✅ [recent-files] Returning ${recentFiles.length} files`);
+
+        return res.json({
+            workspacePath,
+            total: allFiles.length,
+            files: recentFiles
+        });
+
+    } catch (err) {
+        console.error("❌ Error getting recent files:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 9️⃣ GET /workspace/scan
+// Escaneia workspace completo com metadados
+// Usado pelo SmartFileDetectionService para análise com AI
+// --------------------------------------------------
+router.get("/scan", async (req, res) => {
+    try {
+        if (!workspacePath || !fs.existsSync(workspacePath)) {
+            return res.status(400).json({ error: "Workspace not configured or invalid" });
+        }
+
+        console.log(`📂 [scan] Scanning workspace: ${workspacePath}`);
+
+        const files = [];
+        const languages = new Set();
+        let totalFiles = 0;
+
+        // Mapeamento de extensão para linguagem
+        const extensionMap = {
+            '.java': 'Java',
+            '.js': 'JavaScript',
+            '.ts': 'TypeScript',
+            '.py': 'Python',
+            '.go': 'Go',
+            '.rs': 'Rust',
+            '.kt': 'Kotlin',
+            '.scala': 'Scala',
+            '.rb': 'Ruby',
+            '.php': 'PHP',
+            '.cs': 'C#',
+            '.cpp': 'C++',
+            '.c': 'C'
+        };
+
+        function scanRecursive(dir, depth = 0) {
+            if (depth > 6) return; // Limitar profundidade
+
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    // Ignorar diretórios comuns
+                    if (entry.name.startsWith('.') ||
+                        entry.name === 'node_modules' ||
+                        entry.name === 'target' ||
+                        entry.name === 'build' ||
+                        entry.name === '.git' ||
+                        entry.name === '__pycache__') {
+                        continue;
+                    }
+
+                    const fullPath = path.join(dir, entry.name);
+
+                    if (entry.isDirectory()) {
+                        scanRecursive(fullPath, depth + 1);
+                    } else if (entry.isFile()) {
+                        const ext = path.extname(entry.name).toLowerCase();
+
+                        // Verificar se é arquivo de código
+                        if (extensionMap[ext]) {
+                            languages.add(extensionMap[ext]);
+                            totalFiles++;
+
+                            // Limitar arquivos retornados para não estourar memória
+                            if (files.length < 200) {
+                                try {
+                                    const stats = fs.statSync(fullPath);
+                                    files.push({
+                                        path: path.relative(workspacePath, fullPath),
+                                        name: entry.name,
+                                        language: extensionMap[ext],
+                                        size: stats.size,
+                                        modified: stats.mtime
+                                    });
+                                } catch (e) {
+                                    // Ignorar
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                // Ignorar erros de permissão
+            }
+        }
+
+        scanRecursive(workspacePath);
+
+        console.log(`✅ [scan] Found ${totalFiles} files in ${languages.size} languages`);
+
+        return res.json({
+            workspacePath,
+            files,
+            metadata: {
+                totalFiles,
+                languages: Array.from(languages),
+                scannedAt: new Date().toISOString()
+            }
+        });
+
+    } catch (err) {
+        console.error("❌ Error scanning workspace:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+// --------------------------------------------------
+// 🧩 🔟 GET /workspace/file-content
+// Alias para /workspace/file (compatibilidade com código Java)
+// --------------------------------------------------
+router.get("/file-content", async (req, res) => {
+    try {
+        const { path: requestedPath } = req.query;
+
+        if (!requestedPath) {
+            return res.status(400).json({ error: "Missing 'path' query parameter" });
+        }
+
+        let fullPath = requestedPath;
+
+        if (!path.isAbsolute(requestedPath) || !requestedPath.startsWith(workspacePath)) {
+            fullPath = path.join(workspacePath, requestedPath.replace(/^\//, ""));
+        }
+
+        fullPath = path.resolve(fullPath);
+
+        console.log(`📄 [file-content] Reading: ${fullPath}`);
+
+        if (!fs.existsSync(fullPath)) {
+            return res.status(404).json({
+                error: "File not found",
+                path: requestedPath
+            });
+        }
+
+        const content = fs.readFileSync(fullPath, "utf8");
+
+        return res.json({
+            content,
+            path: path.relative(workspacePath, fullPath)
+        });
+
+    } catch (err) {
+        console.error("❌ Error reading file content:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
+export default router;