deepdebug-local-agent 1.0.10 → 1.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepdebug-local-agent",
-  "version": "1.0.10",
+  "version": "1.0.11",
   "description": "DeepDebug Local Agent - AI-powered code debugging assistant",
   "private": false,
   "type": "module",

package/src/routes/workspace.route.js

@@ -6,10 +6,87 @@ import os from "os";
 const router = express.Router();
 
 // 🔹 Caminho global do workspace (inicializado com fallback padrão)
+// ✅ FIX: Read WORKSPACE_ROOT (set by install.js Docker) OR WORKSPACE_BASE (legacy)
 let workspacePath =
+    process.env.WORKSPACE_ROOT ||
     process.env.WORKSPACE_BASE ||
     path.join(os.homedir(), "Documents", "Projects");
 
+// 🆕 Host→Docker path translation
+// When Gateway sends host paths (C:\Users\willi\Projects\my-app),
+// we need to translate them to Docker paths (/workspace/my-app)
+const WORKSPACE_MOUNT = process.env.WORKSPACE_ROOT || "/workspace";
+const HOST_PROJECTS_PATH = process.env.HOST_PROJECTS_PATH || null;
+
+console.log(`📂 [workspace_route] Initialized with workspacePath: ${workspacePath}`);
+console.log(`📂 [workspace_route] WORKSPACE_MOUNT: ${WORKSPACE_MOUNT}`);
+console.log(`📂 [workspace_route] HOST_PROJECTS_PATH: ${HOST_PROJECTS_PATH || 'not set'}`);
+
+/**
+ * Translates a host-side path to the Docker container path.
+ *
+ * Examples:
+ *   C:\Users\willi\Documents\Projects\pure-core-ms → /workspace/pure-core-ms
+ *   /Users/macintosh/IdeaProjects/pure-core-ms     → /workspace/pure-core-ms
+ *   /workspace/pure-core-ms                        → /workspace/pure-core-ms (unchanged)
+ *   src/main/java/...                              → src/main/java/... (relative, unchanged)
+ */
+function translateToDockerPath(hostPath) {
+    if (!hostPath) return workspacePath;
+
+    // Normalize path separators (Windows → Unix)
+    let normalized = hostPath.replace(/\\/g, '/');
+
+    // Already a Docker path
+    if (normalized.startsWith('/workspace')) {
+        return normalized;
+    }
+
+    // Relative path (like src/main/java/...) - not a workspace root
+    if (!path.isAbsolute(normalized) && !normalized.match(/^[A-Za-z]:/)) {
+        return normalized;
+    }
+
+    // If we know the host projects root, strip it
+    if (HOST_PROJECTS_PATH) {
+        const normalizedHost = HOST_PROJECTS_PATH.replace(/\\/g, '/').replace(/\/$/, '');
+        if (normalized.toLowerCase().startsWith(normalizedHost.toLowerCase())) {
+            const relative = normalized.substring(normalizedHost.length).replace(/^\//, '');
+            const dockerPath = path.posix.join(WORKSPACE_MOUNT, relative);
+            console.log(`📂 [translate] ${hostPath} → ${dockerPath} (via HOST_PROJECTS_PATH)`);
+            return dockerPath;
+        }
+    }
+
+    // Smart detection: look for common project root patterns
+    const projectRootPatterns = [
+        /.*[/\\](Documents[/\\]Projects)[/\\]/i,
+        /.*[/\\](IdeaProjects)[/\\]/i,
+        /.*[/\\](source[/\\]repos)[/\\]/i,
+        /.*[/\\](Projects)[/\\]/i,
+        /.*[/\\](repos)[/\\]/i,
+        /.*[/\\](dev)[/\\]/i,
+        /.*[/\\](code)[/\\]/i,
+    ];
+
+    for (const pattern of projectRootPatterns) {
+        const match = normalized.match(pattern);
+        if (match) {
+            const afterRoot = normalized.substring(match.index + match[0].length);
+            const dockerPath = path.posix.join(WORKSPACE_MOUNT, afterRoot);
+            console.log(`📂 [translate] ${hostPath} → ${dockerPath} (via pattern: ${match[1]})`);
+            return dockerPath;
+        }
+    }
+
+    // Last resort: extract the last folder name
+    const parts = normalized.replace(/\/$/, '').split('/');
+    const projectName = parts[parts.length - 1];
+    const dockerPath = path.posix.join(WORKSPACE_MOUNT, projectName);
+    console.log(`📂 [translate] ${hostPath} → ${dockerPath} (via last folder name)`);
+    return dockerPath;
+}
+
 // --------------------------------------------------
 // 🧩 1️⃣ GET /workspace/info
 // Retorna informações sobre o workspace atual
@@ -22,6 +99,11 @@ router.get("/info", async (req, res) => {
             isDirectory: fs.existsSync(workspacePath)
                 ? fs.lstatSync(workspacePath).isDirectory()
                 : false,
+            env: {
+                WORKSPACE_ROOT: process.env.WORKSPACE_ROOT || null,
+                WORKSPACE_BASE: process.env.WORKSPACE_BASE || null,
+                HOST_PROJECTS_PATH: process.env.HOST_PROJECTS_PATH || null,
+            }
         });
     } catch (err) {
         console.error("❌ Error reading workspace info:", err);
@@ -29,20 +111,246 @@ router.get("/info", async (req, res) => {
     }
 });
 
