dsh-codebase-chat 0.23.0 → 0.24.0

package/README.md

@@ -28,14 +28,15 @@
 npx dsh-codebase-chat-mcp setup
 ```
 
-The wizard detects **Claude, Cursor, Windsurf and VS Code**, writes the MCP config, done.
-No JSON to edit — and **no API key**: in `promptOnly` mode your host model does the thinking.
+The wizard detects **Claude, Cursor, Windsurf, VS Code, Zed, Gemini CLI, Kiro, Cline and Roo Code**, asks how you want answers (host model, API key, or offline local model), writes the MCP config, done.
+No JSON to edit — and **no API key**: in `promptOnly` mode your host model does the thinking,
+or go **fully offline** with the embedded local model (`localLlm`) — no key, no host, no cloud.
 
 Other paths — DeepSeek Harness plugin · CLI · from source · manual config: **[Reference](#reference)**.
 
 <p align="center">
-  <img src="docs/assets/demo.gif" alt="dsh-codebase-chat CLI demo" width="840"><br>
-  <em>Live terminal capture — <a href="docs/assets/demo-mcp.gif">MCP session</a> · <a href="docs/assets/demo-fr.gif">French mode</a></em>
+  <img src="docs/assets/demo-conv.gif" alt="dsh-codebase-chat real MCP session on a 422-file codebase" width="840"><br>
+  <em>Real MCP session on a real 422-file codebase — <code>codebase_health</code> finds 324 circular deps, <code>codebase_chat</code> answers with <code>[source: file:line]</code> receipts · <a href="docs/assets/demo-power.gif">PR review (--diff + --watch)</a> · <a href="docs/assets/demo.gif">CLI tour</a> · <a href="docs/assets/demo-mcp.gif">MCP stdio</a> · <a href="docs/assets/demo-fr.gif">French mode</a></em>
 </p>
 
 ## What a real session looks like
@@ -97,6 +98,7 @@ Every answer from `codebase_chat` arrives with `[source: file:line]` receipts yo
 | Code stays on your machine | ❌ | ❌ | ✅ |
 | Inside Claude / Cursor / Windsurf | ❌ | ~ | ✅ |
 | Deterministic health score, no LLM | ❌ | ❌ | ✅ |
+| Answers fully offline (embedded LLM) | ❌ | ❌ | ✅ |
 | Free — no API key, no account | ~ | ❌ | ✅ |
 
 ## How it works
@@ -107,7 +109,7 @@ Every answer from `codebase_chat` arrives with `[source: file:line]` receipts yo
 
 `/codebase-apply` writes safely — **dry-run** · **`.dsh-backups/`** before overwrite · **protected paths** · never outside the project.
 
-## The 12 tools
+## The 13 tools
 
 | Understand | Decide | Act | Explore |
 | --- | --- | --- | --- |
@@ -115,8 +117,9 @@ Every answer from `codebase_chat` arrives with `[source: file:line]` receipts yo
 | `codebase_search` | `codebase_audit` | `codebase_tasks` | `codebase_crea` |
 | `codebase_explain` | `codebase_report` | | |
 | `codebase_health` | `codebase_ceo` | | |
+| `codebase_impact` | | | |
 
-Same engine, three surfaces: **MCP tools** in your IDE, **slash commands** in DeepSeek Harness, **CLI flags** anywhere. Every tool takes `lang` (`fr`/`en`), `embed`, `promptOnly`, `maxTokens`.
+Same engine, three surfaces: **MCP tools** in your IDE, **slash commands** in DeepSeek Harness, **CLI flags** anywhere. Every tool takes `lang` (`fr`/`en`), `embed`, `promptOnly`, `localLlm`, `maxTokens`.
 
 ## Reference
 
@@ -222,6 +225,7 @@ dsh --profile headless '/codebase-git --project C:\my-app'
 | `DEEPSEEK_API_KEY` / `OPENAI_API_KEY` | — | Direct-LLM mode only |
 | `DEEPSEEK_BASE_URL` / `OPENAI_BASE_URL` | `https://api.deepseek.com/v1` | Custom endpoint |
 | `CODEBASE_MODEL` | `deepseek-chat` | Model for direct-LLM mode |
