deepcode-ai 1.1.2 → 1.1.3

package/dist/index.js

@@ -1657,6 +1657,8 @@ import { Command as Command2 } from "commander";
 
 // ../../packages/core/dist/index.js
 import { Effect } from "effect";
+import { lstat, readdir } from "fs/promises";
+import path2 from "path";
 import { zodToJsonSchema } from "zod-to-json-schema";
 
 // ../../packages/shared/dist/index.js
@@ -2227,20 +2229,20 @@ var SessionTelemetrySchema = z.object({
 
 // ../../packages/core/dist/index.js
 import { z as z2 } from "zod";
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { createInterface } from "readline";
 import { Effect as Effect3 } from "effect";
 import { z as z22 } from "zod";
 import { Effect as Effect2 } from "effect";
 import { createHash } from "crypto";
 import { mkdir as mkdir2, readFile, rm as rm2, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
+import path22 from "path";
 import { mkdir as mkdir22, readFile as readFile2 } from "fs/promises";
 import os from "os";
-import path22 from "path";
+import path3 from "path";
 import { EventEmitter } from "events";
 import { z as z3 } from "zod";
-import { execFile, spawn as spawn2 } from "child_process";
 import { spawn as spawn3 } from "child_process";
 import { URL as URL2 } from "url";
 import { URLSearchParams } from "url";
@@ -2248,27 +2250,27 @@ import { execFile as execFile2 } from "child_process";
 import { z as z4 } from "zod";
 import { spawn as spawn4 } from "child_process";
 import { existsSync } from "fs";
-import path3 from "path";
-import { mkdir as mkdir3, appendFile } from "fs/promises";
 import path4 from "path";
+import { mkdir as mkdir3, appendFile } from "fs/promises";
+import path5 from "path";
 import os2 from "os";
 import { access, realpath } from "fs/promises";
-import path5 from "path";
-import os3 from "os";
 import path6 from "path";
-import { mkdir as mkdir4, readFile as readFile3, readdir } from "fs/promises";
+import os3 from "os";
 import path7 from "path";
+import { mkdir as mkdir4, readFile as readFile3, readdir as readdir2 } from "fs/promises";
+import path8 from "path";
 import { readFile as readFile5 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 import { Effect as Effect4 } from "effect";
 import { z as z5 } from "zod";
-import { mkdir as mkdir6, readFile as readFile6, readdir as readdir3, stat, writeFile as writeFile22 } from "fs/promises";
-import path10 from "path";
+import { lstat as lstat2, mkdir as mkdir6, readFile as readFile6, readdir as readdir4, stat, writeFile as writeFile22 } from "fs/promises";
+import path11 from "path";
 import { Effect as Effect5 } from "effect";
 import { z as z6 } from "zod";
 import { Effect as Effect6 } from "effect";
 import { z as z7 } from "zod";
-import path11 from "path";
+import path12 from "path";
 import { Effect as Effect7 } from "effect";
 import { z as z8 } from "zod";
 import { Effect as Effect8 } from "effect";
@@ -2298,8 +2300,8 @@ var PermissionDeniedError = class extends DeepCodeError {
   }
 };
 var PathNotAllowedError = class extends DeepCodeError {
-  constructor(path12, reason) {
-    super(`Path is not allowed: ${path12}. ${reason}`, "PATH_NOT_ALLOWED");
+  constructor(path13, reason) {
+    super(`Path is not allowed: ${path13}. ${reason}`, "PATH_NOT_ALLOWED");
     this.name = "PathNotAllowedError";
   }
 };
@@ -2525,8 +2527,15 @@ var PlannedTaskSchema = z2.object({
   dependencies: z2.array(z2.string()).default([])
 });
 var PlannedTaskArraySchema = z2.array(PlannedTaskSchema).min(1, "At least one task is required.");
+var READ_ONLY_DISCOVERY_VERB_PATTERN = /\b(?:list|show|find|search|inspect|check|track|listar|mostre|mostrar|busque|buscar|procure|procurar|inspecione|verifique|rastrear|rastreie)\b/i;
+var READ_ONLY_DISCOVERY_NOUN_PATTERN = /\b(?:project|projects|repo|repos|repository|repositories|directory|directories|folder|folders|workspace|projeto|projetos|repositorio|repositorios|diretorio|diretorios|pasta|pastas)\b/i;
+var READ_ONLY_MUTATION_PATTERN = /\b(?:git\s+init|git\s+add|git\s+commit|git\s+push|git\s+tag|git\s+stash|initialize\s+(?:a\s+)?git\s+repository|initialise\s+(?:a\s+)?git\s+repository|create\s+(?:a\s+)?\.?gitignore|stage\s+all\s+files|commit\s+all\s+files)\b/i;
+function isReadOnlyDiscoveryObjective(objective) {
+  return READ_ONLY_DISCOVERY_VERB_PATTERN.test(objective) && READ_ONLY_DISCOVERY_NOUN_PATTERN.test(objective);
+}
 var TaskPlanner = class {
   async plan(objective, complete) {
+    const readOnlyDiscoveryObjective = isReadOnlyDiscoveryObjective(objective);
     const raw = await complete(`Create an execution plan for this coding task.
 Return only JSON in this shape:
 [
@@ -2539,6 +2548,9 @@ Requirements:
 - Type must be one of: research, code, test, verify
 - Dependencies must reference existing task IDs
 - Tasks should be ordered logically
+${readOnlyDiscoveryObjective ? `- This is a read-only discovery request; prefer the fewest inspection steps needed
+- Do not propose initializing git repositories, creating .gitignore, staging files, committing, or pushing
+- Do not propose filesystem mutations for this request` : ""}
 
 Task:
     ${objective}`);
@@ -2555,6 +2567,9 @@ Task:
             throw new Error(`Task "${task.id}" has unknown dependency: "${dep}"`);
           }
         }
+        if (readOnlyDiscoveryObjective && READ_ONLY_MUTATION_PATTERN.test(task.description)) {
+          throw new Error(`Unsafe mutating task in read-only plan: "${task.description}"`);
+        }
       }
       return {
         objective,
@@ -3008,9 +3023,70 @@ function firstObjectField(payload, keys) {
 function collapseFallbackWhitespace(input) {
   return input.replace(/\n{3,}/g, "\n\n").trim();
 }
+function execFileAsync(command, args, options) {
+  return new Promise((resolve3, reject) => {
+    execFile(
+      command,
+      args,
+      {
+        cwd: options.cwd,
+        timeout: options.timeoutMs,
+        signal: options.signal,
+        maxBuffer: 20 * 1024 * 1024,
+        env: { ...process.env, FORCE_COLOR: "1" }
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          const err = error;
+          if (typeof err.code === "number") {
+            resolve3({ stdout, stderr, exitCode: err.code });
+            return;
+          }
+          reject(error);
+          return;
+        }
+        resolve3({ stdout, stderr, exitCode: 0 });
+      }
+    );
+  });
+}
+function runShell(command, options) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn(command, {
+      cwd: options.cwd,
+      shell: true,
+      env: { ...process.env, FORCE_COLOR: "1" },
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => child.kill("SIGKILL"), 1500).unref();
+    }, options.timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      reject(error);
+    });
+    child.on("close", (exitCode) => {
+      clearTimeout(timer);
+      resolve3({ stdout, stderr, exitCode, timedOut });
+    });
+  });
+}
 var DIRECT_SHELL_COMMAND_PATTERN = /^(?:ls|dir|pwd|date|tree|find|rg|grep|cat|stat|wc)\b/i;
 var DIRECT_UTILITY_PATH_PATTERN = /(?:^|\s)(?:~\/|\.{1,2}\/|\/)[^\s]*/;
 var DIRECT_UTILITY_VERB_PATTERN = /\b(?:list|lista|liste|listar|mostre|mostrar|show|display|open|abrir|abra|read|leia|print|imprima|exiba)\b/i;
