dsh-codebase-chat 0.22.0 → 0.24.0

package/dist/cli.js

@@ -2,6 +2,8 @@
 
 // src/cli.ts
 import { parseArgs } from "util";
+import { watch } from "fs";
+import { sep as sep5 } from "path";
 
 // src/context.ts
 import { join as join5 } from "path";
@@ -648,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) {
@@ -663,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 {
@@ -1103,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;
@@ -1116,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);
       }
     }
   }
@@ -1169,6 +1178,33 @@ function selectChunks(scored, maxTokens, maxChunkTokens = Infinity) {
   return { chunks: result, tokens: used };
 }
 
+// src/diff.ts
+import { execFile } from "child_process";
+import { sep as sep3 } from "path";
+import { promisify } from "util";
+var run = promisify(execFile);
+async function git(absProject, args) {
+  const { stdout } = await run("git", ["-C", absProject, ...args], { maxBuffer: 16 * 1024 * 1024 });
+  return stdout;
+}
+function toRelList(output) {
+  return output.split("\n").map((l) => l.trim()).filter(Boolean).map((l) => l.split(sep3).join("/"));
+}
+async function getChangedFiles(absProject, base) {
+  try {
+    const [tracked, untracked] = await Promise.all([
+      // Working tree vs base — covers committed, staged and unstaged edits.
+      git(absProject, ["diff", "--name-only", base, "--"]),
+      git(absProject, ["ls-files", "--others", "--exclude-standard"])
+    ]);
+    const files = /* @__PURE__ */ new Set([...toRelList(tracked), ...toRelList(untracked)]);
+    return { files, ok: true };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { files: /* @__PURE__ */ new Set(), ok: false, error: msg.split("\n")[0] };
+  }
+}
+
 // src/context.ts
 var DEFAULT_MAX_TOKENS = 6e4;
 var HEAD_BUDGET_TOKENS = 800;
@@ -1179,23 +1215,38 @@ function getLabels(lang) {
     tree: "File tree",
     noConstraints: "No explicit constraints documented.",
     constraints: "IDENTIFIED PRODUCT CONSTRAINTS",
-    answerIn: "Answer in English."
+    answerIn: "Answer in English.",
+    diffScope: (base, n) => `Scope: ${n} file(s) changed vs ${base}`,
+    diffUnavailable: (base) => `Scope: diff vs ${base} unavailable (not a git repo?) \u2014 full project`
   } : {
     project: "Projet",
     focus: "Focus",
     tree: "Arborescence",
     noConstraints: "Aucune contrainte explicite document\xE9e.",
     constraints: "CONTRAINTES PRODUIT IDENTIFI\xC9ES",
-    answerIn: "R\xE9ponds obligatoirement en fran\xE7ais."
+    answerIn: "R\xE9ponds obligatoirement en fran\xE7ais.",
+    diffScope: (base, n) => `P\xE9rim\xE8tre : ${n} fichier(s) modifi\xE9(s) vs ${base}`,
+    diffUnavailable: (base) => `P\xE9rim\xE8tre : diff vs ${base} indisponible (pas un repo git ?) \u2014 projet complet`
   };
 }
 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();
@@ -1213,13 +1264,30 @@ function formatChunk(chunk) {
 ${chunk.content}`;
 }
 async function buildContext(options) {
-  const { project, query, filePath, searchQuery, instruction, embed = false } = options;
+  const { project, query, filePath, searchQuery, instruction, embed = false, diff } = options;
   const absProject = await findProjectRoot(resolveProjectPath(project));
   const cfg = await loadProjectConfig(absProject);
   const maxTokens = options.maxTokens ?? cfg.maxTokens ?? DEFAULT_MAX_TOKENS;
   const lang = options.lang ?? cfg.lang ?? "fr";
   const labels = getLabels(lang);
   const index = await getIndex(absProject);
+  let scopedIndex = index;
+  let diffFiles;
+  let scopeLine = "";
+  if (diff && !filePath) {
+    const scope = await getChangedFiles(absProject, diff);
+    if (scope.ok) {
+      diffFiles = [...scope.files].filter((f) => index.files[f]);
+      const files = {};
+      for (const f of diffFiles) files[f] = index.files[f];
+      scopedIndex = { ...index, files };
+      scopeLine = `${labels.diffScope(diff, diffFiles.length)}
+`;
+    } else {
+      scopeLine = `${labels.diffUnavailable(diff)}
+`;
+    }
+  }
   if (embed) {
     try {
       await embedIndex(index);
@@ -1241,17 +1309,17 @@ async function buildContext(options) {
       );
       selectedChunks = chunks;
     } else {
-      const scored = await scoreChunks(index, filePath, embed);
+      const scored = await scoreChunks(scopedIndex, filePath, embed);
       const { chunks } = selectChunks(scored, bodyLimit, maxChunkTokens);
       if (chunks.length === 0) throw new Error(`File not found: ${filePath}`);
       selectedChunks = chunks;
     }
   } else if (searchQuery) {
-    const scored = await scoreChunks(index, searchQuery, embed);
+    const scored = await scoreChunks(scopedIndex, searchQuery, embed);
     const { chunks } = selectChunks(scored, bodyLimit, maxChunkTokens);
     selectedChunks = chunks;
   } else {
-    const scored = await scoreChunks(index, query, embed);
+    const scored = await scoreChunks(scopedIndex, query, embed);
     const { chunks } = selectChunks(scored, bodyLimit, maxChunkTokens);
     selectedChunks = chunks;
   }
@@ -1261,7 +1329,7 @@ ${constraints.map((c) => `- ${c}`).join("\n")}` : `== ${labels.constraints} ==
 ${labels.noConstraints}`;
   const head = `${labels.project} : ${absProject}
 ${labels.focus} : ${focus}
-${constraintsText}
+${scopeLine}${constraintsText}
 
 == ${labels.tree} ==
 ${index.tree}
@@ -1285,12 +1353,13 @@ ${finalInstruction}`;
     absProject,
     context: prompt,
     chunks: selectedChunks,
-    tokenCount
+    tokenCount,
+    diffFiles
   };
 }
 
 // src/analysis.ts
