dsh-codebase-chat 0.25.6 → 0.28.0

package/dist/cli.js

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { parseArgs } from "util";
 import { watch } from "fs";
-import { sep as sep5, basename as basename3 } from "path";
+import { sep as sep5, basename as basename4 } from "path";
 
 // src/context.ts
 import { join as join5 } from "path";
@@ -1652,6 +1652,95 @@ function formatCycle(c, md = false) {
   const shown = c.path.slice(0, 4).map(q).join(", ");
   return `${c.path.length} files: ${shown}, \u2026`;
 }
+var GRADE_ICON = { A: "\u{1F7E2}", B: "\u{1F535}", C: "\u{1F7E1}", D: "\u{1F7E0}", E: "\u{1F534}" };
+function scoreBar(score) {
+  const filled = Math.round(score / 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+function formatHealthReportMd(r, lang = "fr") {
+  const t2 = lang === "en" ? {
+    title: "Static analysis",
+    files: "files analyzed",
+    edges: "local imports",
+    cycles: "Circular dependencies",
+    none: "None",
+    unusedFiles: "Unused files (candidates)",
+    unusedExports: "Unused exports (candidates)",
+    dupes: "Duplicate code blocks",
+    hotspots: "Complexity hotspots",
+    score: "Health score",
+    noteUnused: "_candidates \u2014 entry points and framework conventions excluded_",
+    colFile: "File",
+    colSymbol: "Symbol",
+    colSize: "Size",
+    colFiles: "Files",
+    colScore: "Score",
+    more: (n) => `_\u2026and ${n} more_`
+  } : {
+    title: "Analyse statique",
+    files: "fichiers analys\xE9s",
+    edges: "imports locaux",
+    cycles: "D\xE9pendances circulaires",
+    none: "Aucune",
+    unusedFiles: "Fichiers inutilis\xE9s (candidats)",
+    unusedExports: "Exports inutilis\xE9s (candidats)",
+    dupes: "Blocs de code dupliqu\xE9s",
+    hotspots: "Hotspots de complexit\xE9",
+    score: "Score de sant\xE9",
+    noteUnused: "_candidats \u2014 points d\u2019entr\xE9e et conventions exclus_",
+    colFile: "Fichier",
+    colSymbol: "Symbole",
+    colSize: "Taille",
+    colFiles: "Fichiers",
+    colScore: "Score",
+    more: (n) => `_\u2026et ${n} autres_`
+  };
+  const out = [];
+  out.push(`## ${GRADE_ICON[r.grade]} ${t2.title} \u2014 \`${basename(r.projectPath)}\``);
+  out.push("");
+  if (r.analyzedFiles === 0) {
+    out.push(lang === "en" ? "_No code files detected in this project \u2014 check the path or your `.codebase-chat.json` ignore rules._" : "_Aucun fichier de code d\xE9tect\xE9 dans ce projet \u2014 v\xE9rifie le chemin ou les r\xE8gles ignore de `.codebase-chat.json`._");
+    return out.join("\n");
+  }
+  out.push(`**${t2.score} : ${scoreBar(r.score)} ${r.score}/100 (${r.grade})** \xB7 ${r.analyzedFiles} ${t2.files} \xB7 ${r.importEdges} ${t2.edges}`);
+  out.push("");
+  out.push(`### ${t2.cycles} \u2014 ${r.cycles.length}`);
+  if (r.cycles.length === 0) out.push(t2.none);
+  else for (const c of r.cycles.slice(0, 10)) out.push(`- ${formatCycle(c, true)}`);
+  if (r.cycles.length > 10) out.push(t2.more(r.cycles.length - 10));
+  out.push("");
+  out.push(`### ${t2.unusedFiles} \u2014 ${r.unusedFiles.length}`);
+  out.push(t2.noteUnused);
+  if (r.unusedFiles.length) {
+    out.push("", `| ${t2.colFile} |`, "|---|---|");
+    for (const f of r.unusedFiles.slice(0, 15)) out.push(`| \`${f}\` |`);
+    if (r.unusedFiles.length > 15) out.push(`| ${t2.more(r.unusedFiles.length - 15)} |`);
+  }
+  out.push("");
+  out.push(`### ${t2.unusedExports} \u2014 ${r.unusedExports.length}`);
+  if (r.unusedExports.length) {
+    out.push("", `| ${t2.colFile} | ${t2.colSymbol} |`, "|---|---|");
+    for (const e of r.unusedExports.slice(0, 15)) out.push(`| \`${e.file}:${e.line}\` | \`${e.name}\` |`);
+    if (r.unusedExports.length > 15) out.push(`| ${t2.more(r.unusedExports.length - 15)} | |`);
+  } else out.push(t2.none);
+  out.push("");
+  out.push(`### ${t2.dupes} \u2014 ${r.duplicates.length}`);
+  if (r.duplicates.length) {
+    out.push("", `| ${t2.colSize} | ${t2.colFiles} |`, "|---|---|");
+    for (const d of r.duplicates.slice(0, 8)) {
+      out.push(`| ${d.lines} \xD7 ${d.files.length} | ${d.files.map((f) => `\`${f}\``).join(", ")} |`);
+    }
+    if (r.duplicates.length > 8) out.push(`| ${t2.more(r.duplicates.length - 8)} | |`);
+  } else out.push(t2.none);
+  out.push("");
+  out.push(`### ${t2.hotspots} \u2014 ${r.hotspots.length}`);
+  if (r.hotspots.length) {
+    out.push("", `| ${t2.colFile} | ${t2.colScore} |`, "|---|---|");
+    for (const h of r.hotspots.slice(0, 10)) out.push(`| \`${h.file}\` | **${h.score}** |`);
+    if (r.hotspots.length > 10) out.push(`| ${t2.more(r.hotspots.length - 10)} | |`);
+  } else out.push(t2.none);
+  return out.join("\n");
+}
 
 // src/impact.ts
 import { basename as basename2 } from "path";
@@ -2532,80 +2621,956 @@ function buildToolPrompt(tool, opts) {
   return normalizeLabels(builder(opts), opts.lang || "fr");
 }
 
-// src/local-llm.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join8 } from "path";
-var DEFAULT_MODEL_URI = "hf:Qwen/Qwen2.5-1.5B-Instruct-GGUF:Q4_K_M";
-var LOCAL_CONTEXT_SIZE = 8192;
-var LOCAL_MAX_TOKENS = 1536;
-function isLocalLlmEnabled() {
-  return !!(process.env.CODEBASE_LOCAL_LLM || "").trim();
+// src/report.ts
+import { access, readFile as readFile6 } from "fs/promises";
+import { basename as basename3, extname as extname3, join as join8 } from "path";
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var run2 = promisify2(execFile2);
+var EXT_LANG = {
+  ".ts": "TypeScript",
+  ".tsx": "TypeScript (React)",
+  ".js": "JavaScript",
+  ".jsx": "JavaScript (React)",
+  ".mjs": "JavaScript (ESM)",
+  ".cjs": "JavaScript (CJS)",
+  ".py": "Python",
+  ".rs": "Rust",
+  ".go": "Go",
+  ".java": "Java",
+  ".kt": "Kotlin",
+  ".rb": "Ruby",
+  ".php": "PHP",
+  ".c": "C",
+  ".h": "C/C++",
+  ".cpp": "C++",
+  ".cs": "C#",
+  ".swift": "Swift",
+  ".vue": "Vue",
+  ".svelte": "Svelte",
+  ".dart": "Dart",
+  ".lua": "Lua"
+};
+function bar(score) {
+  const filled = Math.round(score / 10);
+  return "\u2588".repeat(filled) + "\u2591".repeat(10 - filled);
+}
+var SMELL_PATS = [
+  ["todo", /\b(?:TODO|FIXME|HACK|XXX|WIP)\b/i],
+  ["console", /\bconsole\.(log|warn|error|debug|info)\s*\(/],
+  ["tsIgnore", /@ts-(ignore|expect-error|nocheck)\b/],
+  ["any", /:\s*any\b/],
+  ["emptyCatch", /catch\s*\([^)]*\)\s*\{\s*\}/],
+  ["debugger", /\bdebugger\s*;/],
+  ["syncIo", /\b(readFileSync|writeFileSync|appendFileSync|readdirSync|mkdirSync|execSync)\s*\(/]
+];
+var SEC_PATS = [
+  ["secret", /(?:api[_-]?key|secret|passwd|password|token|private[_-]?key)\s*[:=]\s*['"`][A-Za-z0-9_\/+\-.]{8,}['"`]/i],
+  ["eval", /\beval\s*\(|new\s+Function\s*\(/],
+  ["exec", /\bexecSync\s*\(|child_process/],
+  ["innerHTML", /\.innerHTML\s*=/],
+  ["unsafeRegex", /new\s+RegExp\s*\([^'"`]/]
+];
+function scanCode(fileTexts, pats, perFileCap = 3) {
+  const out = {};
+  for (const [file, text] of fileTexts) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(file)) continue;
+    const lines = text.split("\n");
+    for (const [key, re] of pats) {
+      let found = 0;
+      for (let i = 0; i < lines.length && found < perFileCap; i++) {
+        if (re.test(lines[i])) {
+          (out[key] ??= []).push({ file, line: i + 1, sample: lines[i].trim().slice(0, 90) });
+          found++;
+        }
+      }
+    }
+  }
+  return out;
 }
-function configuredModel() {
-  const v = (process.env.CODEBASE_LOCAL_LLM || "").trim();
-  if (!v || v === "1" || v.toLowerCase() === "true") return DEFAULT_MODEL_URI;
-  return v;
+function countHits(scan) {
+  return Object.values(scan).reduce((s, f) => s + f.length, 0);
 }
-async function importLlama() {
+var SENSITIVE_PATS = /(^|\/)\.env$|(^|\/)\.env\.(local|prod|production|dev|development)$|\.(pem|key|p12|pfx|keystore)$|id_rsa|id_ed25519|credentials\.json|service-account/i;
+async function gitActivity(abs) {
   try {
-    return await import("node-llama-cpp");
+    const { stdout } = await run2("git", [
+      "-C",
+      abs,
+      "log",
+      "--numstat",
+      "--format=@@@%an|%ad|%s",
+      "--date=short",
+      "-n",
+      "400"
+    ], { maxBuffer: 32 * 1024 * 1024 });
+    const stats = { commits: 0, authors: /* @__PURE__ */ new Map(), lastDate: "", churn: /* @__PURE__ */ new Map(), fileAuthors: /* @__PURE__ */ new Map(), months: /* @__PURE__ */ new Map(), sensitiveTracked: [], fileLastCommit: /* @__PURE__ */ new Map(), subjects: [], commitSizes: [] };
+    let author = "";
+    let date = "";
+    let curFiles = 0, curLines = 0;
+    const flush = () => {
+      if (curFiles || curLines) stats.commitSizes.push({ files: curFiles, lines: curLines });
+      curFiles = 0;
+      curLines = 0;
+    };
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("@@@")) {
+        flush();
+        stats.commits++;
+        const [a, d, s] = line.slice(3).split("|");
+        author = a;
+        date = d;
+        if (s) stats.subjects.push(s);
+        if (!stats.lastDate) stats.lastDate = d;
+        stats.authors.set(a, (stats.authors.get(a) ?? 0) + 1);
+        const month = d.slice(0, 7);
+        stats.months.set(month, (stats.months.get(month) ?? 0) + 1);
+        continue;
+      }
+      const m = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+      if (!m || m[1] === "-") continue;
+      const file = m[3].replace(/\\/g, "/");
+      const delta = Number(m[1]) + Number(m[2]);
+      curFiles++;
+      curLines += delta;
+      stats.churn.set(file, (stats.churn.get(file) ?? 0) + delta);
+      if (!stats.fileLastCommit.has(file) && date) stats.fileLastCommit.set(file, date);
+      if (author) (stats.fileAuthors.get(file) ?? stats.fileAuthors.set(file, /* @__PURE__ */ new Set()).get(file)).add(author);
+    }
+    flush();
+    try {
+      const { stdout: tracked } = await run2("git", ["-C", abs, "ls-files"], { maxBuffer: 8 * 1024 * 1024 });
+      stats.sensitiveTracked = tracked.split("\n").map((l) => l.trim()).filter((f) => f && SENSITIVE_PATS.test(f));
+    } catch {
+    }
+    return stats;
   } catch {
-    throw new Error("Local LLM needs the optional dependency: npm i node-llama-cpp");
-  }
-}
-var modelPromise = null;
-function loadLocalModel() {
-  if (!modelPromise) {
-    modelPromise = (async () => {
-      const spec = configuredModel();
-      let modelPath = spec;
-      if (spec.startsWith("hf:")) {
-        const { createModelDownloader } = await importLlama();
-        const downloader = await createModelDownloader({
-          modelUri: spec,
-          dirPath: join8(getCacheDir(), "models")
-        });
-        modelPath = await downloader.download();
-      } else if (!existsSync2(spec)) {
-        throw new Error(`Local model not found: ${spec}`);
+    return null;
+  }
+}
+var SYSTEM_ENV = /* @__PURE__ */ new Set([
+  "PATH",
+  "PATHEXT",
+  "HOME",
+  "HOMEPATH",
+  "USERPROFILE",
+  "USERNAME",
+  "USER",
+  "APPDATA",
+  "LOCALAPPDATA",
+  "TEMP",
+  "TMP",
+  "TMPDIR",
+  "OS",
+  "COMSPEC",
+  "SYSTEMROOT",
+  "WINDIR",
+  "PROGRAMFILES",
+  "PROGRAMDATA",
+  "NUMBER_OF_PROCESSORS",
+  "PROCESSOR_ARCHITECTURE",
+  "SHELL",
+  "TERM",
+  "PWD",
+  "OLDPWD",
+  "HOME",
+  "LANG",
+  "LC_ALL",
+  "TZ",
+  "NODE_ENV",
+  "NODE_PATH",
+  "npm_config_cache",
+  "CI",
+  "HOSTNAME"
+]);
+async function envAudit(abs, fileTexts) {
+  const used = /* @__PURE__ */ new Set();
+  for (const [file, text] of fileTexts) {
+    if (/test|spec|__tests__/i.test(file)) continue;
+    for (const m of text.matchAll(/\bprocess\.env\.([A-Z_][A-Z0-9_]*)/g)) used.add(m[1]);
+    for (const m of text.matchAll(/\bimport\.meta\.env\.([A-Z_][A-Z0-9_]*)/g)) used.add(m[1]);
+  }
+  const declared = /* @__PURE__ */ new Set();
+  for (const envFile of [".env.example", ".env.sample", ".env.template"]) {
+    try {
+      const text = await readFile6(join8(abs, envFile), "utf8");
+      for (const m of text.matchAll(/^\s*([A-Z_][A-Z0-9_]*)\s*=/gm)) declared.add(m[1]);
+    } catch {
+    }
+  }
+  const projectVars = [...used].filter((v) => !SYSTEM_ENV.has(v));
+  const undocumented = projectVars.filter((v) => !declared.has(v)).sort();
+  return { used: projectVars.sort(), undocumented, hasTemplate: declared.size > 0 };
+}
+function unusedDeps(deps, imported) {
+  return deps.filter((d) => ![...imported].some((i) => pkgRoot(i) === d));
+}
+async function configAudit(abs, pkg, _indexPaths, isGit) {
+  let tsStrict = null;
+  let gitignore = false;
+  try {
+    const raw = await readFile6(join8(abs, "tsconfig.json"), "utf8");
+    const clean = raw.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    tsStrict = JSON.parse(clean)?.compilerOptions?.strict === true;
+  } catch {
+  }
+  try {
+    await access(join8(abs, ".gitignore"));
+    gitignore = true;
+  } catch {
+  }
+  const pkgMissing = ["license", "repository", "engines"].filter((k) => !pkg[k]);
+  return { tsStrict, gitignore, pkgMissing, isGit };
+}
+function functionHotspots(index) {
+  const out = [];
+  for (const f of Object.values(index.files)) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(f.relPath)) continue;
+    for (const c of f.chunks) {
+      if ((c.kind === "function" || c.kind === "method" || c.kind === "class") && c.name)
+        out.push({ file: f.relPath, name: c.name, lines: c.endLine - c.startLine + 1 });
+    }
+  }
+  return out.sort((a, b) => b.lines - a.lines).slice(0, 6);
+}
+async function brokenPkgEntries(abs, pkg) {
+  const targets = [];
+  if (typeof pkg.main === "string") targets.push(pkg.main);
+  if (typeof pkg.bin === "string") targets.push(pkg.bin);
+  else if (pkg.bin && typeof pkg.bin === "object") targets.push(...Object.values(pkg.bin).filter((v) => typeof v === "string"));
+  const walkExports = (e) => {
+    if (typeof e === "string" && e.startsWith(".")) targets.push(e);
+    else if (e && typeof e === "object") Object.values(e).forEach(walkExports);
+  };
+  walkExports(pkg.exports);
+  const broken = [];
+  for (const t2 of [...new Set(targets)]) {
+    try {
+      await access(join8(abs, t2));
+    } catch {
+      broken.push(t2);
+    }
+  }
+  return broken;
+}
+function deepImports(fileTexts) {
+  const out = [];
+  const re = /from\s+['"]((?:\.\.\/){3,}[^'"]*)['"]/;
+  for (const [file, text] of fileTexts) {
+    if (/test|spec|__tests__/i.test(file)) continue;
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const m = lines[i].match(re);
+      if (m) out.push({ file, line: i + 1, sample: m[1] });
+    }
+  }
+  return out.slice(0, 8);
+}
+function codeShape(fileTexts) {
+  let commentLines = 0, codeLines = 0;
+  const deepNest = [];
+  for (const [file, text] of fileTexts) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(file)) continue;
+    let maxDepth = 0, inBlock = false;
+    for (const line of text.split("\n")) {
+      const t2 = line.trim();
+      if (!t2) continue;
+      codeLines++;
+      if (inBlock) {
+        commentLines++;
+        if (t2.includes("*/")) inBlock = false;
+        continue;
       }
-      const { getLlama } = await importLlama();
-      const cpuOnly = /^(0|off|false|cpu)$/i.test(process.env.CODEBASE_LOCAL_GPU || "");
-      const llama = await getLlama(cpuOnly ? { gpu: false } : {});
-      try {
-        return await llama.loadModel({ modelPath });
-      } catch (err) {
-        if (cpuOnly) throw err;
-        console.error(`[local-llm] GPU load failed (${err instanceof Error ? err.message : err}) \u2014 falling back to CPU. Slower, but works. Set CODEBASE_LOCAL_GPU=off to skip GPU entirely.`);
-        const cpuLlama = await getLlama({ gpu: false });
-        return cpuLlama.loadModel({ modelPath });
+      if (t2.startsWith("//") || t2.startsWith("*")) {
+        commentLines++;
+        continue;
       }
-    })();
-    modelPromise.catch(() => {
-      modelPromise = null;
-    });
+      if (t2.startsWith("/*")) {
+        commentLines++;
+        if (!t2.includes("*/")) inBlock = true;
+        continue;
+      }
+      const indent = line.match(/^[\t ]*/)[0];
+      const depth = indent.replace(/\t/g, "    ").length / 4;
+      if (depth > maxDepth) maxDepth = depth;
+    }
+    if (maxDepth >= 6) deepNest.push({ file, depth: Math.round(maxDepth) });
   }
-  return modelPromise;
+  return { commentPct: codeLines ? Math.round(commentLines / codeLines * 100) : 0, deepNest: deepNest.sort((a, b) => b.depth - a.depth).slice(0, 5) };
 }
-async function callLocalLlm(prompt, lang = "fr") {
-  const model = await loadLocalModel();
-  const { LlamaChatSession } = await importLlama();
-  const context = await model.createContext({ contextSize: LOCAL_CONTEXT_SIZE });
+async function readmeAudit(abs) {
   try {
-    const session = new LlamaChatSession({
-      contextSequence: context.getSequence(),
-      systemPrompt: lang === "en" ? "You are a senior codebase analyst. Be precise and cite files with [source: path:line]." : "Tu es un analyste codebase senior. Sois precis et cite les fichiers avec [source: chemin:ligne]."
+    const text = await readFile6(join8(abs, "README.md"), "utf8");
+    return {
+      install: /^#{1,3}.*(install|installation|getting started|démarrage)/im.test(text),
+      usage: /^#{1,3}.*(usage|utilisation|quickstart|quick start)/im.test(text),
+      codeBlocks: (text.match(/```/g) ?? []).length / 2,
+      badges: (text.match(/!\[/g) ?? []).length
+    };
+  } catch {
+    return null;
+  }
+}
+function commitQuality(subjects) {
+  if (!subjects.length) return null;
+  const CONV = /^(feat|fix|docs|style|refactor|perf|test|chore|ci|build|revert|tweak|release|hotfix|init|merge|wip)(\(.+\))?!?:\s/i;
+  const conv = subjects.filter((s) => CONV.test(s)).length;
+  const avgLen = Math.round(subjects.reduce((s, x) => s + x.length, 0) / subjects.length);
+  return { conventionalPct: Math.round(conv / subjects.length * 100), avgLen };
+}
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "buffer",
+  "child_process",
+  "cluster",
+  "console",
+  "constants",
+  "crypto",
+  "dgram",
+  "dns",
+  "domain",
+  "events",
+  "fs",
+  "http",
+  "http2",
+  "https",
+  "inspector",
+  "module",
+  "net",
+  "os",
+  "path",
+  "perf_hooks",
+  "process",
+  "punycode",
+  "querystring",
+  "readline",
+  "repl",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tls",
+  "tty",
+  "url",
+  "util",
+  "v8",
+  "vm",
+  "worker_threads",
+  "zlib"
+]);
+function pkgRoot(spec) {
+  const s = spec.startsWith("node:") ? spec.slice(5) : spec;
+  if (s.startsWith("@")) return s.split("/").slice(0, 2).join("/");
+  return s.split("/")[0];
+}
+function importedPackages(fileTexts) {
+  const imported = /* @__PURE__ */ new Set();
+  const IMPORT_RE2 = /(?:\bfrom\s+|\bimport\s*\(|\bimport\s+|\brequire\s*\()\s*['"]([^'"./][^'"]*)['"]/g;
+  for (const text of fileTexts.values())
+    for (const m of text.matchAll(IMPORT_RE2)) imported.add(m[1]);
+  return imported;
+}
+async function missingDeps(abs, fileTexts, pkg, indexPaths) {
+  const declared = new Set([pkg.name].filter(Boolean));
+  const addDeps = (p) => ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].forEach((k) => Object.keys(p[k] ?? {}).forEach((d) => declared.add(d)));
+  addDeps(pkg);
+  for (const p of indexPaths) {
+    if (!/(^|\/)package\.json$/.test(p) || p === "package.json") continue;
+    try {
+      addDeps(JSON.parse(await readFile6(join8(abs, p), "utf8")));
+    } catch {
+    }
+  }
+  const missing = /* @__PURE__ */ new Set();
+  for (const spec of importedPackages(fileTexts)) {
+    const root = pkgRoot(spec);
+    if (!NODE_BUILTINS.has(root) && !declared.has(root)) missing.add(root);
+  }
+  return [...missing].sort();
+}
+async function lockfileDrift(abs, deps) {
+  for (const lf of ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock"]) {
+    try {
+      const text = await readFile6(join8(abs, lf), "utf8");
+      return deps.filter((d) => !text.includes(d));
+    } catch {
+    }
+  }
+  return [];
+}
+function functionComplexity(index) {
+  const BRANCH = /\b(if|for|while|case|catch)\b|&&|\|\||\?/g;
+  const out = [];
+  for (const f of Object.values(index.files)) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(f.relPath)) continue;
+    for (const c of f.chunks) {
+      if ((c.kind === "function" || c.kind === "method") && c.name)
+        out.push({ file: f.relPath, name: c.name, score: (c.content.match(BRANCH) ?? []).length });
+    }
+  }
+  return out.sort((a, b) => b.score - a.score).slice(0, 6);
+}
+function duplicateNames(codeFiles) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const f of codeFiles) {
+    const b = basename3(f).toLowerCase();
+    (byName.get(b) ?? byName.set(b, []).get(b)).push(f);
+  }
+  return [...byName.entries()].filter(([n, fs]) => fs.length > 1 && !/^(index|types?|constants?|config)\./.test(n)).map(([name, files]) => ({ name, files })).slice(0, 5);
+}
+function asyncWithoutAwait(index) {
+  const out = [];
+  for (const f of Object.values(index.files)) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(f.relPath)) continue;
+    for (const c of f.chunks) {
+      if ((c.kind === "function" || c.kind === "method") && c.name && /\basync\b/.test(c.content.split("\n")[0]) && !/\bawait\b/.test(c.content))
+        out.push({ file: f.relPath, name: c.name });
+    }
+  }
+  return out.slice(0, 6);
+}
+function graphDepth(edges, entryPoints) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of edges) (adj.get(e.from) ?? adj.set(e.from, []).get(e.from)).push(e.to);
+  let max = 0;
+  const memo = /* @__PURE__ */ new Map();
+  const dfs = (f, seen) => {
+    if (memo.has(f)) return memo.get(f);
+    if (seen.has(f)) return 0;
+    seen.add(f);
+    let d = 0;
+    for (const t2 of adj.get(f) ?? []) d = Math.max(d, dfs(t2, seen) + 1);
+    seen.delete(f);
+    memo.set(f, d);
+    return d;
+  };
+  for (const e of entryPoints) max = Math.max(max, dfs(e, /* @__PURE__ */ new Set()));
+  return max;
+}
+function docCoverage(fileTexts) {
+  let documented = 0, total = 0;
+  const EXPORT_LINE = /^\s*export\s+(?:async\s+)?(?:function|class|const|let|interface|type|enum|default)\b/;
+  for (const [file, text] of fileTexts) {
+    if (/test|spec|__tests__|\.d\.ts$/i.test(file)) continue;
+    const lines = text.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      if (!EXPORT_LINE.test(lines[i])) continue;
+      total++;
+      let j = i - 1;
+      while (j >= 0 && !lines[j].trim()) j--;
+      if (j >= 0 && /^\s*(\/\/|\/\*|\*)/.test(lines[j])) documented++;
+    }
+  }
+  return { documented, total };
+}
+function detectInfra(indexPaths) {
+  const found = [];
+  const has = (p) => indexPaths.has(p) || [...indexPaths].some((f) => f.startsWith(p));
+  if (has(".github/workflows")) found.push("CI (GitHub Actions)");
+  if (has("dockerfile") || has("docker-compose.yml")) found.push("Docker");
+  if (has("tsconfig.json")) found.push("TypeScript config");
+  if (has("pnpm-lock.yaml") || has("package-lock.json") || has("yarn.lock")) found.push("lockfile");
+  if (has("vitest.config") || has("jest.config")) found.push("test runner config");
+  if (has(".env.example") || has(".env.sample")) found.push(".env template");
+  if (has("dockerfile")) found.push("container");
+  if (has("vercel.json") || has("netlify.toml")) found.push("deploy config");
+  if (has("eslint.config") || has(".eslintrc")) found.push("linter config");
+  if (has(".prettierrc") || has("prettier.config")) found.push("formatter config");
+  return [...new Set(found)];
+}
+function recommendations(r, hasTests, smells, sec, git2, infra, riskFiles, extras, lang) {
+  const en = lang === "en";
+  const out = [];
+  if (extras.missingDeps.length) out.push({
+    severity: "Critique",
+    text: en ? `${extras.missingDeps.length} package${extras.missingDeps.length > 1 ? "s" : ""} imported but absent from package.json: ${extras.missingDeps.map((d) => `\`${d}\``).join(", ")} \u2014 installs will break for everyone else.` : `${extras.missingDeps.length} package${extras.missingDeps.length > 1 ? "s" : ""} import\xE9${extras.missingDeps.length > 1 ? "s" : ""} mais absent${extras.missingDeps.length > 1 ? "s" : ""} de package.json : ${extras.missingDeps.map((d) => `\`${d}\``).join(", ")} \u2014 l\u2019install cassera chez les autres.`
+  });
+  if (extras.brokenEntries.length) out.push({
+    severity: "Critique",
+    text: en ? `package.json points to missing files: ${extras.brokenEntries.map((e) => `\`${e}\``).join(", ")} \u2014 the package is broken for consumers.` : `package.json pointe vers des fichiers absents : ${extras.brokenEntries.map((e) => `\`${e}\``).join(", ")} \u2014 le package est cass\xE9 pour les consommateurs.`
+  });
+  if (extras.sensitive.length) out.push({
+    severity: "Critique",
+    text: en ? `Sensitive file${extras.sensitive.length > 1 ? "s" : ""} in the repo \u2014 e.g. \`${extras.sensitive[0]}\`${git2?.sensitiveTracked.includes(extras.sensitive[0]) ? " (tracked by git \u2014 purge history + rotate secrets)" : ""}. Add to .gitignore.` : `Fichier${extras.sensitive.length > 1 ? "s" : ""} sensible${extras.sensitive.length > 1 ? "s" : ""} dans le d\xE9p\xF4t \u2014 ex. \`${extras.sensitive[0]}\`${git2?.sensitiveTracked.includes(extras.sensitive[0]) ? " (suivi par git \u2014 purger l\u2019historique + r\xE9voquer les secrets)" : ""}. Ajouter au .gitignore.`
+  });
+  if (sec.secret?.length) out.push({
+    severity: "Critique",
+    text: en ? `${sec.secret.length} potential hardcoded secret${sec.secret.length > 1 ? "s" : ""} \u2014 e.g. \`${sec.secret[0].file}:${sec.secret[0].line}\`. Move to env vars, rotate if ever committed.` : `${sec.secret.length} secret${sec.secret.length > 1 ? "s" : ""} potentiellement cod\xE9${sec.secret.length > 1 ? "s" : ""} en dur \u2014 ex. \`${sec.secret[0].file}:${sec.secret[0].line}\`. D\xE9placer en variables d'env, r\xE9voquer si d\xE9j\xE0 commit\xE9.`
+  });
+  if (sec.eval?.length || sec.exec?.length || sec.innerHTML?.length) {
+    const f = [...sec.eval ?? [], ...sec.exec ?? [], ...sec.innerHTML ?? []][0];
+    out.push({
+      severity: "\xC9lev\xE9e",
+      text: en ? `Dangerous sinks detected (eval/exec/innerHTML) \u2014 e.g. \`${f.file}:${f.line}\`. Audit each call site.` : `Sinks dangereux d\xE9tect\xE9s (eval/exec/innerHTML) \u2014 ex. \`${f.file}:${f.line}\`. Auditer chaque site d'appel.`
     });
-    return await session.prompt(prompt, {
-      temperature: 0.2,
-      maxTokens: LOCAL_MAX_TOKENS,
-      // Small models degenerate into loops at low temperature — penalize
-      // repeated tokens so the answer moves forward instead of echoing.
-      repeatPenalty: { lastTokens: 128, penalty: 1.2, penalizeNewLine: false }
+  }
+  if (riskFiles.length) out.push({
+    severity: "\xC9lev\xE9e",
+    text: en ? `\`${riskFiles[0].file}\` changes constantly AND is complex (churn ${riskFiles[0].churn}, complexity ${riskFiles[0].score})${extras.untestedRisk.includes(riskFiles[0].file) ? " and has no dedicated test" : ""} \u2014 the classic defect magnet. Cover it with tests before touching it.` : `\`${riskFiles[0].file}\` change sans cesse ET est complexe (churn ${riskFiles[0].churn}, complexit\xE9 ${riskFiles[0].score})${extras.untestedRisk.includes(riskFiles[0].file) ? " et n\u2019a pas de test d\xE9di\xE9" : ""} \u2014 l'aimant \xE0 bugs classique. Couvrir de tests avant d'y toucher.`
+  });
+  if (extras.envUndoc.length) out.push({
+    severity: "Moyenne",
+    text: en ? `${extras.envUndoc.length} env var${extras.envUndoc.length > 1 ? "s" : ""} used but absent from .env.example (e.g. \`${extras.envUndoc[0]}\`) \u2014 document them or setup will break for the next dev.` : `${extras.envUndoc.length} variable${extras.envUndoc.length > 1 ? "s" : ""} d\u2019env utilis\xE9e${extras.envUndoc.length > 1 ? "s" : ""} mais absente${extras.envUndoc.length > 1 ? "s" : ""} de .env.example (ex. \`${extras.envUndoc[0]}\`) \u2014 les documenter sinon le setup cassera pour le prochain dev.`
+  });
+  if (extras.lockDrift.length) out.push({
+    severity: "Moyenne",
+    text: en ? `${extras.lockDrift.length} declared dep${extras.lockDrift.length > 1 ? "s" : ""} absent from the lockfile (${extras.lockDrift.map((d) => `\`${d}\``).join(", ")}) \u2014 run the package manager to resync.` : `${extras.lockDrift.length} d\xE9pendance${extras.lockDrift.length > 1 ? "s" : ""} d\xE9clar\xE9e${extras.lockDrift.length > 1 ? "s" : ""} absente${extras.lockDrift.length > 1 ? "s" : ""} du lockfile (${extras.lockDrift.map((d) => `\`${d}\``).join(", ")}) \u2014 relancer le package manager pour resynchroniser.`
+  });
+  if (extras.tsStrict === false) out.push({
+    severity: "Moyenne",
+    text: en ? "TypeScript `strict` is off \u2014 enable it progressively (`strict: true` or `strictNullChecks` first)." : "Le `strict` TypeScript est d\xE9sactiv\xE9 \u2014 l\u2019activer progressivement (`strict: true` ou `strictNullChecks` d\u2019abord)."
+  });
+  if (extras.deepRel > 3) out.push({
+    severity: "Moyenne",
+    text: en ? `${extras.deepRel} deep relative imports (\`../../..\` 3+ levels) \u2014 expose a public barrel or move the module closer.` : `${extras.deepRel} imports relatifs profonds (\`../../..\` 3+ niveaux) \u2014 exposer un barrel public ou rapprocher le module.`
+  });
+  if (extras.deepNest.length) out.push({
+    severity: "Moyenne",
+    text: en ? `Nesting \u22656 levels in ${extras.deepNest.map((d) => `\`${d}\``).join(", ")} \u2014 early returns / extraction will flatten it.` : `Imbrication \u22656 niveaux dans ${extras.deepNest.map((d) => `\`${d}\``).join(", ")} \u2014 early returns / extraction pour aplatir.`
+  });
+  if (extras.commitConv !== null && extras.commitConv < 50) out.push({
+    severity: "Faible",
+    text: en ? `Only ${extras.commitConv}% of commits are conventional \u2014 a shared format makes history machine-readable.` : `Seulement ${extras.commitConv}% des commits sont conventionnels \u2014 un format partag\xE9 rend l'historique lisible par machine.`
+  });
+  if (extras.deadDeps.length) out.push({
+    severity: "Faible",
+    text: en ? `${extras.deadDeps.length} declared dependenc${extras.deadDeps.length > 1 ? "ies are" : "y is"} never imported (e.g. \`${extras.deadDeps[0]}\`) \u2014 remove to shrink install + audit surface.` : `${extras.deadDeps.length} d\xE9pendance${extras.deadDeps.length > 1 ? "s" : ""} d\xE9clar\xE9e${extras.deadDeps.length > 1 ? "s" : ""} jamais import\xE9e${extras.deadDeps.length > 1 ? "s" : ""} (ex. \`${extras.deadDeps[0]}\`) \u2014 retirer pour r\xE9duire l\u2019install + la surface d\u2019audit.`
+  });
+  if (git2 && git2.fileAuthors.size) {
+    const soloHubs = riskFiles.filter((f) => (git2.fileAuthors.get(f.file)?.size ?? 0) <= 1);
+    const solo = [...git2.fileAuthors.entries()].filter(([, a]) => a.size === 1).length;
+    if (soloHubs.length || git2.churn.size && solo / git2.fileAuthors.size > 0.7) out.push({
+      severity: "Moyenne",
+      text: en ? `Bus factor: ${solo} file${solo > 1 ? "s" : ""} touched by a single author${soloHubs.length ? `, including hot \`${soloHubs[0].file}\`` : ""} \u2014 spread knowledge via reviews/pairing.` : `Bus factor : ${solo} fichier${solo > 1 ? "s" : ""} touch\xE9${solo > 1 ? "s" : ""} par un seul auteur${soloHubs.length ? `, dont le chaud \`${soloHubs[0].file}\`` : ""} \u2014 diffuser la connaissance via reviews/pairing.`
     });
-  } finally {
-    await context.dispose();
   }
+  if (!infra.some((i) => i.startsWith("CI"))) out.push({
+    severity: "Moyenne",
+    text: en ? "No CI pipeline detected \u2014 add one (tests + typecheck on every push)." : "Aucune CI d\xE9tect\xE9e \u2014 en ajouter une (tests + typecheck \xE0 chaque push)."
+  });
+  if (r.cycles.length) out.push({
+    severity: "Critique",
+    text: en ? `Break ${r.cycles.length} circular dependenc${r.cycles.length > 1 ? "ies" : "y"} \u2014 e.g. \`${r.cycles[0].path[0]}\` \u2194 \`${r.cycles[0].path[1] ?? r.cycles[0].path[0]}\`. Extract the shared contract into a leaf module.` : `Casser ${r.cycles.length} d\xE9pendance${r.cycles.length > 1 ? "s" : ""} circulaire${r.cycles.length > 1 ? "s" : ""} \u2014 ex. \`${r.cycles[0].path[0]}\` \u2194 \`${r.cycles[0].path[1] ?? r.cycles[0].path[0]}\`. Extraire le contrat partag\xE9 dans un module feuille.`
+  });
+  for (const h of r.hotspots.slice(0, 3)) out.push({
+    severity: "\xC9lev\xE9e",
+    text: en ? `Split \`${h.file}\` (complexity ${h.score}) \u2014 extract independent blocks into focused modules.` : `D\xE9couper \`${h.file}\` (complexit\xE9 ${h.score}) \u2014 extraire les blocs ind\xE9pendants dans des modules cibl\xE9s.`
+  });
+  if (r.duplicates.length) out.push({
+    severity: "Moyenne",
+    text: en ? `Factor ${r.duplicates.length} duplicated block${r.duplicates.length > 1 ? "s" : ""} \u2014 e.g. ${r.duplicates[0].files.map((f) => `\`${f}\``).join(" / ")} share ${r.duplicates[0].lines} identical lines.` : `Factoriser ${r.duplicates.length} bloc${r.duplicates.length > 1 ? "s" : ""} dupliqu\xE9${r.duplicates.length > 1 ? "s" : ""} \u2014 ex. ${r.duplicates[0].files.map((f) => `\`${f}\``).join(" / ")} partagent ${r.duplicates[0].lines} lignes identiques.`
+  });
+  if (r.unusedFiles.length) out.push({
+    severity: "Moyenne",
+    text: en ? `Review ${r.unusedFiles.length} unreferenced file${r.unusedFiles.length > 1 ? "s" : ""} \u2014 delete or wire them in (e.g. \`${r.unusedFiles[0]}\`).` : `V\xE9rifier ${r.unusedFiles.length} fichier${r.unusedFiles.length > 1 ? "s" : ""} non r\xE9f\xE9renc\xE9${r.unusedFiles.length > 1 ? "s" : ""} \u2014 supprimer ou brancher (ex. \`${r.unusedFiles[0]}\`).`
+  });
+  if (r.unusedExports.length > 5) out.push({
+    severity: "Faible",
+    text: en ? `Prune ${r.unusedExports.length} exports nobody imports \u2014 shrink the public surface.` : `Nettoyer ${r.unusedExports.length} exports que personne n'importe \u2014 r\xE9duire la surface publique.`
+  });
+  if (!hasTests) out.push({
+    severity: "\xC9lev\xE9e",
+    text: en ? "No test files detected \u2014 add a test suite before refactoring." : "Aucun fichier de test d\xE9tect\xE9 \u2014 ajouter une suite de tests avant de refactorer."
+  });
+  if (smells.console && smells.console.length > 5) out.push({
+    severity: "Faible",
+    text: en ? `${smells.console.length} console.* calls in production code \u2014 route through a logger (e.g. \`${smells.console[0].file}:${smells.console[0].line}\`).` : `${smells.console.length} appels console.* dans le code de prod \u2014 passer par un logger (ex. \`${smells.console[0].file}:${smells.console[0].line}\`).`
+  });
+  if (smells.todo && smells.todo.length > 5) out.push({
+    severity: "Faible",
+    text: en ? `${smells.todo.length} TODO/FIXME markers \u2014 triage into tracked issues.` : `${smells.todo.length} marqueurs TODO/FIXME \u2014 trier en tickets suivis.`
+  });
+  if (!out.length) out.push({
+    severity: "Faible",
+    text: en ? "Nothing structural to fix \u2014 keep the hygiene rules that got this score." : "Rien de structurel \xE0 corriger \u2014 garder les r\xE8gles d\u2019hygi\xE8ne qui ont produit ce score."
+  });
+  return out;
+}
+async function buildDeterministicReport(projectPath, lang = "fr") {
+  const en = lang === "en";
+  const [index, graph, health] = await Promise.all([
+    getIndex(projectPath),
+    collectImportGraph(projectPath),
+    analyzeProject(projectPath)
+  ]);
+  const name = basename3(health.projectPath);
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await readFile6(join8(health.projectPath, "package.json"), "utf8"));
+  } catch {
+  }
+  const langCount = /* @__PURE__ */ new Map();
+  for (const rel of Object.keys(index.files)) {
+    const l = EXT_LANG[extname3(rel).toLowerCase()];
+    if (!l) continue;
+    langCount.set(l, (langCount.get(l) ?? 0) + 1);
+  }
+  const langs = [...langCount.entries()].sort((a, b) => b[1] - a[1]);
+  const deps = Object.keys(pkg.dependencies ?? {});
+  const devDeps = Object.keys(pkg.devDependencies ?? {});
+  const scripts = Object.keys(pkg.scripts ?? {});
+  const symbols = Object.values(index.files).reduce((s, f) => s + f.chunks.filter((c) => c.name).length, 0);
+  const hubs = [...graph.inDegree.entries()].sort((a, b) => b[1] - a[1]).slice(0, 10);
+  const entryPoints = graph.codeFiles.filter((f) => looksLikeEntry(f, pkg)).slice(0, 10);
+  const leaves = graph.codeFiles.filter((f) => !graph.edges.some((e) => e.from === f)).length;
+  const testFiles = Object.keys(index.files).filter((f) => /test|spec|__tests__/i.test(f));
+  const srcFiles = graph.codeFiles.filter((f) => !/test|spec|__tests__/i.test(f));
+  const testRatio = srcFiles.length ? Math.round(testFiles.length / srcFiles.length * 100) : 0;
+  const largest = graph.codeFiles.map((f) => ({ f, lines: graph.fileTexts.get(f).split("\n").length })).sort((a, b) => b.lines - a.lines).slice(0, 5);
+  const indexPaths = new Set(Object.keys(index.files).map((f) => f.toLowerCase()));
+  const docs = ["readme.md", "license", "license.md", "changelog.md", "contributing.md", "security.md", "agents.md"].filter((d) => indexPaths.has(d));
+  const smells = scanCode(graph.fileTexts, SMELL_PATS);
+  const sec = scanCode(graph.fileTexts, SEC_PATS, 5);
+  const hasTests = testFiles.length > 0;
+  const git2 = await gitActivity(health.projectPath);
+  const infra = detectInfra(indexPaths);
+  const env = await envAudit(health.projectPath, graph.fileTexts);
+  const imported = importedPackages(graph.fileTexts);
+  const deadDeps = unusedDeps(deps, imported);
+  const missing = await missingDeps(health.projectPath, graph.fileTexts, pkg, indexPaths);
+  const lockDrift = await lockfileDrift(health.projectPath, deps);
+  const fnComplex = functionComplexity(index);
+  const dupNames = duplicateNames(graph.codeFiles);
+  const asyncNoAwait = asyncWithoutAwait(index);
+  const maxDepth = graphDepth(graph.edges, entryPoints);
+  const cfg = await configAudit(health.projectPath, pkg, indexPaths, !!git2);
+  const longFns = functionHotspots(index);
+  const brokenEntries = await brokenPkgEntries(health.projectPath, pkg);
+  const deepRel = deepImports(graph.fileTexts);
+  const shape = codeShape(graph.fileTexts);
+  const readme = await readmeAudit(health.projectPath);
+  const commitQ = git2 ? commitQuality(git2.subjects) : null;
+  const typedFiles = graph.codeFiles.filter((f) => /\.(ts|tsx)$/.test(f)).length;
+  const typedPct = graph.codeFiles.length ? Math.round(typedFiles / graph.codeFiles.length * 100) : 0;
+  const staleHubs = git2 ? hubs.filter(([f]) => git2.fileLastCommit.has(f)).map(([f, n]) => ({ f, n, last: git2.fileLastCommit.get(f) })).sort((a, b) => a.last.localeCompare(b.last)).slice(0, 5) : [];
+  const testBases = new Set(testFiles.map((f) => basename3(f).replace(/\.(test|spec)\.[^.]+$/i, "").toLowerCase()));
+  const sensitive = [...git2?.sensitiveTracked ?? []];
+  if (!git2) {
+    for (const rel of [".env", ".env.local", ".env.production"]) {
+      try {
+        await access(join8(health.projectPath, rel));
+        sensitive.push(rel);
+      } catch {
+      }
+    }
+  }
+  const docCov = docCoverage(graph.fileTexts);
+  const docPct = docCov.total ? Math.round(docCov.documented / docCov.total * 100) : 0;
+  const complexityByFile = new Map(health.hotspots.map((h) => [h.file, h.score]));
+  const riskFiles = git2 ? [...git2.churn.entries()].filter(([f]) => complexityByFile.has(f)).map(([file, churn]) => ({ file, churn, score: complexityByFile.get(file) })).sort((a, b) => b.churn * b.score - a.churn * a.score).slice(0, 5) : [];
+  const untestedRisk = riskFiles.filter((r) => !testBases.has(basename3(r.file).replace(/\.[^.]+$/, "").toLowerCase()));
+  const topChurn = git2 ? [...git2.churn.entries()].filter(([f]) => !/lock|\.min\.|dist\/|generated/i.test(f)).sort((a, b) => b[1] - a[1]).slice(0, 8) : [];
+  const t2 = en ? {
+    title: "Deterministic report",
+    genBy: "generated by static analysis \u2014 no LLM, no network",
+    summary: "Executive summary",
+    stack: "Stack & structure",
+    lang: "Languages",
+    deps: "Runtime deps",
+    devDeps: "Dev deps",
+    scripts: "Scripts",
+    arch: "Module graph",
+    hubs: "Hub modules (most imported)",
+    entries: "Entry points",
+    leaves: "leaf modules",
+    syms: "symbols extracted",
+    constraints: "Product constraints",
+    none: "None declared",
+    debt: "Debt & smells",
+    secu: "Security signals",
+    secuNone: "No risky pattern detected in scanned code.",
+    tests: "test/src file ratio",
+    largest: "Largest files",
+    docs: "Docs present",
+    infra: "Infra detected",
+    gitTitle: "Git activity & risk",
+    gitCommits: "commits",
+    gitAuthors: "authors",
+    gitLast: "last commit",
+    gitChurn: "Most churned files",
+    gitRisk: "Risk hotspots (churn \xD7 complexity)",
+    gitSolo: "single-author files",
+    docCov: "docstring coverage",
+    timeline: "Activity (commits/month)",
+    longestFns: "Longest functions",
+    untested: "Untested risk hotspots",
+    envUsed: "Env vars used",
+    envUndoc: "not documented in .env.example",
+    deadDeps: "Dependencies never imported",
+    sensitive: "Sensitive files present",
+    cfg: "Config hygiene",
+    cfgStrict: "tsconfig strict: off",
+    cfgGitignore: "no .gitignore",
+    cfgPkg: "package.json missing",
+    pkgBroken: "broken package entries",
+    typed: "typed files",
+    comments: "comment density",
+    deepImports: "Deep relative imports (3+ levels)",
+    deepNest: "Deep nesting (6+ levels)",
+    readmeTitle: "README audit",
+    readmeInstall: "install section",
+    readmeUsage: "usage section",
+    readmeCode: "code blocks",
+    readmeBadges: "badges",
+    commitQ: "Commit messages",
+    commitConv: "conventional",
+    staleHubs: "Stable core (hubs untouched longest)",
+    missingDeps: "imported but undeclared",
+    lockDrift: "absent from lockfile",
+    bigCommits: "Largest commits",
+    fnComplex: "Most complex functions",
+    dupNames: "Duplicate file names",
+    asyncNoAwait: "async without await",
+    graphDepth: "Max import chain depth",
+    reco: "Recommendations",
+    sev: "Severity",
+    action: "Action",
+    labels: {
+      todo: "TODO/FIXME markers",
+      console: "console.* calls",
+      tsIgnore: "@ts-ignore/-expect-error",
+      any: "`any` types",
+      emptyCatch: "empty catch blocks",
+      debugger: "debugger statements",
+      secret: "hardcoded secrets (suspected)",
+      eval: "eval / new Function",
+      exec: "child_process / execSync",
+      innerHTML: "innerHTML assignments",
+      unsafeRegex: "dynamic RegExp"
+    },
+    verdict: (g) => ({ A: "Excellent health \u2014 clean structure.", B: "Good health \u2014 minor debt.", C: "Correct \u2014 visible debt to watch.", D: "Fragile \u2014 refactor before growing.", E: "Critical \u2014 structural debt blocking." })[g] ?? ""
+  } : {
+    title: "Rapport d\xE9terministe",
+    genBy: "g\xE9n\xE9r\xE9 par analyse statique \u2014 aucun LLM, aucun r\xE9seau",
+    summary: "R\xE9sum\xE9 ex\xE9cutif",
+    stack: "Stack & structure",
+    lang: "Langages",
+    deps: "D\xE9pendances runtime",
+    devDeps: "D\xE9pendances dev",
+    scripts: "Scripts",
+    arch: "Graphe de modules",
+    hubs: "Modules hubs (les plus import\xE9s)",
+    entries: "Points d\u2019entr\xE9e",
+    leaves: "modules feuilles",
+    syms: "symboles extraits",
+    constraints: "Contraintes produit",
+    none: "Aucune d\xE9clar\xE9e",
+    debt: "Dette & smells",
+    secu: "Signaux s\xE9curit\xE9",
+    secuNone: "Aucun pattern risqu\xE9 d\xE9tect\xE9 dans le code scann\xE9.",
+    tests: "ratio tests/src",
+    largest: "Plus gros fichiers",
+    docs: "Docs pr\xE9sentes",
+    infra: "Infra d\xE9tect\xE9e",
+    gitTitle: "Activit\xE9 Git & risque",
+    gitCommits: "commits",
+    gitAuthors: "auteurs",
+    gitLast: "dernier commit",
+    gitChurn: "Fichiers les plus modifi\xE9s",
+    gitRisk: "Hotspots de risque (churn \xD7 complexit\xE9)",
+    gitSolo: "fichiers mono-auteur",
+    docCov: "couverture docstrings",
+    timeline: "Activit\xE9 (commits/mois)",
+    longestFns: "Fonctions les plus longues",
+    untested: "Hotspots \xE0 risque non test\xE9s",
+    envUsed: "Variables d\u2019env utilis\xE9es",
+    envUndoc: "non document\xE9es dans .env.example",
+    deadDeps: "D\xE9pendances jamais import\xE9es",
+    sensitive: "Fichiers sensibles pr\xE9sents",
+    cfg: "Hygi\xE8ne de config",
+    cfgStrict: "tsconfig strict : off",
+    cfgGitignore: "pas de .gitignore",
+    cfgPkg: "package.json incomplet",
+    pkgBroken: "entr\xE9es package cass\xE9es",
+    typed: "fichiers typ\xE9s",
+    comments: "densit\xE9 de commentaires",
+    deepImports: "Imports relatifs profonds (3+ niveaux)",
+    deepNest: "Imbrication profonde (6+ niveaux)",
+    readmeTitle: "Audit README",
+    readmeInstall: "section install",
+    readmeUsage: "section usage",
+    readmeCode: "blocs de code",
+    readmeBadges: "badges",
+    commitQ: "Messages de commit",
+    commitConv: "conventionnels",
+    staleHubs: "Noyau stable (hubs les plus anciens)",
+    missingDeps: "import\xE9s mais non d\xE9clar\xE9s",
+    lockDrift: "absentes du lockfile",
+    bigCommits: "Plus gros commits",
+    fnComplex: "Fonctions les plus complexes",
+    dupNames: "Noms de fichiers dupliqu\xE9s",
+    asyncNoAwait: "async sans await",
+    graphDepth: "Profondeur max des cha\xEEnes d\u2019imports",
+    reco: "Recommandations",
+    sev: "S\xE9v\xE9rit\xE9",
+    action: "Action",
+    labels: {
+      todo: "Marqueurs TODO/FIXME",
+      console: "Appels console.*",
+      tsIgnore: "@ts-ignore/-expect-error",
+      any: "Types `any`",
+      emptyCatch: "catch vides",
+      debugger: "Instructions debugger",
+      secret: "Secrets en dur (suspect\xE9s)",
+      eval: "eval / new Function",
+      exec: "child_process / execSync",
+      innerHTML: "Affectations innerHTML",
+      unsafeRegex: "RegExp dynamiques"
+    },
+    verdict: (g) => ({ A: "Excellente sant\xE9 \u2014 structure propre.", B: "Bonne sant\xE9 \u2014 dette mineure.", C: "Correct \u2014 dette visible \xE0 surveiller.", D: "Fragile \u2014 refactorer avant de grossir.", E: "Critique \u2014 dette structurelle bloquante." })[g] ?? ""
+  };
+  const out = [];
+  out.push(`# \u{1F4CA} ${t2.title} \u2014 \`${name}\``);
+  out.push(`_${t2.genBy}_`, "");
+  out.push(`## 1. ${t2.summary}`);
+  out.push(`**${bar(health.score)} ${health.score}/100 (${health.grade})** \u2014 ${t2.verdict(health.grade)}`);
+  out.push("");
+  out.push(`- ${health.analyzedFiles} ${en ? "code files" : "fichiers de code"} \xB7 ${symbols} ${t2.syms} \xB7 ${health.importEdges} ${en ? "local imports" : "imports locaux"} \xB7 ${leaves} ${t2.leaves}`);
+  out.push(`- ${testFiles.length} ${en ? "test files" : "fichiers de test"} (${testRatio}% ${t2.tests}) \xB7 ${countHits(smells)} ${en ? "smell hits" : "smells d\xE9tect\xE9s"} \xB7 ${countHits(sec)} ${en ? "security signals" : "signaux s\xE9curit\xE9"}`);
+  out.push(`- ${docCov.documented}/${docCov.total} ${en ? "exports documented" : "exports document\xE9s"} (${docPct}% ${t2.docCov})`);
+  if (git2) out.push(`- ${git2.commits} ${t2.gitCommits} \xB7 ${git2.authors.size} ${en ? "author(s)" : "auteur(s)"} \xB7 ${t2.gitLast} : ${git2.lastDate}`);
+  out.push("");
+  out.push(`## 2. ${t2.stack}`);
+  if (pkg.name) out.push(`- **${en ? "Package" : "Package"}** : \`${pkg.name}${pkg.version ? `@${pkg.version}` : ""}\``);
+  if (langs.length) out.push(`- **${t2.lang}** : ${langs.map(([l, n]) => `${l} (${n})`).join(", ")}`);
+  if (deps.length) out.push(`- **${t2.deps}** (${deps.length}) : ${deps.slice(0, 12).map((d) => `\`${d}\``).join(", ")}${deps.length > 12 ? " \u2026" : ""}`);
+  if (devDeps.length) out.push(`- **${t2.devDeps}** (${devDeps.length}) : ${devDeps.slice(0, 8).map((d) => `\`${d}\``).join(", ")}${devDeps.length > 8 ? " \u2026" : ""}`);
+  if (scripts.length) out.push(`- **${t2.scripts}** : ${scripts.map((s) => `\`${s}\``).join(", ")}`);
+  if (docs.length) out.push(`- **${t2.docs}** : ${docs.map((d) => `\`${d}\``).join(", ")}`);
+  if (infra.length) out.push(`- **${t2.infra}** : ${infra.map((i) => `\`${i}\``).join(", ")}`);
+  if (env.used.length) out.push(`- **${t2.envUsed}** (${env.used.length}) : ${env.used.slice(0, 10).map((v) => `\`${v}\``).join(", ")}${env.used.length > 10 ? " \u2026" : ""}`);
+  if (env.undocumented.length && env.hasTemplate) out.push(`  - \u26A0\uFE0F ${env.undocumented.length} ${t2.envUndoc} : ${env.undocumented.slice(0, 8).map((v) => `\`${v}\``).join(", ")}`);
+  if (deadDeps.length) out.push(`- **${t2.deadDeps}** : ${deadDeps.map((d) => `\`${d}\``).join(", ")}`);
+  if (missing.length) out.push(`- \u26A0\uFE0F **${en ? "Deps" : "Deps"} ${t2.missingDeps}** : ${missing.map((d) => `\`${d}\``).join(", ")}`);
+  if (lockDrift.length) out.push(`- \u26A0\uFE0F ${lockDrift.length} ${en ? "deps" : "deps"} ${t2.lockDrift} : ${lockDrift.map((d) => `\`${d}\``).join(", ")}`);
+  const cfgNotes = [];
+  if (cfg.tsStrict === false) cfgNotes.push(t2.cfgStrict);
+  if (cfg.isGit && !cfg.gitignore) cfgNotes.push(t2.cfgGitignore);
+  if (cfg.pkgMissing.length) cfgNotes.push(`${t2.cfgPkg} : ${cfg.pkgMissing.map((k) => `\`${k}\``).join(", ")}`);
+  if (cfgNotes.length) out.push(`- **${t2.cfg}** : ${cfgNotes.join(" \xB7 ")}`);
+  if (brokenEntries.length) out.push(`- \u26A0\uFE0F **${t2.pkgBroken}** : ${brokenEntries.map((e) => `\`${e}\``).join(", ")}`);
+  out.push(`- ${typedPct}% ${t2.typed} (${typedFiles}/${graph.codeFiles.length}) \xB7 ${shape.commentPct}% ${t2.comments}`);
+  if (readme) {
+    const ok = (b) => b ? "\u2705" : "\u274C";
+    out.push(`- **${t2.readmeTitle}** : ${t2.readmeInstall} ${ok(readme.install)} \xB7 ${t2.readmeUsage} ${ok(readme.usage)} \xB7 ${readme.codeBlocks} ${t2.readmeCode} \xB7 ${readme.badges} ${t2.readmeBadges}`);
+  }
+  out.push("");
+  out.push(`## 3. ${t2.arch}`);
+  if (hubs.length) {
+    out.push(`**${t2.hubs}** :`, "");
+    for (const [f, n] of hubs) out.push(`- \`${f}\` \u2190 ${n} ${en ? "importers" : "importeurs"}`);
+    out.push("");
+  }
+  if (entryPoints.length) {
+    out.push(`**${t2.entries}** : ${entryPoints.map((f) => `\`${f}\``).join(", ")}`, "");
+  }
+  if (largest.length) {
+    out.push(`**${t2.largest}** : ${largest.map((x) => `\`${x.f}\` (${x.lines}l)`).join(", ")}`, "");
+  }
+  if (longFns.length) {
+    out.push(`**${t2.longestFns}** :`, "");
+    for (const f of longFns) out.push(`- \`${f.file}\` \u2192 \`${f.name}\` (${f.lines}l)`);
+    out.push("");
+  }
+  if (deepRel.length) {
+    out.push(`**${t2.deepImports}** \u2014 ${deepRel.length} :`, "");
+    for (const d of deepRel.slice(0, 5)) out.push(`- \`${d.file}:${d.line}\` \u2192 \`${d.sample}\``);
+    out.push("");
+  }
+  if (shape.deepNest.length) {
+    out.push(`**${t2.deepNest}** : ${shape.deepNest.map((d) => `\`${d.file}\` (${d.depth})`).join(", ")}`, "");
+  }
+  if (maxDepth > 0) out.push(`- **${t2.graphDepth}** : ${maxDepth}`);
+  if (fnComplex.length) {
+    out.push(`**${t2.fnComplex}** :`, "");
+    for (const f of fnComplex) out.push(`- \`${f.file}\` \u2192 \`${f.name}\` (${f.score} ${en ? "branches" : "branchements"})`);
+    out.push("");
+  }
+  if (dupNames.length) {
+    out.push(`**${t2.dupNames}** :`, "");
+    for (const d of dupNames) out.push(`- \`${d.name}\` \u2192 ${d.files.map((f) => `\`${f}\``).join(", ")}`);
+    out.push("");
+  }
+  if (git2) {
+    out.push(`## 4. ${t2.gitTitle}`, "");
+    const topAuthors = [...git2.authors.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([a, n]) => `${a} (${n})`).join(", ");
+    const soloCount = [...git2.fileAuthors.values()].filter((a) => a.size === 1).length;
+    out.push(`- ${git2.commits} ${t2.gitCommits} \xB7 **${t2.gitAuthors}** : ${topAuthors}`);
+    out.push(`- ${soloCount} ${t2.gitSolo}`);
+    if (commitQ) out.push(`- ${t2.commitQ} : ${commitQ.conventionalPct}% ${t2.commitConv} \xB7 ~${commitQ.avgLen} ${en ? "chars" : "car."}`);
+    out.push("");
+    out.push(`**${t2.gitChurn}** :`, "");
+    for (const [f, c] of topChurn) {
+      const n = git2.fileAuthors.get(f)?.size ?? 0;
+      out.push(`- \`${f}\` \u2014 ${c} ${en ? "lines changed" : "lignes modifi\xE9es"} \xB7 ${n} ${en ? "author(s)" : "auteur(s)"}`);
+    }
+    out.push("");
+    if (riskFiles.length) {
+      out.push(`**${t2.gitRisk}** :`, "");
+      for (const r of riskFiles) {
+        const tested = testBases.has(basename3(r.file).replace(/\.[^.]+$/, "").toLowerCase());
+        out.push(`- \`${r.file}\` \u2014 churn ${r.churn} \xD7 ${en ? "complexity" : "complexit\xE9"} ${r.score}${tested ? "" : en ? " \xB7 \u26A0\uFE0F no test" : " \xB7 \u26A0\uFE0F sans test"}`);
+      }
+      out.push("");
+      if (untestedRisk.length) out.push(`_${t2.untested} : ${untestedRisk.map((r) => `\`${r.file}\``).join(", ")}_`, "");
+    }
+    if (git2.months.size > 1) {
+      const months = [...git2.months.entries()].sort().slice(-12);
+      const max = Math.max(...months.map(([, n]) => n));
+      out.push(`**${t2.timeline}** :`, "");
+      out.push("```");
+      for (const [m, n] of months) out.push(`${m} ${"\u2587".repeat(Math.max(1, Math.round(n / max * 20)))} ${n}`);
+      out.push("```", "");
+    }
+    if (staleHubs.length) {
+      out.push(`**${t2.staleHubs}** :`, "");
+      for (const s of staleHubs) out.push(`- \`${s.f}\` \u2190 ${s.n} ${en ? "importers" : "importeurs"} \xB7 ${en ? "last change" : "derni\xE8re modif"} ${s.last}`);
+      out.push("");
+    }
+    if (git2.commitSizes.length) {
+      const big = [...git2.commitSizes].sort((a, b) => b.lines - a.lines).slice(0, 3);
+      out.push(`**${t2.bigCommits}** : ${big.map((c) => `${c.lines} ${en ? "lines" : "lignes"} / ${c.files} ${en ? "files" : "fichiers"}`).join(" \xB7 ")}`, "");
+    }
+  }
+  out.push(`## 5. ${t2.debt}`);
+  const smellKeys = Object.keys(smells);
+  if (!smellKeys.length) out.push(en ? "_Nothing detected._" : "_Rien d\xE9tect\xE9._");
+  for (const key of smellKeys) {
+    const hits = smells[key];
+    out.push(`- **${t2.labels[key] ?? key}** \u2014 ${hits.length}${en ? " hit" + (hits.length > 1 ? "s" : "") : ""}`);
+    for (const h of hits.slice(0, 4)) out.push(`  - \`${h.file}:${h.line}\` \u2014 ${h.sample}`);
+    if (hits.length > 4) out.push(`  - _\u2026${hits.length - 4} ${en ? "more" : "autres"}_`);
+  }
+  if (asyncNoAwait.length) {
+    out.push(`- **${t2.asyncNoAwait}** \u2014 ${asyncNoAwait.length}`);
+    for (const a of asyncNoAwait.slice(0, 5)) out.push(`  - \`${a.file}\` \u2192 \`${a.name}\``);
+  }
+  out.push("");
+  out.push(`## 6. ${t2.secu}`);
+  if (sensitive.length) {
+    out.push(`- **${t2.sensitive}** \u2014 ${sensitive.length}`);
+    for (const f of sensitive.slice(0, 6)) out.push(`  - \`${f}\`${git2?.sensitiveTracked.includes(f) ? en ? " (tracked by git!)" : " (suivi par git !)" : ""}`);
+  }
+  const secKeys = Object.keys(sec);
+  if (!secKeys.length && !sensitive.length) out.push(`_${t2.secuNone}_`);
+  for (const key of secKeys) {
+    const hits = sec[key];
+    out.push(`- **${t2.labels[key] ?? key}** \u2014 ${hits.length}`);
+    for (const h of hits.slice(0, 5)) out.push(`  - \`${h.file}:${h.line}\` \u2014 ${h.sample}`);
+    if (hits.length > 5) out.push(`  - _\u2026${hits.length - 5} ${en ? "more" : "autres"}_`);
+  }
+  out.push("");
+  out.push(`## 7. ${t2.constraints}`);
+  out.push(index.constraints.length ? index.constraints.map((c) => `- ${c}`).join("\n") : t2.none, "");
+  out.push(formatHealthReportMd(health, lang).replace(/^## /, "## 8. ").replace(/\n### /g, "\n#### "), "");
+  out.push(`## 9. ${t2.reco}`, "");
+  out.push(`| ${t2.sev} | ${t2.action} |`, "|---|---|");
+  const SEV_ICON = { Critique: "\u{1F534}", "\xC9lev\xE9e": "\u{1F7E0}", Moyenne: "\u{1F7E1}", Faible: "\u{1F535}" };
+  for (const r of recommendations(health, hasTests, smells, sec, git2, infra, riskFiles, { sensitive, envUndoc: env.undocumented, deadDeps, tsStrict: cfg.tsStrict, untestedRisk: untestedRisk.map((r2) => r2.file), brokenEntries, deepRel: deepRel.length, deepNest: shape.deepNest.map((d) => d.file), commitConv: commitQ?.conventionalPct ?? null, missingDeps: missing, lockDrift }, lang)) out.push(`| ${SEV_ICON[r.severity]} ${r.severity} | ${r.text} |`);
+  out.push("");
+  out.push("---");
+  out.push(`_${en ? "Made with passion by shinzarou-eng" : "Fait avec passion par shinzarou-eng"} \u2014 dsh-codebase-chat \xB7 ${en ? "deterministic mode" : "mode d\xE9terministe"}_`);
+  return out.join("\n");
 }
 
 // src/cli.ts
@@ -2659,7 +3624,7 @@ Usage:
   npx dsh-codebase-chat --project <path> --watch
   npx dsh-codebase-chat --project <path> --prompt intelligence
   npx dsh-codebase-chat --project <path> --prompt intelligence --call   # answered via DEEPSEEK_API_KEY
-  npx dsh-codebase-chat --project <path> --prompt intelligence --local  # answered 100% offline
+  npx dsh-codebase-chat --project <path> --prompt intelligence --no-llm # deterministic report, zero model
 
 Options:
   -p, --project <path>   Project directory (default: current directory)
@@ -2680,8 +3645,8 @@ Options:
   --call                 With --prompt: send it to the API (needs DEEPSEEK_API_KEY
                          or OPENAI_API_KEY; DEEPSEEK_BASE_URL / CODEBASE_MODEL
                          customize endpoint/model) instead of printing it.
-  --local                With --prompt: answer with the embedded local model
-                         (node-llama-cpp, ~1 GB download on first use, offline).
+  --no-llm               With --prompt: deterministic full report \u2014 pure static
+                         analysis, no model, no key, no network.
   -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)
@@ -2711,7 +3676,7 @@ async function main() {
       focus: { type: "string" },
       style: { type: "string" },
       call: { type: "boolean", default: false },
-      local: { type: "boolean", default: false },
+      "no-llm": { type: "boolean", default: false },
       watch: { type: "boolean", short: "w", default: false },
       embed: { type: "boolean", short: "e", default: false },
       lang: { type: "string" },
@@ -2809,7 +3774,11 @@ async function main() {
       console.error(lang === "en" ? `--prompt ${mode} needs a query: add --ask/--search/--file (or --focus)` : `--prompt ${mode} n\xE9cessite une requ\xEAte : ajoute --ask/--search/--file (ou --focus)`);
       exit(1);
     }
-    const useLocal = values.local || isLocalLlmEnabled();
+    if (values["no-llm"]) {
+      const report = await buildDeterministicReport(values.project, lang);
+      console.log(process.stdout.isTTY ? renderAnswerTerminal(report) : report);
+      exit(0);
+    }
     const result = await buildContext({
       project: values.project,
       query,
@@ -2817,8 +3786,7 @@ async function main() {
       filePath: values.file,
       lang,
       embed: values.embed,
-      diff: values.diff,
-      maxTokens: useLocal ? 3500 : void 0
+      diff: values.diff
     });
     let staticSection = "";
     if ((/* @__PURE__ */ new Set(["intelligence", "report", "audit", "tasks", "ceo"])).has(mode)) {
@@ -2831,14 +3799,10 @@ ${formatHealthReport(report, lang)}`;
       } catch {
       }
     }
-    const projectName = basename3(result.absProject);
+    const projectName = basename4(result.absProject);
     let prompt;
     try {
-      prompt = useLocal ? `${result.context}${staticSection}
-
-${lang === "en" ? `Answer based only on the codebase context above (${mode} mode). Structure your answer in short sections with bullet points, and cite each fact as [source: path:line].${query ? ` Question: ${query}` : ""}` : `R\xE9ponds en t'appuyant uniquement sur le contexte du codebase ci-dessus (mode ${mode}). Structure ta r\xE9ponse en sections courtes avec des puces, et cite chaque fait avec [source: fichier:ligne].${query ? ` Question : ${query}` : ""}`}
-
-${lang === "en" ? "Answer" : "R\xE9ponse"} :` : buildToolPrompt(tool, {
+      prompt = buildToolPrompt(tool, {
         context: `${result.context}${staticSection}`,
         projectName,
         lang,
@@ -2852,12 +3816,6 @@ ${lang === "en" ? "Answer" : "R\xE9ponse"} :` : buildToolPrompt(tool, {
       console.error(lang === "en" ? `unknown prompt mode "${mode}" \u2014 expected: intelligence, report, audit, tasks, ceo, player, chat, search, explain, refactor, crea` : `mode de prompt inconnu "${mode}" \u2014 attendu : intelligence, report, audit, tasks, ceo, player, chat, search, explain, refactor, crea`);
       exit(1);
     }
-    if (values.local || isLocalLlmEnabled()) {
-      console.error(lang === "en" ? "Answering with the embedded local model (first run downloads ~1 GB)..." : "R\xE9ponse via le mod\xE8le local embarqu\xE9 (premier lancement : ~1 Go de t\xE9l\xE9chargement)...");
-      const answer = await callLocalLlm(prompt, lang);
-      console.log(process.stdout.isTTY ? renderAnswerTerminal(answer) : answer);
-      exit(0);
-    }
     if (values.call) {
       const apiKey = process.env.DEEPSEEK_API_KEY || process.env.OPENAI_API_KEY || "";
       if (!apiKey) {