+// --------------------------------------------------
+// 🆕 POST /workspace/open
+// Gateway Java (LocalAgentClient.ensureActiveWorkspaceOpen) calls this
+//
+// TWO MODES:
+// 1. LOCAL MODE:  { "root": "/host/path/to/project" }
+//    → Translates host paths to Docker container paths (for Docker local)
+//
+// 2. CLOUD MODE:  { "repoUrl": "https://github.com/org/repo", "token": "ghp_xxx", "branch": "main" }
+//    → Clones the repo via git (for Cloud Run — no local filesystem)
+//    → Caches in /tmp/workspaces/{repoName} to avoid re-cloning
+// --------------------------------------------------
+
+// Git clone cache directory (survives between requests in same Cloud Run instance)
+const WORKSPACE_CACHE = process.env.WORKSPACE_CACHE || '/tmp/workspaces';
+
+/**
+ * Execute a shell command and return { stdout, stderr, exitCode }
+ */
+function execAsync(cmd, options = {}) {
+    const { execSync } = require('child_process');
+    try {
+        const stdout = execSync(cmd, {
+            encoding: 'utf8',
+            timeout: options.timeout || 120000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            ...options
+        });
+        return { stdout: stdout.trim(), stderr: '', exitCode: 0 };
+    } catch (err) {
+        return {
+            stdout: err.stdout ? err.stdout.toString().trim() : '',
+            stderr: err.stderr ? err.stderr.toString().trim() : err.message,
+            exitCode: err.status || 1
+        };
+    }
+}
+
+/**
+ * Clone or update a git repository.
+ * Returns the local path where the repo is checked out.
+ */
+async function ensureRepoCloned(repoUrl, token, branch = 'main') {
+    // Extract repo name from URL
+    let repoName = repoUrl.split('/').pop().replace('.git', '');
+    // Include org for uniqueness: org/repo → org_repo
+    const urlParts = repoUrl.replace(/\.git$/, '').split('/');
+    if (urlParts.length >= 2) {
+        const org = urlParts[urlParts.length - 2];
+        repoName = `${org}_${repoName}`;
+    }
+
+    const clonePath = path.join(WORKSPACE_CACHE, repoName);
+
+    // Ensure cache directory exists
+    if (!fs.existsSync(WORKSPACE_CACHE)) {
+        fs.mkdirSync(WORKSPACE_CACHE, { recursive: true });
+        console.log(`📁 Created workspace cache: ${WORKSPACE_CACHE}`);
+    }
+
+    // Build authenticated URL if token provided
+    const authUrl = token
+        ? repoUrl.replace('https://', `https://x-access-token:${token}@`)
+        : repoUrl;
+
+    if (fs.existsSync(path.join(clonePath, '.git'))) {
+        // Already cloned → git fetch + checkout + pull
+        console.log(`📂 [git] Repo already cloned: ${clonePath}, updating...`);
+
+        // Fetch latest
+        let result = execAsync(`git fetch origin`, { cwd: clonePath });
+        if (result.exitCode !== 0) {
+            // Try with token in remote URL
+            execAsync(`git remote set-url origin "${authUrl}"`, { cwd: clonePath });
+            result = execAsync(`git fetch origin`, { cwd: clonePath });
+        }
+
+        // Checkout correct branch
+        execAsync(`git checkout ${branch} 2>/dev/null || git checkout -b ${branch} origin/${branch}`, { cwd: clonePath });
+
+        // Reset to remote (discard any local patches from previous fixes)
+        execAsync(`git reset --hard origin/${branch}`, { cwd: clonePath });
+
+        console.log(`✅ [git] Updated to latest ${branch}: ${clonePath}`);
+    } else {
+        // Fresh clone
+        console.log(`📂 [git] Cloning ${repoUrl} (branch: ${branch})...`);
+
+        const result = execAsync(
+            `git clone --branch ${branch} --single-branch --depth 50 "${authUrl}" "${clonePath}"`,
+            { timeout: 180000 }  // 3 minutes for large repos
+        );
+
+        if (result.exitCode !== 0) {
+            throw new Error(`Git clone failed: ${result.stderr}`);
+        }
+
+        // Configure git user for future commits
+        execAsync(`git config user.email "deepdebug-ai@deepdebug.ai"`, { cwd: clonePath });
+        execAsync(`git config user.name "DeepDebug AI"`, { cwd: clonePath });
+
+        // Store the authenticated remote URL for future push
+        if (token) {
+            execAsync(`git remote set-url origin "${authUrl}"`, { cwd: clonePath });
+        }
+
+        console.log(`✅ [git] Cloned successfully: ${clonePath}`);
+    }
+
+    return clonePath;
+}
+
+router.post("/open", async (req, res) => {
+    try {
+        const { root, workspacePath: wpPath, repoUrl, token, branch = 'main' } = req.body;
+
+        // ==========================================
+        // CLOUD MODE: Git clone
+        // ==========================================
+        if (repoUrl) {
+            console.log(`📂 [/workspace/open] CLOUD MODE — cloning ${repoUrl} (branch: ${branch})`);
+
+            try {
+                const clonePath = await ensureRepoCloned(repoUrl, token, branch);
+
+                // Detect project type
+                const files = fs.readdirSync(clonePath);
+                let language = "unknown", buildTool = "unknown", marker = null;
+                if (files.includes("pom.xml")) { language = "java"; buildTool = "maven"; marker = "pom.xml"; }
+                else if (files.includes("build.gradle") || files.includes("build.gradle.kts")) { language = "java"; buildTool = "gradle"; marker = "build.gradle"; }
+                else if (files.includes("package.json")) { language = "node"; buildTool = "npm"; marker = "package.json"; }
+                else if (files.includes("requirements.txt") || files.includes("setup.py")) { language = "python"; buildTool = "pip"; marker = "requirements.txt"; }
+                else if (files.includes("go.mod")) { language = "go"; buildTool = "go"; marker = "go.mod"; }
+                else if (files.some(f => f.endsWith(".csproj"))) { language = "csharp"; buildTool = "dotnet"; marker = ".csproj"; }
+
+                workspacePath = clonePath;
+                console.log(`✅ [/workspace/open] Cloud workspace set to: ${workspacePath} (${language}/${buildTool})`);
+
+                return res.json({
+                    ok: true,
+                    root: workspacePath,
+                    mode: "cloud-clone",
+                    meta: { language, buildTool, marker },
+                    port: null
+                });
+            } catch (gitErr) {
+                console.error(`❌ [/workspace/open] Git clone failed:`, gitErr.message);
+                return res.status(500).json({
+                    ok: false,
+                    error: `Git clone failed: ${gitErr.message}`,
+                    hint: "Check that the repository URL and token are correct."
+                });
+            }
+        }
+
+        // ==========================================
+        // LOCAL MODE: Path-based (Docker local)
+        // ==========================================
+        const requestedPath = root || wpPath;
+
+        if (!requestedPath) {
+            return res.status(400).json({ error: "Missing 'root', 'workspacePath', or 'repoUrl' in body" });
+        }
+
+        // Translate host path to docker path if needed
+        let resolvedPath = translateToDockerPath(requestedPath);
+        resolvedPath = path.resolve(resolvedPath);
+
+        console.log(`📂 [/workspace/open] LOCAL MODE — Requested: ${requestedPath}`);
+        console.log(`📂 [/workspace/open] Resolved:  ${resolvedPath}`);
+
+        if (!fs.existsSync(resolvedPath) || !fs.lstatSync(resolvedPath).isDirectory()) {
+            // If translated path doesn't exist, try the raw path as fallback
+            const rawResolved = path.resolve(requestedPath.replace(/\\/g, '/'));
+            if (fs.existsSync(rawResolved) && fs.lstatSync(rawResolved).isDirectory()) {
+                resolvedPath = rawResolved;
+                console.log(`📂 [/workspace/open] Fallback to raw path: ${resolvedPath}`);
+            } else {
+                // List what IS in /workspace to help debug
+                let availableDirs = [];
+                try {
+                    if (fs.existsSync(WORKSPACE_MOUNT)) {
+                        availableDirs = fs.readdirSync(WORKSPACE_MOUNT, { withFileTypes: true })
+                            .filter(d => d.isDirectory())
+                            .map(d => d.name);
+                    }
+                } catch (e) {}
+
+                console.error(`❌ [/workspace/open] Directory not found: ${resolvedPath}`);
+                return res.status(400).json({
+                    error: `Directory not found: ${resolvedPath}`,
+                    requestedPath, resolvedPath,
+                    availableProjects: availableDirs,
+                    hint: "The workspace path might not be mounted in Docker. Check docker -v mount."
+                });
+            }
+        }
+
+        // Detect project type
+        const files = fs.readdirSync(resolvedPath);
+        let language = "unknown", buildTool = "unknown", marker = null;
+        if (files.includes("pom.xml")) { language = "java"; buildTool = "maven"; marker = "pom.xml"; }
+        else if (files.includes("build.gradle") || files.includes("build.gradle.kts")) { language = "java"; buildTool = "gradle"; marker = "build.gradle"; }
+        else if (files.includes("package.json")) { language = "node"; buildTool = "npm"; marker = "package.json"; }
+        else if (files.includes("requirements.txt") || files.includes("setup.py")) { language = "python"; buildTool = "pip"; marker = "requirements.txt"; }
+        else if (files.includes("go.mod")) { language = "go"; buildTool = "go"; marker = "go.mod"; }
+
+        workspacePath = resolvedPath;
+        console.log(`✅ [/workspace/open] Local workspace set to: ${workspacePath} (${language}/${buildTool})`);
+
+        return res.json({
+            ok: true,
+            root: workspacePath,
+            mode: "local",
+            meta: { language, buildTool, marker },
+            port: null
+        });
+    } catch (err) {
+        console.error("❌ [/workspace/open] Error:", err);
+        return res.status(500).json({ error: err.message });
+    }
+});
+
 // --------------------------------------------------
 // 🧩 2️⃣ POST /workspace
 // Atualiza o diretório de workspace selecionado pelo usuário