-import { basename, extname as extname2, join as join6, relative as relative3, sep as sep3, posix as posixPath } from "path";
+import { basename, extname as extname2, join as join6, relative as relative3, sep as sep4, posix as posixPath } from "path";
 import { readFile as readFile4 } from "fs/promises";
 var CODE_EXTS = /* @__PURE__ */ new Set([".js", ".jsx", ".mjs", ".cjs", ".ts", ".tsx"]);
 var ENTRY_BASENAMES = /* @__PURE__ */ new Set(["index", "main", "app", "cli", "server", "bin", "mod"]);
@@ -1333,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), "");
@@ -1405,13 +1496,13 @@ function findDuplicates(fileTexts) {
   }
   return [...groups.values()].sort((a, b) => b.lines - a.lines).slice(0, 15);
 }
-async function analyzeProject(projectPath) {
+async function collectImportGraph(projectPath) {
   const abs = await findProjectRoot(resolveProjectPath(projectPath));
   const fileTexts = /* @__PURE__ */ new Map();
   const codeFiles = [];
   const walk = await getWalkOptions(abs);
   for await (const full of walkFiles(abs, walk.skipDirs, walk.skipFiles, walk.ignoreGlobs)) {
-    const rel = relative3(abs, full).split(sep3).join("/");
+    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;
     const text = await safeReadText(full);
@@ -1419,11 +1510,6 @@ async function analyzeProject(projectPath) {
     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();
@@ -1433,18 +1519,32 @@ async function analyzeProject(projectPath) {
       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;
         }
@@ -1452,21 +1552,22 @@ async function analyzeProject(projectPath) {
       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,
@@ -1508,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}`);
@@ -1524,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 {
@@ -1548,6 +1792,9 @@ 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
 
 Options:
   -p, --project <path>   Project directory (default: current directory)
@@ -1557,6 +1804,9 @@ 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)
   --lang <en|fr>         Language for headings (default: .codebase-chat.json lang, else fr)
   -h, --help             Show this help
@@ -1579,6 +1829,9 @@ 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 },
       lang: { type: "string" },
       help: { type: "boolean", short: "h", default: false }
@@ -1608,11 +1861,64 @@ async function main() {
     console.log(`Cache:   ${index.projectHash}`);
     exit(0);
   }
+  if (values.watch) {
+    const abs = await findProjectRoot(project);
+    const walk = await getWalkOptions(abs);
+    await getIndex(abs, (m) => console.log(m), true);
+    console.log(lang === "en" ? "Watch mode \u2014 the index stays hot while you code. (Ctrl+C to quit)" : "Mode watch \u2014 l\u2019index reste \xE0 jour pendant que tu codes. (Ctrl+C pour quitter)");
+    let timer;
+    let pending = /* @__PURE__ */ new Set();
+    const watcher = watch(abs, { recursive: true }, (_event, filename) => {
+      if (!filename) return;
+      const rel = filename.split(sep5).join("/");
+      if (rel.split("/").some((p) => walk.skipDirs.has(p))) return;
+      pending.add(rel);
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(() => {
+        const changed = [...pending];
+        pending = /* @__PURE__ */ new Set();
+        const t0 = Date.now();
+        void getIndex(abs, () => {
+        }).then(() => {
+          const dt = ((Date.now() - t0) / 1e3).toFixed(1);
+          const list = changed.slice(0, 4).join(", ") + (changed.length > 4 ? ` +${changed.length - 4}` : "");
+          console.log(lang === "en" ? `Changed: ${list} \u2192 index refreshed (${dt}s)` : `Modifi\xE9 : ${list} \u2192 index \xE0 jour (${dt}s)`);
+        });
+      }, 500);
+    });
+    process.on("SIGINT", () => {
+      watcher.close();
+      exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
   if (values.health) {
-    const report = await analyzeProject(project);
+    let scope;
+    if (values.diff) {
+      const s = await getChangedFiles(await findProjectRoot(project), values.diff);
+      if (s.ok) {
+        scope = { files: s.files };
+        console.log(lang === "en" ? `Diff scope: ${s.files.size} file(s) changed vs ${values.diff}` : `P\xE9rim\xE8tre diff : ${s.files.size} fichier(s) modifi\xE9(s) vs ${values.diff}`);
+      } else {
+        console.error(lang === "en" ? `warning: diff vs "${values.diff}" unavailable (${s.error}) \u2014 full project` : `attention : diff vs "${values.diff}" indisponible (${s.error}) \u2014 projet complet`);
+      }
+    }
+    const report = await analyzeProject(project, scope);
     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,
@@ -1620,7 +1926,8 @@ async function main() {
       searchQuery: values.search,
       filePath: values.file,
       lang,
-      embed: values.embed
+      embed: values.embed,
+      diff: values.diff
     });
     console.log(result.context);
     console.log(`