+var PROJECT_DISCOVERY_VERB_PATTERN = /\b(?:list|lista|liste|listar|show|mostre|mostrar|find|busque|buscar|procure|procurar|track|rastreie|rastrear|scan|escanear|discover|descubra)\b/i;
+var PROJECT_DISCOVERY_NOUN_PATTERN = /\b(?:project|projects|repo|repos|repository|repositories|repositorio|repositorios|projeto|projetos)\b/i;
 var DATE_TIME_QUESTION_PATTERN = /\b(?:que dia e hoje|que dia é hoje|data de hoje|dia de hoje|what day is it|what day is today|today'?s date|current date|que horas sao|que horas são|hora atual|current time|what time is it)\b/i;
 var SIMPLE_SHELL_COMMAND_PATTERN = /^(?:mkdir|touch|rmdir|cp|mv|chmod|chown|echo|ln|git\s+(?:init|clone|add|commit|push|pull|checkout|branch|stash|tag))\b/i;
 var SIMPLE_ACTION_VERB_RE = /^(?:cria|crie|criar|apaga|apague|apagar|deleta|delete|deletar|remove|mova|move|renomeia|renomeie|renomear|create|rename|mkdir|make)\b/;
@@ -3127,6 +3203,11 @@ function parseUtilityRequest(input) {
   if (normalizedInput === "date" || DATE_TIME_QUESTION_PATTERN.test(normalizedInput)) {
     return { kind: "date" };
   }
+  if (PROJECT_DISCOVERY_NOUN_PATTERN.test(normalizedInput) && (PROJECT_DISCOVERY_VERB_PATTERN.test(normalizedInput) || /\bgit\b/i.test(normalizedInput))) {
+    const explicitPathMatch = trimmed.match(/((?:~\/|\.{1,2}\/|\/)[^\s]+)/);
+    const rawPath = explicitPathMatch?.[1]?.trim() || ".";
+    return { kind: "list_projects", path: rawPath, rawPath };
+  }
   const shellListMatch = trimmed.match(/^(?:ls|dir)\s*(.+)?$/i);
   if (shellListMatch) {
     const rawPath = shellListMatch[1]?.trim() || ".";
@@ -3198,7 +3279,9 @@ function utilityDateResponse() {
 }
 function formatUtilityResult(request, result) {
   if (!result.trim()) {
-    return request.kind === "list_dir" ? "Diret\xF3rio vazio." : "Sem sa\xEDda.";
+    if (request.kind === "list_dir") return "Diret\xF3rio vazio.";
+    if (request.kind === "list_projects") return "Nenhum projeto encontrado. Quer versionar alguma pasta?";
+    return "Sem sa\xEDda.";
   }
   if (!result.startsWith("Error running ")) {
     return result;
@@ -3254,6 +3337,9 @@ function isDirectUtilityRequest(input, policy) {
   if (DIRECT_UTILITY_PATH_PATTERN.test(input) && DIRECT_UTILITY_VERB_PATTERN.test(normalizedInput)) {
     return true;
   }
+  if (PROJECT_DISCOVERY_NOUN_PATTERN.test(normalizedInput) && (PROJECT_DISCOVERY_VERB_PATTERN.test(normalizedInput) || /\bgit\b/i.test(normalizedInput))) {
+    return true;
+  }
   return DIRECT_UTILITY_VERB_PATTERN.test(normalizedInput) && (normalizedInput.includes(" directory") || normalizedInput.includes(" folder") || normalizedInput.includes(" pasta") || normalizedInput.includes(" diretorio") || normalizedInput.includes(" documents") || normalizedInput.includes(" documentos") || containsConfiguredTerm(normalizedInput, policy.fileExtensions));
 }
 function containsConfiguredTerm(normalizedInput, terms) {
@@ -3310,6 +3396,22 @@ function resolveExecutionTarget(config, session, mode, explicitProvider) {
   }
   return fallback;
 }
+var PROJECT_MARKER = ".git";
+var PROJECT_DISCOVERY_SKIP_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  ".hg",
+  ".svn",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  "target",
+  "__pycache__",
+  "vendor"
+]);
 var Agent = class {
   constructor(providerManager, tools, sessions, config, cache, permissions, pathSecurity, eventBus) {
     this.providerManager = providerManager;
@@ -4013,6 +4115,26 @@ ${assistantText}` : assistantText;
       });
       return output2;
     }
+    if (request.kind === "list_projects") {
+      try {
+        const output2 = await this.discoverProjects(session, request.path ?? ".");
+        this.sessions.addMessage(session.id, {
+          role: "assistant",
+          source: "assistant",
+          content: formatUtilityResult(request, output2)
+        });
+        return formatUtilityResult(request, output2);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const output2 = `Nao consegui localizar projetos em ${request.rawPath ?? request.path ?? "."}: ${message}`;
+        this.sessions.addMessage(session.id, {
+          role: "assistant",
+          source: "assistant",
+          content: output2
+        });
+        return output2;
+      }
+    }
     const call = {
       id: createId("toolcall"),
       name: "list_dir",
@@ -4039,6 +4161,71 @@ ${assistantText}` : assistantText;
     });
     return output;
   }
+  async discoverProjects(session, inputPath) {
+    if (!await this.isGitAvailable(session.worktree)) {
+      return "Git nao esta instalado. Quer que eu instale?";
+    }
+    const rootPath = await this.pathSecurity.normalize(inputPath, { enforceAccess: false });
+    await this.permissions.ensure({ operation: "list_projects", kind: "read", path: rootPath });
+    const results = [];
+    await this.walkForProjects(rootPath, 3, results, /* @__PURE__ */ new Set());
+    if (results.length === 0) {
+      return "";
+    }
+    const formatted = results.sort((left, right) => left.path.localeCompare(right.path)).map((match) => {
+      const relative2 = path2.relative(rootPath, match.path) || ".";
+      return `${relative2} [${match.markers.join(", ")}]`;
+    });
+    return formatted.join("\n");
+  }
+  async walkForProjects(directory, depthRemaining, results, seen) {
+    if (seen.has(directory) || results.length >= 200) {
+      return;
+    }
+    seen.add(directory);
+    const entries = await readdir(directory, { withFileTypes: true });
+    const markerSet = new Set(
+      entries.filter((entry) => entry.name === PROJECT_MARKER).map((entry) => entry.name)
+    );
+    if (markerSet.size > 0) {
+      results.push({
+        path: directory,
+        markers: Array.from(markerSet).sort()
+      });
+    }
+    if (depthRemaining <= 0) {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      if (PROJECT_DISCOVERY_SKIP_DIRS.has(entry.name) || entry.name.startsWith(".")) {
+        continue;
+      }
+      const fullPath = path2.join(directory, entry.name);
+      try {
+        const info = await lstat(fullPath);
+        if (info.isSymbolicLink()) {
+          continue;
+        }
+        await this.walkForProjects(fullPath, depthRemaining - 1, results, seen);
+      } catch {
+        continue;
+      }
+    }
+  }
+  async isGitAvailable(cwd) {
+    try {
+      const result = await execFileAsync("git", ["--version"], {
+        cwd,
+        timeoutMs: 5e3
+      });
+      return result.exitCode === 0;
+    } catch {
+      return false;
+    }
+  }
   resolveTurnStrategy(input, mode) {
     return resolveTurnStrategy(input, mode, this.config.buildTurnPolicy);
   }
@@ -4080,7 +4267,7 @@ var McpClient = class {
   ready;
   nextId = 1;
   pending = /* @__PURE__ */ new Map();
-  constructor(command, args, env, spawnProcess = spawn) {
+  constructor(command, args, env, spawnProcess = spawn2) {
     this.process = spawnProcess(command, args, {
       stdio: ["pipe", "pipe", "pipe"],
       env: { ...process.env, ...env }
@@ -4325,7 +4512,7 @@ var ToolCache = class {
   async set(namespace, keyParts, value) {
     if (!this.config.cache.enabled) return;
     const key = cacheKey(namespace, keyParts);
-    const dir = path2.join(this.worktree, ".deepcode", "cache");
+    const dir = path22.join(this.worktree, ".deepcode", "cache");
     await mkdir2(dir, { recursive: true });
     const now = Date.now();
     const entry = {
@@ -4338,10 +4525,10 @@ var ToolCache = class {
 `, "utf8");
   }
   async clear() {
-    await rm2(path2.join(this.worktree, ".deepcode", "cache"), { recursive: true, force: true });
+    await rm2(path22.join(this.worktree, ".deepcode", "cache"), { recursive: true, force: true });
   }
   filePath(key) {
-    return path2.join(this.worktree, ".deepcode", "cache", `${key}.json`);
+    return path22.join(this.worktree, ".deepcode", "cache", `${key}.json`);
   }
 };
 function cacheKey(namespace, keyParts) {
@@ -4349,12 +4536,12 @@ function cacheKey(namespace, keyParts) {
 }
 var ConfigLoader = class {
   resolveConfigPath(options) {
-    return options.configPath ? path22.resolve(options.configPath) : path22.join(options.cwd, ".deepcode", "config.json");
+    return options.configPath ? path3.resolve(options.configPath) : path3.join(options.cwd, ".deepcode", "config.json");
   }
   async load(options) {
     const configPath = this.resolveConfigPath(options);
     const rawFile = await this.readOptionalJson(configPath);
-    const cwd = path22.dirname(configPath) === path22.join(path22.resolve(options.cwd), ".deepcode") ? path22.resolve(options.cwd) : path22.dirname(configPath);
+    const cwd = path3.dirname(configPath) === path3.join(path3.resolve(options.cwd), ".deepcode") ? path3.resolve(options.cwd) : path3.dirname(configPath);
     const openrouterApiKeyFile = parseOptionalString(process.env.OPENROUTER_API_KEY_FILE) ?? rawFile.providers?.openrouter?.apiKeyFile;
     const anthropicApiKeyFile = parseOptionalString(process.env.ANTHROPIC_API_KEY_FILE) ?? rawFile.providers?.anthropic?.apiKeyFile;
     const openaiApiKeyFile = parseOptionalString(process.env.OPENAI_API_KEY_FILE) ?? rawFile.providers?.openai?.apiKeyFile;
@@ -4436,14 +4623,14 @@ var ConfigLoader = class {
     if (!parsed.success) {
       throw new ConfigError(`Invalid DeepCode config: ${parsed.error.message}`, parsed.error);
     }
-    await mkdir22(path22.dirname(configPath), { recursive: true });
+    await mkdir22(path3.dirname(configPath), { recursive: true });
     await writeFileAtomic(configPath, `${JSON.stringify(parsed.data, null, 2)}
 `);
     return configPath;
   }
   async init(cwd) {
-    const dir = path22.join(cwd, ".deepcode");
-    const configPath = path22.join(dir, "config.json");
+    const dir = path3.join(cwd, ".deepcode");
+    const configPath = path3.join(dir, "config.json");
     await mkdir22(dir, { recursive: true });
     const config = DeepCodeConfigSchema.parse({});
     await writeFileAtomic(configPath, `${JSON.stringify(config, null, 2)}
@@ -4495,7 +4682,7 @@ function normalizeLabel(value) {
 function resolveUserPath(filePath, cwd) {
   if (!filePath) return void 0;
   const expanded = filePath === "~" ? os.homedir() : filePath.replace(/^~(?=\/|\\)/, os.homedir());
-  return path22.isAbsolute(expanded) ? expanded : path22.resolve(cwd, expanded);
+  return path3.isAbsolute(expanded) ? expanded : path3.resolve(cwd, expanded);
 }
 function parseOptionalBoolean(value) {
   if (value === void 0) return void 0;
@@ -4548,65 +4735,6 @@ var EventBus = class {
     }
   }
 };
-function execFileAsync(command, args, options) {
-  return new Promise((resolve3, reject) => {
-    execFile(
-      command,
-      args,
-      {
-        cwd: options.cwd,
-        timeout: options.timeoutMs,
-        signal: options.signal,
-        maxBuffer: 20 * 1024 * 1024,
-        env: { ...process.env, FORCE_COLOR: "1" }
-      },
-      (error, stdout, stderr) => {
-        if (error) {
-          const err = error;
-          if (typeof err.code === "number") {
-            resolve3({ stdout, stderr, exitCode: err.code });
-            return;
-          }
-          reject(error);
-          return;
-        }
-        resolve3({ stdout, stderr, exitCode: 0 });
-      }
-    );
-  });
-}
-function runShell(command, options) {
-  return new Promise((resolve3, reject) => {
-    const child = spawn2(command, {
-      cwd: options.cwd,
-      shell: true,
-      env: { ...process.env, FORCE_COLOR: "1" },
-      signal: options.signal
-    });
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    const timer = setTimeout(() => {
-      timedOut = true;
-      child.kill("SIGTERM");
-      setTimeout(() => child.kill("SIGKILL"), 1500).unref();
-    }, options.timeoutMs);
-    child.stdout?.on("data", (chunk) => {
-      stdout += String(chunk);
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += String(chunk);
-    });
-    child.on("error", (error) => {
-      clearTimeout(timer);
-      reject(error);
-    });
-    child.on("close", (exitCode) => {
-      clearTimeout(timer);
-      resolve3({ stdout, stderr, exitCode, timedOut });
-    });
-  });
-}
 var GitHubAuthenticatedUserSchema = z3.object({
   login: z3.string(),
   id: z3.number(),
@@ -4730,13 +4858,13 @@ var GitHubClient = class {
     }
     return parseGitHubRemote(result.stdout.trim());
   }
-  async request(path12, init = {}) {
+  async request(path13, init = {}) {
     if (!this.options.token) {
       throw new Error(
         "GitHub token is required. Set GITHUB_TOKEN or .deepcode/config.json github.token."
       );
     }
-    const response = await fetch(`${this.apiBase}${path12}`, {
+    const response = await fetch(`${this.apiBase}${path13}`, {
       ...init,
       headers: {
         accept: "application/vnd.github+json",
@@ -4752,13 +4880,13 @@ var GitHubClient = class {
     if (response.status === 204) return void 0;
     return await response.json();
   }
-  async requestText(path12, init = {}) {
+  async requestText(path13, init = {}) {
     if (!this.options.token) {
       throw new Error(
         "GitHub token is required. Set GITHUB_TOKEN or .deepcode/config.json github.token."
       );
     }
-    const response = await fetch(`${this.apiBase}${path12}`, {
+    const response = await fetch(`${this.apiBase}${path13}`, {
       ...init,
       headers: {
         accept: "application/vnd.github+json",
@@ -5099,7 +5227,7 @@ var LspClient = class {
     await this.request("initialize", {
       processId: process.pid,
       rootUri: toFileUri(this.rootPath),
-      workspaceFolders: [{ uri: toFileUri(this.rootPath), name: path3.basename(this.rootPath) }],
+      workspaceFolders: [{ uri: toFileUri(this.rootPath), name: path4.basename(this.rootPath) }],
       capabilities: {
         workspace: {
           symbol: {
@@ -5201,7 +5329,7 @@ var LspClient = class {
   }
 };
 function pickLanguageServer(servers, rootPath, queryPath) {
-  const extension = path3.extname(queryPath);
+  const extension = path4.extname(queryPath);
   const byExtension = servers.find((server) => server.fileExtensions.includes(extension));
   if (byExtension) return byExtension;
   const projectFiles = [
@@ -5211,14 +5339,14 @@ function pickLanguageServer(servers, rootPath, queryPath) {
     ["Cargo.toml", "rust"],
     ["go.mod", "go"]
   ];
-  const detected = projectFiles.find(([file]) => pathExists(path3.join(rootPath, file)))?.[1];
+  const detected = projectFiles.find(([file]) => pathExists(path4.join(rootPath, file)))?.[1];
   return detected ? servers.find((server) => server.languages.includes(detected)) : servers[0];
 }
 function pathExists(filePath) {
   return existsSync(filePath);
 }
 function toFileUri(filePath) {
-  return `file://${path3.resolve(filePath).replaceAll(path3.sep, "/")}`;
+  return `file://${path4.resolve(filePath).replaceAll(path4.sep, "/")}`;
 }
 function fromFileUri(uri) {
   return decodeURIComponent(uri.replace(/^file:\/\//, ""));
@@ -5226,12 +5354,12 @@ function fromFileUri(uri) {
 var SECRET_KEY_PATTERN = /(api[_-]?key|token|authorization|secret|password|passwd|credential|private[_-]?key)/i;
 var MIN_SECRET_VALUE_LENGTH = 4;
 function redactSecrets(value, options = {}) {
-  const path12 = options.path ?? [];
+  const path13 = options.path ?? [];
   const secretPlaceholder = options.secretPlaceholder ?? "[redacted]";
   const emptySecretPlaceholder = options.emptySecretPlaceholder ?? "[empty]";
   const secretValues = options.secretValues ?? collectSecretValues();
   if (typeof value === "string") {
-    if (isSecretPath(path12)) {
+    if (isSecretPath(path13)) {
       return value.length > 0 ? secretPlaceholder : emptySecretPlaceholder;
     }
     return redactText(value, secretValues, secretPlaceholder);
@@ -5240,7 +5368,7 @@ function redactSecrets(value, options = {}) {
     return value.map(
       (item, index) => redactSecrets(item, {
         ...options,
-        path: [...path12, String(index)],
+        path: [...path13, String(index)],
         secretValues
       })
     );
@@ -5251,7 +5379,7 @@ function redactSecrets(value, options = {}) {
         key,
         redactSecrets(item, {
           ...options,
-          path: [...path12, key],
+          path: [...path13, key],
           secretValues
         })
       ])
@@ -5289,8 +5417,8 @@ function collectSecretValues(config) {
   }
   return [...values].sort((left, right) => right.length - left.length);
 }
-function isSecretPath(path12) {
-  const key = path12[path12.length - 1] ?? "";
+function isSecretPath(path13) {
+  const key = path13[path13.length - 1] ?? "";
   if (/(api[_-]?key|token|secret|credential).*file/i.test(key)) return false;
   return SECRET_KEY_PATTERN.test(key);
 }
@@ -6148,10 +6276,10 @@ var AuditLogger = class {
   }
   worktree;
   async log(entry) {
-    const dir = path4.join(this.worktree, ".deepcode");
+    const dir = path5.join(this.worktree, ".deepcode");
     await mkdir3(dir, { recursive: true });
     const payload = redactSecrets({ ...entry, createdAt: entry.createdAt ?? nowIso() });
-    await appendFile(path4.join(dir, "audit.log"), `${JSON.stringify(payload)}
+    await appendFile(path5.join(dir, "audit.log"), `${JSON.stringify(payload)}
 `, "utf8");
   }
 };
@@ -6193,7 +6321,7 @@ var PathSecurity = class {
     return resolved;
   }
   classify(targetPath) {
-    const candidate = path5.normalize(targetPath);
+    const candidate = path6.normalize(targetPath);
     const blacklisted = this.rules.blacklist.some((rule) => globToRegex(rule).test(candidate));
     if (blacklisted) {
       return "blacklisted";
@@ -6206,8 +6334,8 @@ var PathSecurity = class {
   }
   async resolvePath(inputPath) {
     const expanded = this.expandUserPath(inputPath);
-    const absolute = path5.isAbsolute(expanded) ? expanded : path5.resolve(this.worktree, expanded);
-    const normalized2 = path5.normalize(absolute);
+    const absolute = path6.isAbsolute(expanded) ? expanded : path6.resolve(this.worktree, expanded);
+    const normalized2 = path6.normalize(absolute);
     const resolved = await this.resolveExistingParent(normalized2);
     return resolved;
   }
@@ -6219,7 +6347,7 @@ var PathSecurity = class {
     const duplicatedHomePrefix = normalizedHome ? `~/${normalizedHome}` : "";
     if (duplicatedHomePrefix && (normalizedInput === duplicatedHomePrefix || normalizedInput.startsWith(`${duplicatedHomePrefix}/`))) {
       const absoluteSuffix = normalizedInput.slice(2);
-      return path5.sep === "\\" ? absoluteSuffix.replace(/\//g, "\\") : `/${absoluteSuffix}`;
+      return path6.sep === "\\" ? absoluteSuffix.replace(/\//g, "\\") : `/${absoluteSuffix}`;
     }
     return inputPath.replace(/^~(?=\/|\\)/, this.home);
   }
@@ -6228,16 +6356,16 @@ var PathSecurity = class {
   }
   async resolveExistingParent(targetPath) {
     let cursor = targetPath;
-    while (cursor !== path5.dirname(cursor)) {
+    while (cursor !== path6.dirname(cursor)) {
       try {
         await access(cursor);
         const real = await realpath(cursor);
         if (targetPath === cursor) {
           return real;
         }
-        return path5.join(real, path5.relative(cursor, targetPath));
+        return path6.join(real, path6.relative(cursor, targetPath));
       } catch {
-        cursor = path5.dirname(cursor);
+        cursor = path6.dirname(cursor);
       }
     }
     return targetPath;
@@ -6535,16 +6663,16 @@ function whitelistExampleForPath(targetPath) {
     return "${WORKTREE}/**";
   }
   const home = process.env.HOME ?? os3.homedir();
-  const normalizedTarget = path6.resolve(targetPath);
-  const normalizedHome = path6.resolve(home);
+  const normalizedTarget = path7.resolve(targetPath);
+  const normalizedHome = path7.resolve(home);
   if (normalizedTarget === normalizedHome) {
     return "${HOME}/**";
   }
-  if (normalizedTarget.startsWith(`${normalizedHome}${path6.sep}`)) {
-    const relative2 = path6.relative(normalizedHome, normalizedTarget).replaceAll(path6.sep, "/");
+  if (normalizedTarget.startsWith(`${normalizedHome}${path7.sep}`)) {
+    const relative2 = path7.relative(normalizedHome, normalizedTarget).replaceAll(path7.sep, "/");
     return relative2 ? `\${HOME}/${relative2}/**` : "${HOME}/**";
   }
-  const normalizedForConfig = normalizedTarget.replaceAll(path6.sep, "/");
+  const normalizedForConfig = normalizedTarget.replaceAll(path7.sep, "/");
   if (normalizedForConfig === "/") {
     return "/**";
   }
@@ -6604,20 +6732,20 @@ var SessionManager = class {
   }
   async persist(sessionId) {
     const session = this.get(sessionId);
-    const dir = path7.join(this.worktree, ".deepcode", "sessions");
+    const dir = path8.join(this.worktree, ".deepcode", "sessions");
     await mkdir4(dir, { recursive: true });
-    const filePath = path7.join(dir, `${session.id}.json`);
+    const filePath = path8.join(dir, `${session.id}.json`);
     await writeFileAtomic(filePath, `${JSON.stringify(session, null, 2)}
 `);
     return filePath;
   }
   async loadAll() {
-    const dir = path7.join(this.worktree, ".deepcode", "sessions");
+    const dir = path8.join(this.worktree, ".deepcode", "sessions");
     try {
-      const entries = await readdir(dir);
+      const entries = await readdir2(dir);
       const loaded = [];
       for (const entry of entries.filter((value) => value.endsWith(".json"))) {
-        const filePath = path7.join(dir, entry);
+        const filePath = path8.join(dir, entry);
         try {
           const parsed = JSON.parse(await readFile3(filePath, "utf8"));
           const result = SessionSchema.safeParse(parsed);
@@ -6665,7 +6793,7 @@ var analyzeCodeTool = defineTool({
       const declarations = content.split(/\r?\n/).map((line, index) => ({ line: index + 1, text: line.trim() })).filter(({ text }) => /^(export\s+)?(class|interface|type|function|const|let|var|def|func)\s+/.test(text));
       const result = {
         file: filePath,
-        extension: path9.extname(filePath),
+        extension: path10.extname(filePath),
         lines: content.split(/\r?\n/).length,
         declarations
       };
@@ -6734,7 +6862,7 @@ var readFileTool = defineTool({
       if (cached.hit && cached.value !== void 0) {
         context.logActivity({
           type: "cache_hit",
-          message: `Cache hit read_file ${path10.relative(context.worktree, filePath)}`,
+          message: `Cache hit read_file ${path11.relative(context.worktree, filePath)}`,
           metadata: { path: filePath }
         });
         return cached.value;
@@ -6745,7 +6873,7 @@ var readFileTool = defineTool({
       const end = args.limit ? Math.min(lines.length, start + args.limit) : lines.length;
       context.logActivity({
         type: "file_read",
-        message: `Read ${path10.relative(context.worktree, filePath)}`,
+        message: `Read ${path11.relative(context.worktree, filePath)}`,
         metadata: { path: filePath, lines: end - start }
       });
       const output = lines.slice(start, end).map((line, index) => `${String(start + index + 1).padStart(5, " ")} | ${line}`).join("\n");
@@ -6767,11 +6895,11 @@ var writeFileTool = defineTool({
       const filePath = await context.pathSecurity.normalize(args.path, { enforceAccess: false });
       await context.permissions.ensure({ operation: "write_file", kind: "write", path: filePath });
       await context.snapshotForUndo?.(filePath);
-      await mkdir6(path10.dirname(filePath), { recursive: true });
+      await mkdir6(path11.dirname(filePath), { recursive: true });
       await writeFile22(filePath, args.content, "utf8");
       context.logActivity({
         type: "file_written",
-        message: `Wrote ${path10.relative(context.worktree, filePath)}`,
+        message: `Wrote ${path11.relative(context.worktree, filePath)}`,
         metadata: { path: filePath, bytes: Buffer.byteLength(args.content) }
       });
       return `File written: ${filePath}`;
@@ -6804,7 +6932,7 @@ var editFileTool = defineTool({
       await writeFile22(filePath, next, "utf8");
       context.logActivity({
         type: "file_edited",
-        message: `Edited ${path10.relative(context.worktree, filePath)}`,
+        message: `Edited ${path11.relative(context.worktree, filePath)}`,
         metadata: { path: filePath, removedBytes: args.oldString.length, addedBytes: args.newString.length }
       });
       return `File edited: ${filePath}`;
@@ -6822,18 +6950,23 @@ var listDirTool = defineTool({
     try: async () => {
       const dirPath = await context.pathSecurity.normalize(args.path, { enforceAccess: false });
       await context.permissions.ensure({ operation: "list_dir", kind: "read", path: dirPath });
-      const entries = await readdir3(dirPath, { withFileTypes: true });
+      const entries = await readdir4(dirPath, { withFileTypes: true });
       const rows = await Promise.all(
         entries.filter((entry) => entry.name !== "node_modules" && entry.name !== ".git").map(async (entry) => {
-          const fullPath = path10.join(dirPath, entry.name);
-          const info = await stat(fullPath);
-          const type = entry.isDirectory() ? "dir " : "file";
-          return `${type} ${String(info.size).padStart(9, " ")} ${entry.name}`;
+          const fullPath = path11.join(dirPath, entry.name);
+          try {
+            const info = await lstat2(fullPath);
+            const type = entry.isSymbolicLink() ? "link" : entry.isDirectory() ? "dir " : "file";
+            return `${type} ${String(info.size).padStart(9, " ")} ${entry.name}`;
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return `unknown ${"?".padStart(9, " ")} ${entry.name} (${message})`;
+          }
         })
       );
       context.logActivity({
         type: "directory_listed",
-        message: `Listed ${path10.relative(context.worktree, dirPath) || "."}`,
+        message: `Listed ${path11.relative(context.worktree, dirPath) || "."}`,
         metadata: { path: dirPath, entries: rows.length }
       });
       return rows.join("\n");
@@ -6952,7 +7085,7 @@ var searchTextTool = defineTool({
       if (cached.hit && cached.value !== void 0) {
         context.logActivity({
           type: "cache_hit",
-          message: `Cache hit search_text ${path11.relative(context.worktree, searchPath) || "."}`,
+          message: `Cache hit search_text ${path12.relative(context.worktree, searchPath) || "."}`,
           metadata: { pattern: args.pattern }
         });
         return cached.value;
@@ -6977,7 +7110,7 @@ var searchTextTool = defineTool({
       }));
       context.logActivity({
         type: "text_search",
-        message: `Searched ${path11.relative(context.worktree, searchPath) || "."}`,
+        message: `Searched ${path12.relative(context.worktree, searchPath) || "."}`,
         metadata: { pattern: args.pattern, matches: matches.length }
       });
       const output = JSON.stringify(matches, null, 2);
@@ -7017,7 +7150,7 @@ var searchFilesTool = defineTool({
         throw new Error(result.stderr || `ripgrep exited with ${result.exitCode}`);
       }
       const needle = args.query.toLowerCase();
-      const files = result.stdout.split(/\r?\n/).filter(Boolean).filter((file) => path11.basename(file).toLowerCase().includes(needle)).slice(0, 200);
+      const files = result.stdout.split(/\r?\n/).filter(Boolean).filter((file) => path12.basename(file).toLowerCase().includes(needle)).slice(0, 200);
       context.logActivity({
         type: "file_search",
         message: `Found ${files.length} file(s)`,
@@ -7339,7 +7472,7 @@ function createDefaultToolRegistry() {
 }
 
 // ../../packages/cli/dist/index.js
-import path8 from "path";
+import path9 from "path";
 import { writeSync } from "fs";
 import { mkdtemp, rm as rm3 } from "fs/promises";
 import { tmpdir } from "os";
@@ -8315,7 +8448,7 @@ var AsyncFzf = class {
 // ../../packages/cli/dist/index.js
 import { execFile as execFile3 } from "child_process";
 import * as nodeFs from "fs";
-import { access as access2, lstat, open, readFile as readFile4, stat as stat2 } from "fs/promises";
+import { access as access2, lstat as lstat3, open, readFile as readFile4, stat as stat2 } from "fs/promises";
 import * as path42 from "path";
 import { promisify } from "util";
 import { useState as useState2, useRef, useCallback, useMemo } from "react";
@@ -9342,7 +9475,7 @@ import { jsx as jsx45, jsxs as jsxs39 } from "react/jsx-runtime";
 import { jsx as jsx46, jsxs as jsxs40 } from "react/jsx-runtime";
 import { jsx as jsx47 } from "react/jsx-runtime";
 async function createRuntime(options) {
-  const worktree = path8.resolve(options.cwd);
+  const worktree = path9.resolve(options.cwd);
   const config = await new ConfigLoader().load({ cwd: worktree, configPath: options.configPath });
   const events = new EventBus();
   const pathSecurity = new PathSecurity(worktree, config.paths);
@@ -10599,7 +10732,7 @@ async function isInTransientGitState(gitRoot) {
 async function countUntrackedLines(absolutePath) {
   let fileStat;
   try {
-    fileStat = await lstat(absolutePath);
+    fileStat = await lstat3(absolutePath);
   } catch {
     return { added: 0, isBinary: true, truncated: false };
   }