+| `CODEBASE_LOCAL_LLM` | — | `1` enables the embedded local model (offline answers); `hf:owner/repo:QUANT` or a `.gguf` path picks another model |
 
 </details>
 
@@ -265,10 +269,10 @@ pnpm install && pnpm build && pnpm test && pnpm typecheck
 <br>
 
 **Does it send my code to the cloud?**
-No. Indexing, retrieval, and prompt building run on your machine. In prompt-only mode, nothing leaves it at all.
+Indexing, retrieval, and prompt building all run on your machine. In prompt-only mode the server makes no network calls itself — the assembled context is read by your host model (cloud or local, your choice). For zero-network answers end to end, enable the embedded local model (`localLlm`).
 
 **Do I need an API key?**
-Not for the MCP server — without a key it returns the built prompt to the host model. A key is only needed for direct LLM calls. Inside DeepSeek Harness, the plugin uses your configured model.
+No — three ways to get answers: the host model (`promptOnly`, best quality), a DeepSeek/OpenAI key, or the embedded local model (`localLlm`, fully offline). The local model is small — great for quick lookups, prefer a hosted model for full reports. Inside DeepSeek Harness, the plugin uses your configured model.
 
 **Which languages are supported?**
 French and English via `lang` on every tool. Source-side, AST covers JS/TS, Python, Go, Rust, Java, C#, PHP — the rest is indexed line by line.
@@ -290,7 +294,7 @@ Then restart `dsh --profile web`.
 
 | | |
 | --- | --- |
-| **Shipped** | tree-sitter AST (7 languages), deterministic health score, MCP setup wizard, `.codebase-chat.json`, `--diff` scoping, `--watch` mode |
+| **Shipped** | tree-sitter AST (7 languages), deterministic health score, MCP setup wizard, `.codebase-chat.json`, `--diff` scoping, `--watch` mode, embedded local LLM |
 | **Next** | GitHub Issues export from TASKS.md, prompt language packs (ES/DE/PT) |
 | **Planned** | VS Code extension, HTTP/SSE transport, PR review mode, report export |
 | **Exploring** | multi-repo workspaces, shared team index cache, CI bot |

package/dist/cli.js

@@ -650,7 +650,12 @@ var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".vscode",
   "__pycache__",
   ".dsh-tmp",