+// (legacy endpoint - kept for backward compatibility)
 // --------------------------------------------------
 router.post("/", async (req, res) => {
     try {
         console.log(workspacePath)
-        const { workspacePath: newPath } = req.body;
-        if (!newPath) {
-            return res.status(400).json({ error: "Missing workspacePath" });
+        const { workspacePath: newPath, root } = req.body;
+        const requestedPath = newPath || root;
+        if (!requestedPath) {
+            return res.status(400).json({ error: "Missing workspacePath or root" });
         }
 
-        // 🔹 Resolve o caminho completo (garante formato absoluto)
-        const resolvedPath = path.resolve(newPath);
+        // Translate host path if in Docker
+        let resolvedPath = translateToDockerPath(requestedPath);
+        resolvedPath = path.resolve(resolvedPath);
 
         if (!fs.existsSync(resolvedPath) || !fs.lstatSync(resolvedPath).isDirectory()) {
             return res
@@ -78,9 +386,27 @@ router.get("/files", async (req, res) => {
             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);
+                    if (
+                        !["node_modules", ".git", "target", "build", ".idea"].includes(
+                            entry.name
+                        )
+                    ) {
+                        walk(fullPath, depth + 1);
+                    }
+                } else if (
+                    entry.name.endsWith(".java") ||
+                    entry.name.endsWith(".js") ||
+                    entry.name.endsWith(".ts") ||
+                    entry.name.endsWith(".py") ||
+                    entry.name.endsWith(".go") ||
+                    entry.name.endsWith(".cs") ||
+                    entry.name.endsWith(".xml") ||
+                    entry.name.endsWith(".yml") ||
+                    entry.name.endsWith(".yaml") ||
+                    entry.name.endsWith(".json") ||
+                    entry.name.endsWith(".properties")
+                ) {
+                    files.push(path.relative(workspacePath, fullPath));
                 }
             }
         }
@@ -88,7 +414,7 @@ router.get("/files", async (req, res) => {
         walk(workspacePath);
         return res.json({ workspacePath, files });
     } catch (err) {
-        console.error("❌ Error listing files:", err);
+        console.error("❌ Error listing workspace files:", err);
         return res.status(500).json({ error: err.message });
     }
 });
@@ -144,8 +470,7 @@ router.get("/file", async (req, res) => {
 
 // --------------------------------------------------
 // 🧩 5️⃣ POST /workspace/resolve
-// Resolve caminho absoluto do projeto pelo nome da pasta
-// (usado quando o dev escolhe o workspace no Setup Wizard)
+// Resolve caminho relativo a absoluto (para exibição no frontend)
 // --------------------------------------------------
 router.post("/resolve", async (req, res) => {
     try {
@@ -200,94 +525,62 @@ router.get("/detect", async (req, res) => {
 // ==========================================
 
 // --------------------------------------------------
-// 🧩 7️⃣ POST /workspace/search-file
-// Busca recursiva por nome de arquivo no workspace
-// Usado pelo InvestigationModeService para encontrar arquivos por hint
+// 🧩 7️⃣ GET /workspace/search-file
+// Busca um arquivo pelo nome dentro do workspace
 // --------------------------------------------------
-router.post("/search-file", async (req, res) => {
+router.get("/search-file", async (req, res) => {
     try {
-        const { fileName } = req.body;
-
+        const { fileName } = req.query;
         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" });
+            return res.status(400).json({ error: "Workspace not configured" });
         }
 
         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
+        const alternatives = [];
 
+        function searchFile(dir, depth = 0) {
+            if (depth > 10 || foundPath) return;
             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;
-                    }
-
+                    if (foundPath) return;
                     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()) {
+                        if (!["node_modules", ".git", "target", "build", ".idea", ".gradle"].includes(entry.name)) {
+                            searchFile(fullPath, depth + 1);
+                        }
+                    } else {
+                        // Exact match
+                        if (entry.name === fileName || entry.name === path.basename(fileName)) {
                             foundPath = path.relative(workspacePath, fullPath);
-                            matches.push({
-                                path: foundPath,
-                                matchType: 'exact'
-                            });
-                        } else if (entry.name.includes(fileName.replace('.java', ''))) {
-                            matches.push({
+                        }
+                        // Partial match for alternatives
+                        else if (entry.name.toLowerCase().includes(path.basename(fileName).toLowerCase().replace('.java', '').replace('.js', ''))) {
+                            alternatives.push({
                                 path: path.relative(workspacePath, fullPath),
-                                matchType: 'partial'
+                                name: entry.name
                             });
                         }
                     }
                 }
-            } catch (err) {
-                // Ignorar erros de permissão
-                console.warn(`⚠️ Cannot read directory: ${dir}`);
-            }
+            } catch (e) { /* ignore permission errors */ }
         }
 
-        searchRecursive(workspacePath);
+        searchFile(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)
-            });
+            return res.json({ found: true, path: foundPath, alternatives: alternatives.slice(0, 5) });
         }
 
-        console.log(`❌ [search-file] Not found: ${fileName}`);
-        return res.json({ found: false, matches: [] });
+        console.log(`⚠️ [search-file] Not found: ${fileName} (${alternatives.length} alternatives)`);
+        return res.json({ found: false, path: null, alternatives: alternatives.slice(0, 10) });
 
     } catch (err) {
         console.error("❌ Error searching file:", err);
@@ -296,189 +589,129 @@ router.post("/search-file", async (req, res) => {
 });
 
 // --------------------------------------------------
-// 🧩 8️⃣ GET /workspace/recent-files
-// Lista arquivos recentemente modificados
-// Usado pelo InvestigationModeService como última estratégia
+// 🧩 8️⃣ POST /workspace/search
+// Busca por conteúdo dentro dos arquivos do workspace
 // --------------------------------------------------
-router.get("/recent-files", async (req, res) => {
+router.post("/search", async (req, res) => {
     try {
-        const limit = parseInt(req.query.limit) || 10;
+        const { query, filePattern, maxResults = 20 } = req.body;
+        if (!query) {
+            return res.status(400).json({ error: "Missing 'query' in body" });
+        }
 
         if (!workspacePath || !fs.existsSync(workspacePath)) {
-            return res.status(400).json({ error: "Workspace not configured or invalid" });
+            return res.status(400).json({ error: "Workspace not configured" });
         }
 
-        console.log(`🕐 [recent-files] Getting ${limit} recent files from ${workspacePath}`);
-
-        const allFiles = [];
+        console.log(`🔍 [search] Searching for: "${query}" in ${workspacePath}`);
 
-        // Coletar todos os arquivos com data de modificação
-        function collectFiles(dir, depth = 0) {
-            if (depth > 5) return; // Limitar profundidade
+        const results = [];
+        const extensions = ['.java', '.js', '.ts', '.py', '.go', '.cs', '.xml', '.yml', '.yaml', '.json', '.properties', '.html', '.css'];
 
+        function searchContent(dir, depth = 0) {
+            if (depth > 8 || results.length >= maxResults) return;
             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;
-                    }
-
+                    if (results.length >= maxResults) return;
                     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
+                        if (!["node_modules", ".git", "target", "build", ".idea", ".gradle", "__pycache__"].includes(entry.name)) {
+                            searchContent(fullPath, depth + 1);
                         }
+                    } else if (extensions.some(ext => entry.name.endsWith(ext))) {
+                        if (filePattern && !entry.name.match(new RegExp(filePattern, 'i'))) continue;
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf8');
+                            const lines = content.split('\n');
+                            for (let i = 0; i < lines.length; i++) {
+                                if (lines[i].includes(query)) {
+                                    results.push({
+                                        file: path.relative(workspacePath, fullPath),
+                                        line: i + 1,
+                                        content: lines[i].trim().substring(0, 200),
+                                        context: lines.slice(Math.max(0, i - 2), Math.min(lines.length, i + 3)).join('\n')
+                                    });
+                                    if (results.length >= maxResults) return;
+                                }
+                            }
+                        } catch (e) { /* ignore read errors */ }
                     }
                 }
-            } catch (err) {
-                // Ignorar erros de permissão
-            }
+            } catch (e) { /* ignore permission errors */ }
         }
 
-        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);
+        searchContent(workspacePath);
 
-        console.log(`✅ [recent-files] Returning ${recentFiles.length} files`);
-
-        return res.json({
-            workspacePath,
-            total: allFiles.length,
-            files: recentFiles
-        });
+        console.log(`✅ [search] Found ${results.length} matches`);
+        return res.json({ query, results, total: results.length });
 
     } catch (err) {
-        console.error("❌ Error getting recent files:", err);
+        console.error("❌ Error searching:", 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
+// Lista TODOS os arquivos do workspace (para list_files tool)
 // --------------------------------------------------
 router.get("/scan", async (req, res) => {
     try {
         if (!workspacePath || !fs.existsSync(workspacePath)) {
-            return res.status(400).json({ error: "Workspace not configured or invalid" });
+            return res.status(400).json({ error: "Workspace not configured" });
         }
 
-        console.log(`📂 [scan] Scanning workspace: ${workspacePath}`);
+        const { directory, pattern, maxDepth = 5 } = req.query;
+        const scanRoot = directory ? path.join(workspacePath, directory) : 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'
-        };
+        if (!fs.existsSync(scanRoot)) {
+            return res.status(404).json({ error: `Directory not found: ${directory || '/'}` });
+        }
+
+        console.log(`📂 [scan] Scanning: ${scanRoot} (maxDepth: ${maxDepth})`);
 
-        function scanRecursive(dir, depth = 0) {
-            if (depth > 6) return; // Limitar profundidade
+        const files = [];
+        const dirs = [];
 
+        function scan(dir, depth = 0) {
+            if (depth > parseInt(maxDepth)) return;
             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);
-
+                    const relativePath = path.relative(workspacePath, fullPath);
                     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
-                                }
+                        if (!["node_modules", ".git", "target", "build", ".idea", ".gradle", "__pycache__", ".next"].includes(entry.name)) {
+                            dirs.push(relativePath);
+                            scan(fullPath, depth + 1);
+                        }
+                    } else {
+                        if (pattern) {
+                            if (entry.name.match(new RegExp(pattern, 'i'))) {
+                                files.push(relativePath);
                             }
+                        } else {
+                            files.push(relativePath);
                         }
                     }
                 }
-            } catch (err) {
-                // Ignorar erros de permissão
-            }
+            } catch (e) { /* ignore */ }
         }
 
-        scanRecursive(workspacePath);
-
-        console.log(`✅ [scan] Found ${totalFiles} files in ${languages.size} languages`);
+        scan(scanRoot);
 
         return res.json({
+            root: directory || '/',
             workspacePath,
-            files,
-            metadata: {
-                totalFiles,
-                languages: Array.from(languages),
-                scannedAt: new Date().toISOString()
-            }
+            files: files.slice(0, 500),
+            directories: dirs,
+            totalFiles: files.length,
+            truncated: files.length > 500
         });
 
     } catch (err) {
-        console.error("❌ Error scanning workspace:", err);
+        console.error("❌ Error scanning:", err);
         return res.status(500).json({ error: err.message });
     }
 });
@@ -508,7 +741,9 @@ router.get("/file-content", async (req, res) => {
         if (!fs.existsSync(fullPath)) {
             return res.status(404).json({
                 error: "File not found",
-                path: requestedPath
+                path: requestedPath,
+                resolvedPath: fullPath,
+                workspacePath,
             });
         }
 

package/src/server.js

@@ -717,8 +717,92 @@ app.get("/health", (_req, res) => {
 
 /** Define/abre o workspace local */
 app.post("/workspace/open", async (req, res) => {
-    const { root, workspaceId } = req.body || {};
-    if (!root) return res.status(400).json({ error: "root is required" });
+    const { root, workspaceId, repoUrl, token, branch = "main" } = req.body || {};
+
+    // ==========================================
+    // CLOUD MODE: Git clone (when Gateway sends repoUrl)
+    // ==========================================
+    if (repoUrl) {
+        console.log(`📂 [/workspace/open] CLOUD MODE — cloning ${repoUrl} (branch: ${branch})`);
+
+        try {
+            // Extract repo name: https://github.com/org/repo → org_repo
+            let repoName = repoUrl.split('/').pop().replace('.git', '');
+            const urlParts = repoUrl.replace(/\.git$/, '').split('/');
+            if (urlParts.length >= 2) {
+                const org = urlParts[urlParts.length - 2];
+                repoName = `${org}_${repoName}`;
+            }
+
+            const cacheDir = process.env.WORKSPACE_CACHE || '/tmp/workspaces';
+            const clonePath = path.join(cacheDir, repoName);
+
+            // Ensure cache directory exists
+            await fsPromises.mkdir(cacheDir, { recursive: true });
+
+            // Build authenticated URL
+            const authUrl = token
+                ? repoUrl.replace('https://', `https://x-access-token:${token}@`)
+                : repoUrl;
+
+            const gitDir = path.join(clonePath, '.git');
+            const alreadyCloned = await exists(gitDir);
+
+            if (alreadyCloned) {
+                console.log(`🔄 [cloud] Repo exists: ${clonePath}, updating...`);
+                // Update remote URL with fresh token
+                await execAsync(`git remote set-url origin "${authUrl}"`, { cwd: clonePath }).catch(() => {});
+                await execAsync(`git fetch origin`, { cwd: clonePath, timeout: 120000 });
+                // Checkout correct branch and reset to remote (discard previous patches)
+                await execAsync(`git checkout ${branch} 2>/dev/null || git checkout -b ${branch} origin/${branch}`, { cwd: clonePath }).catch(() => {});
+                await execAsync(`git reset --hard origin/${branch}`, { cwd: clonePath });
+                console.log(`✅ [cloud] Updated to latest ${branch}`);
+            } else {
+                console.log(`🔽 [cloud] Cloning ${repoUrl} (branch: ${branch})...`);
+                await execAsync(
+                    `git clone --branch ${branch} --single-branch --depth 50 "${authUrl}" "${clonePath}"`,
+                    { timeout: 300000 }
+                );
+                // Configure git user for future commits
+                await execAsync(`git config user.email "deepdebug-ai@deepdebug.ai"`, { cwd: clonePath });
+                await execAsync(`git config user.name "DeepDebug AI"`, { cwd: clonePath });
+                console.log(`✅ [cloud] Cloned successfully: ${clonePath}`);
+            }
+
+            // Set as active workspace
+            WORKSPACE_ROOT = clonePath;
+            const wsId = workspaceId || "default";
+            try { await wsManager.open(wsId, clonePath); } catch (err) {
+                console.warn(`⚠️ WorkspaceManager.open failed (non-fatal): ${err.message}`);
+            }
+
+            const meta = await detectProject(clonePath);
+            const port = await detectPort(clonePath);
+
+            return res.json({
+                ok: true,
+                root: WORKSPACE_ROOT,
+                workspaceId: wsId,
+                mode: "cloud-clone",
+                meta,
+                port
+            });
+
+        } catch (gitErr) {
+            console.error(`❌ [cloud] Git clone failed:`, gitErr.message);
+            const hint = gitErr.message.includes('Authentication') || gitErr.message.includes('could not read')
+                ? "Authentication failed. Check token and repo URL."
+                : gitErr.message.includes('not found') || gitErr.message.includes('does not exist')
+                    ? "Repository not found. Check the URL."
+                    : "Clone failed. Ensure the URL is accessible.";
+            return res.status(500).json({ ok: false, error: gitErr.message, hint });
+        }
+    }
+
+    // ==========================================
+    // LOCAL MODE: Path-based (existing behavior)
+    // ==========================================
+    if (!root) return res.status(400).json({ error: "root or repoUrl is required" });
     const abs = path.resolve(root);
     if (!(await exists(abs))) return res.status(404).json({ error: "path not found" });
 
@@ -734,7 +818,7 @@ app.post("/workspace/open", async (req, res) => {
 
     const meta = await detectProject(WORKSPACE_ROOT);
     const port = await detectPort(WORKSPACE_ROOT);
-    res.json({ ok: true, root: WORKSPACE_ROOT, workspaceId: wsId, meta, port });
+    res.json({ ok: true, root: WORKSPACE_ROOT, workspaceId: wsId, mode: "local", meta, port });
 });
 
 /**