-  ".dsh-vision-router"
+  ".dsh-vision-router",
+  ".agents",
+  ".claude",
+  ".devin",
+  ".playwright-mcp",
+  ".windsurf"
 ]);
 var DEFAULT_SKIP_FILES = /* @__PURE__ */ new Set([]);
 async function getWalkOptions(absProject) {
@@ -665,11 +670,10 @@ function projectHash(absProject) {
   return createHash("sha256").update(absProject.toLowerCase()).digest("hex").slice(0, 16);
 }
 function resolveProjectPath(projectPath) {
-  const raw = (projectPath ?? "").trim().toLowerCase().replace(/['"]/g, "");
-  if (raw === "dako") return "D:\\Nouveau dossier";
-  if (!projectPath) return process.cwd();
-  if (isAbsolute(projectPath)) return resolve(projectPath);
-  return resolve(process.cwd(), projectPath);
+  const raw = (projectPath ?? "").trim().replace(/['"]/g, "");
+  if (!raw) return process.cwd();
+  if (isAbsolute(raw)) return resolve(raw);
+  return resolve(process.cwd(), raw);
 }
 async function findProjectRoot(absProject) {
   try {
@@ -1105,9 +1109,12 @@ function lexicalScore(index, query) {
   const terms = tokenizeQuery(query);
   const scores = /* @__PURE__ */ new Map();
   if (terms.length === 0) return scores;
+  const totalFiles = Math.max(Object.keys(index.files).length, 1);
   for (const term of terms) {
     const posting = index.terms[term];
     if (!posting) continue;
+    const df = Object.keys(posting).length;
+    const idf = Math.log(1 + totalFiles / df);
     for (const [relPath, count] of Object.entries(posting)) {
       const file = index.files[relPath];
       if (!file) continue;
@@ -1118,7 +1125,7 @@ function lexicalScore(index, query) {
         if (!contentHit && !nameHit) continue;
         const bonus = (nameHit ? 4 : 0) + (chunk.kind === "function" || chunk.kind === "method" ? 1 : 0) + (contentHit ? 1 : 0);
         const prev = scores.get(key) ?? 0;
-        scores.set(key, prev + count + bonus);
+        scores.set(key, prev + count * idf + bonus);
       }
     }
   }
@@ -1223,12 +1230,23 @@ function getLabels(lang) {
   };
 }
 async function extractProductConstraints(absProject) {
-  const candidates = ["README.md", "README.MD", "readme.md", "MEMORY.md", "CONTRIBUTING.md"];
+  const candidates = [
+    "README.md",
+    "README.MD",
+    "readme.md",
+    "MEMORY.md",
+    "CONTRIBUTING.md",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".windsurfrules",
+    ".cursorrules",
+    ".cursorrules.md"
+  ];
   const constraints = [];
   for (const name of candidates) {
     const text = await safeReadText(join5(absProject, name));
     if (!text) continue;
-    const regex = /(?:constraint|contrainte|must|doit|interdit|forbidden|rule|règle|limitation)[\s\S]{0,200}/gi;
+    const regex = /(?:constraint|contrainte|must|doit|interdit|forbidden|rule|règle|limitation|never|always|jamais|toujours|zéro|zero)[\s\S]{0,200}/gi;
     let m;
     while ((m = regex.exec(text)) !== null) {
       const line = m[0].replace(/\s+/g, " ").trim();
@@ -1384,36 +1402,58 @@ function parseExports(text) {
 }
 function findCycles(edges) {
   const adj = /* @__PURE__ */ new Map();
+  const nodes = /* @__PURE__ */ new Set();
   for (const e of edges) {
+    nodes.add(e.from);
+    nodes.add(e.to);
     if (!adj.has(e.from)) adj.set(e.from, []);
     adj.get(e.from).push(e.to);
   }
-  const cycles = [];
-  const seen = /* @__PURE__ */ new Set();
-  const stack = [];
+  const index = /* @__PURE__ */ new Map();
+  const low = /* @__PURE__ */ new Map();
   const onStack = /* @__PURE__ */ new Set();
-  function dfs(node) {
-    stack.push(node);
-    onStack.add(node);
-    for (const next of adj.get(node) ?? []) {
-      if (onStack.has(next)) {
-        const cycle = stack.slice(stack.indexOf(next)).concat(next);
-        const body = cycle.slice(0, -1);
-        const minIdx = body.indexOf(body.reduce((a, b) => a < b ? a : b));
-        const key = body.slice(minIdx).concat(body.slice(0, minIdx)).join(">");
-        if (!seen.has(key)) {
-          seen.add(key);
-          cycles.push({ path: cycle });
+  const stack = [];
+  const sccs = [];
+  let counter = 0;
+  for (const root of nodes) {
+    if (index.has(root)) continue;
+    const work = [[root, 0]];
+    while (work.length) {
+      const top = work[work.length - 1];
+      const [v, ci] = top;
+      if (ci === 0) {
+        index.set(v, counter);
+        low.set(v, counter);
+        counter++;
+        stack.push(v);
+        onStack.add(v);
+      }
+      const children = adj.get(v) ?? [];
+      if (ci < children.length) {
+        top[1] = ci + 1;
+        const w = children[ci];
+        if (!index.has(w)) work.push([w, 0]);
+        else if (onStack.has(w)) low.set(v, Math.min(low.get(v), index.get(w)));
+      } else {
+        work.pop();
+        if (work.length) {
+          const parent = work[work.length - 1][0];
+          low.set(parent, Math.min(low.get(parent), low.get(v)));
+        }
+        if (low.get(v) === index.get(v)) {
+          const scc = [];
+          let w;
+          do {
+            w = stack.pop();
+            onStack.delete(w);
+            scc.push(w);
+          } while (w !== v);
+          if (scc.length > 1 || (adj.get(v) ?? []).includes(v)) sccs.push(scc);
         }
-      } else if (!stack.includes(next)) {
-        dfs(next);
       }
     }
-    stack.pop();
-    onStack.delete(node);
   }
-  for (const n of adj.keys()) dfs(n);
-  return cycles;
+  return sccs.map((m) => ({ path: m.sort() })).sort((a, b) => b.path.length - a.path.length);
 }
 function looksLikeEntry(rel, pkg) {
   const base = basename(rel).toLowerCase().replace(extname2(rel), "");
@@ -1456,7 +1496,7 @@ function findDuplicates(fileTexts) {
   }
   return [...groups.values()].sort((a, b) => b.lines - a.lines).slice(0, 15);
 }
-async function analyzeProject(projectPath, opts = {}) {
+async function collectImportGraph(projectPath) {
   const abs = await findProjectRoot(resolveProjectPath(projectPath));
   const fileTexts = /* @__PURE__ */ new Map();
   const codeFiles = [];
@@ -1465,17 +1505,11 @@ async function analyzeProject(projectPath, opts = {}) {
     const rel = relative3(abs, full).split(sep4).join("/");
     const ext = extname2(rel).toLowerCase();
     if (!CODE_EXTS.has(ext) || SKIP_EXTS.has(ext) || rel.includes(".min.")) continue;
-    if (opts.files && !opts.files.has(rel)) continue;
     const text = await safeReadText(full);
     if (!text) continue;
     codeFiles.push(rel);
     fileTexts.set(rel, text);
   }
-  let pkg = {};
-  try {
-    pkg = JSON.parse(await readFile4(join6(abs, "package.json"), "utf8"));
-  } catch {
-  }
   const known = new Set(codeFiles);
   const edges = [];
   const inDegree = /* @__PURE__ */ new Map();
@@ -1485,18 +1519,32 @@ async function analyzeProject(projectPath, opts = {}) {
       inDegree.set(to, (inDegree.get(to) ?? 0) + 1);
     }
   }
-  const cycles = findCycles(edges);
-  const unusedFiles = codeFiles.filter((rel) => !inDegree.has(rel) && !looksLikeEntry(rel, pkg)).sort();
-  const otherText = /* @__PURE__ */ new Map();
-  for (const [file, text] of fileTexts) otherText.set(file, text);
+  return { abs, codeFiles, fileTexts, edges, inDegree };
+}
+async function analyzeProject(projectPath, opts = {}) {
+  const { abs, codeFiles, fileTexts, edges, inDegree } = await collectImportGraph(projectPath);
+  const scope = opts.files;
+  const scopedFiles = scope ? codeFiles.filter((f) => scope.has(f)) : codeFiles;
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await readFile4(join6(abs, "package.json"), "utf8"));
+  } catch {
+  }
+  const cycles = findCycles(edges).filter((c) => !scope || c.path.some((node) => scope.has(node)));
+  const unusedFiles = scopedFiles.filter((rel) => !inDegree.has(rel) && !looksLikeEntry(rel, pkg)).sort();
+  const IDENT_RE = /[A-Za-z_$][\w$]*/g;
+  const identifiersByFile = /* @__PURE__ */ new Map();
+  for (const [file, text] of fileTexts) {
+    identifiersByFile.set(file, new Set(text.match(IDENT_RE) ?? []));
+  }
   const unusedExports = [];
-  for (const rel of codeFiles) {
+  for (const rel of scopedFiles) {
     for (const exp of parseExports(fileTexts.get(rel))) {
       if (exp.name === "default") continue;
       let used = false;
-      for (const [otherFile, text] of fileTexts) {
+      for (const [otherFile, ids] of identifiersByFile) {
         if (otherFile === rel) continue;
-        if (new RegExp(`\\b${exp.name.replace(/[$_]/g, "\\$&")}\\b`).test(text)) {
+        if (ids.has(exp.name)) {
           used = true;
           break;
         }
@@ -1504,21 +1552,22 @@ async function analyzeProject(projectPath, opts = {}) {
       if (!used) unusedExports.push({ file: rel, name: exp.name, line: exp.line });
     }
   }
-  const duplicates = findDuplicates(fileTexts);
+  const duplicates = findDuplicates(fileTexts).filter((g) => !scope || g.files.some((f) => scope.has(f)));
   const hotspots = [];
-  for (const [rel, text] of fileTexts) {
-    const score2 = complexityOf(text);
+  for (const rel of scopedFiles) {
+    const score2 = complexityOf(fileTexts.get(rel));
     if (score2 >= 12) hotspots.push({ file: rel, startLine: 1, score: score2 });
   }
   hotspots.sort((a, b) => b.score - a.score);
-  const codeLines = [...fileTexts.values()].reduce((s, t2) => s + t2.split("\n").length, 0);
+  const codeLines = scopedFiles.reduce((s, f) => s + fileTexts.get(f).split("\n").length, 0);
   const dupLines = duplicates.reduce((s, g) => s + g.lines, 0);
-  const penalties = cycles.length * 6 + unusedFiles.length * 2 + Math.min(unusedExports.length, 20) * 1 + Math.round(dupLines / Math.max(codeLines, 1) * 100) + Math.min(hotspots.length, 15) * 2;
+  const cyclesPenalty = cycles.reduce((s, c) => s + c.path.length, 0) * 2;
+  const penalties = cyclesPenalty + unusedFiles.length * 2 + Math.min(unusedExports.length, 20) * 1 + Math.round(dupLines / Math.max(codeLines, 1) * 100) + Math.min(hotspots.length, 15) * 2;
   const score = Math.max(0, Math.min(100, 100 - penalties));
   const grade = score >= 90 ? "A" : score >= 80 ? "B" : score >= 65 ? "C" : score >= 50 ? "D" : "E";
   return {
     projectPath: abs,
-    analyzedFiles: codeFiles.length,
+    analyzedFiles: scopedFiles.length,
     importEdges: edges.length,
     cycles,
     unusedFiles,
@@ -1560,7 +1609,7 @@ function formatHealthReport(r, lang = "fr") {
   out.push(`${t2.score}: ${r.score}/100 (${r.grade}) \xB7 ${r.analyzedFiles} ${t2.files} \xB7 ${r.importEdges} ${t2.edges}`);
   out.push("");
   out.push(`\u25CF ${t2.cycles} (${r.cycles.length})`);
-  for (const c of r.cycles.slice(0, 10)) out.push(`  ${c.path.join(" \u2192 ")}`);
+  for (const c of r.cycles.slice(0, 10)) out.push(`  ${formatCycle(c)}`);
   if (r.cycles.length === 0) out.push(`  ${t2.none}`);
   out.push("");
   out.push(`\u25CF ${t2.unusedFiles} (${r.unusedFiles.length}) \u2014 ${t2.noteUnused}`);
@@ -1576,6 +1625,149 @@ function formatHealthReport(r, lang = "fr") {
   for (const h of r.hotspots.slice(0, 10)) out.push(`  ${h.file} \u2014 score ${h.score}`);
   return out.join("\n");
 }
+function formatCycle(c, md = false) {
+  const q = (s) => md ? `\`${s}\`` : s;
+  if (c.path.length <= 4) return c.path.map(q).join(" \u2192 ") + " \u2192 " + q(c.path[0]);
+  const shown = c.path.slice(0, 4).map(q).join(", ");
+  return `${c.path.length} files: ${shown}, \u2026`;
+}
+
+// src/impact.ts
+import { basename as basename2 } from "path";
+import { readFile as readFile5 } from "fs/promises";
+import { join as join7 } from "path";
+function matchRank(rel, q) {
+  if (rel === q) return 0;
+  if (rel.endsWith(`/${q}`)) return 1;
+  if (basename2(rel) === q) return 2;
+  if (rel.toLowerCase().includes(q.toLowerCase())) return 3;
+  return -1;
+}
+function resolveTarget(codeFiles, query) {
+  const q = query.trim().replace(/\\/g, "/").replace(/^\.\//, "");
+  if (!q) return { candidates: [] };
+  const ranked = codeFiles.map((f) => ({ f, r: matchRank(f, q) })).filter((m) => m.r >= 0).sort((a, b) => a.r - b.r || a.f.length - b.f.length);
+  if (!ranked.length) return { candidates: [] };
+  const best = ranked.filter((m) => m.r === ranked[0].r);
+  if (best.length === 1) return { target: best[0].f, candidates: [] };
+  return { candidates: best.slice(0, 12).map((m) => m.f) };
+}
+async function analyzeImpact(projectPath, query) {
+  const g = await collectImportGraph(projectPath);
+  const { target, candidates } = resolveTarget(g.codeFiles, query);
+  if (!target) return { ok: false, query, candidates };
+  const rev = /* @__PURE__ */ new Map();
+  for (const e of g.edges) {
+    if (!rev.has(e.to)) rev.set(e.to, []);
+    rev.get(e.to).push(e.from);
+  }
+  let inCycle = false;
+  const queue = [target];
+  let head = 0;
+  const dist = /* @__PURE__ */ new Map([[target, 0]]);
+  while (head < queue.length) {
+    const node = queue[head++];
+    const d = dist.get(node);
+    for (const up of rev.get(node) ?? []) {
+      if (up === target) {
+        inCycle = true;
+        continue;
+      }
+      if (dist.has(up)) continue;
+      dist.set(up, d + 1);
+      queue.push(up);
+    }
+  }
+  dist.delete(target);
+  const dependents = [...dist.entries()].map(([file, d]) => ({ file, depth: d })).sort((a, b) => a.depth - b.depth || a.file.localeCompare(b.file));
+  const directCount = dependents.filter((d) => d.depth === 1).length;
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await readFile5(join7(g.abs, "package.json"), "utf8"));
+  } catch {
+  }
+  const isEntry = looksLikeEntry(target, pkg);
+  const total = dependents.length;
+  const percent = g.codeFiles.length ? total / g.codeFiles.length : 0;
+  const risk = inCycle || percent >= 0.25 || total >= 25 ? "high" : percent >= 0.05 || total >= 5 ? "medium" : "low";
+  return {
+    ok: true,
+    report: {
+      projectPath: g.abs,
+      query,
+      target,
+      exportedSymbols: parseExports(g.fileTexts.get(target) ?? ""),
+      dependents,
+      directCount,
+      totalFiles: g.codeFiles.length,
+      percent,
+      inCycle,
+      isEntry,
+      risk
+    }
+  };
+}
+function formatImpactReport(r, lang = "fr") {
+  const t2 = lang === "en" ? {
+    title: "IMPACT ANALYSIS",
+    target: "Target",
+    exports: "Exported symbols",
+    direct: "Direct dependents",
+    total: "Total blast radius",
+    files: "code files",
+    inCycle: "part of a dependency cycle",
+    entry: "entry point",
+    risk: "Risk",
+    low: "LOW",
+    medium: "MEDIUM",
+    high: "HIGH",
+    depth: "depth",
+    none: "none \u2014 nothing imports this file",
+    more: (n) => `\u2026and ${n} more`
+  } : {
+    title: "ANALYSE D\u2019IMPACT",
+    target: "Cible",
+    exports: "Symboles export\xE9s",
+    direct: "D\xE9pendants directs",
+    total: "Rayon d\u2019impact total",
+    files: "fichiers de code",
+    inCycle: "dans un cycle de d\xE9pendances",
+    entry: "point d\u2019entr\xE9e",
+    risk: "Risque",
+    low: "FAIBLE",
+    medium: "MOYEN",
+    high: "\xC9LEV\xC9",
+    depth: "profondeur",
+    none: "aucun \u2014 rien n\u2019importe ce fichier",
+    more: (n) => `\u2026et ${n} autres`
+  };
+  const tags = [r.isEntry ? t2.entry : "", r.inCycle ? t2.inCycle : ""].filter(Boolean).join(" \xB7 ");
+  const out = [];
+  out.push(`== ${t2.title} \u2014 ${basename2(r.projectPath)} ==`);
+  out.push(`${t2.target}: ${r.target}${tags ? ` (${tags})` : ""}`);
+  out.push(`${t2.exports}: ${r.exportedSymbols.length ? r.exportedSymbols.map((s) => s.name).join(", ") : "\u2014"}`);
+  out.push(`${t2.direct}: ${r.directCount} \xB7 ${t2.total}: ${r.dependents.length} / ${r.totalFiles} ${t2.files} (${Math.round(r.percent * 100)}%)`);
+  out.push(`${t2.risk}: ${t2[riskKey(r.risk)]}`);
+  out.push("");
+  if (!r.dependents.length) {
+    out.push(`  ${t2.none}`);
+    return out.join("\n");
+  }
+  const byDepth = /* @__PURE__ */ new Map();
+  for (const d of r.dependents) {
+    if (!byDepth.has(d.depth)) byDepth.set(d.depth, []);
+    byDepth.get(d.depth).push(d.file);
+  }
+  for (const [d, files] of [...byDepth.entries()].sort((a, b) => a[0] - b[0])) {
+    out.push(`  ${t2.depth} ${d} (${files.length}):`);
+    for (const f of files.slice(0, 12)) out.push(`    ${f}`);
+    if (files.length > 12) out.push(`    ${t2.more(files.length - 12)}`);
+  }
+  return out.join("\n");
+}
+function riskKey(r) {
+  return r;
+}
 
 // src/cli.ts
 var ExitSignal = class {
@@ -1600,6 +1792,7 @@ Usage:
   npx dsh-codebase-chat --project <path> --index
   npx dsh-codebase-chat --project <path> --stats
   npx dsh-codebase-chat --project <path> --health
+  npx dsh-codebase-chat --project <path> --impact src/store.ts
   npx dsh-codebase-chat --project <path> --health --diff main
   npx dsh-codebase-chat --project <path> --watch
 
@@ -1611,6 +1804,7 @@ Options:
   -i, --index            Force re-index the project
   -t, --stats            Print indexing stats
   -H, --health           Deterministic static analysis (cycles, dead code, dupes, complexity)
+  --impact <file>        Blast radius \u2014 which files transitively depend on <file>
   -d, --diff <ref>       Scope --ask/--search/--health to files changed vs a git ref
   -w, --watch            Keep the index hot \u2014 rebuild incrementally on file changes
   -e, --embed            Enable local semantic embeddings (slower, more relevant)
@@ -1635,6 +1829,7 @@ async function main() {
       index: { type: "boolean", short: "i", default: false },
       stats: { type: "boolean", short: "t", default: false },
       health: { type: "boolean", short: "H", default: false },
+      impact: { type: "string" },
       diff: { type: "string", short: "d" },
       watch: { type: "boolean", short: "w", default: false },
       embed: { type: "boolean", short: "e", default: false },
@@ -1713,6 +1908,17 @@ async function main() {
     console.log(formatHealthReport(report, lang));
     exit(0);
   }
+  if (values.impact) {
+    const r = await analyzeImpact(project, values.impact);
+    if (!r.ok) {
+      console.log(lang === "en" ? r.candidates.length ? `Ambiguous target "${values.impact}" \u2014 candidates:
+  ${r.candidates.join("\n  ")}` : `No code file matches "${values.impact}".` : r.candidates.length ? `Cible ambigu\xEB "${values.impact}" \u2014 candidats :
+  ${r.candidates.join("\n  ")}` : `Aucun fichier de code ne correspond \xE0 "${values.impact}".`);
+      exit(1);
+    }
+    console.log(formatImpactReport(r.report, lang));
+    exit(0);
+  }
   if (values.ask || values.search || values.file) {
     const result = await buildContext({
       project: values.project,