dsh-codebase-chat 0.19.0 → 0.22.0

package/dist/cli.js

@@ -4,7 +4,7 @@
 import { parseArgs } from "util";
 
 // src/context.ts
-import { join as join3 } from "path";
+import { join as join5 } from "path";
 
 // src/tokenizer.ts
 import { encode, decode } from "gpt-tokenizer";
@@ -33,14 +33,281 @@ function truncateToTokens(text, maxTokens) {
 }
 
 // src/indexer.ts
-import { mkdir, readFile as readFile2, stat as stat2, writeFile } from "fs/promises";
-import { dirname, join as join2, relative, sep } from "path";
+import { mkdir, readFile as readFile3, stat as stat2, writeFile } from "fs/promises";
+import { dirname as dirname2, join as join4, relative as relative2, sep as sep2 } from "path";
 import { existsSync } from "fs";
 
 // src/extractor.ts
 import { parse } from "@babel/parser";
 import traverse from "@babel/traverse";
 import * as t from "@babel/types";
+
+// src/merge-gaps.ts
+function mergeGaps(content, relPath, namedChunks, visitedRanges) {
+  const lines = content.split("\n");
+  if (lines.length === 0) return namedChunks;
+  const covered = /* @__PURE__ */ new Set();
+  for (const [start2, end] of visitedRanges) {
+    for (let i = start2; i <= end; i++) covered.add(i);
+  }
+  const all = [];
+  let start = 1;
+  for (let i = 1; i <= lines.length; i++) {
+    if (!covered.has(i)) continue;
+    if (i > start) {
+      const gapText = lines.slice(start - 1, i - 1).join("\n");
+      if (gapText.trim()) all.push({ relPath, startLine: start, endLine: i - 1, content: gapText, tokens: countTokens(gapText), kind: "file" });
+    }
+    start = i + 1;
+  }
+  if (start <= lines.length) {
+    const gapText = lines.slice(start - 1).join("\n");
+    if (gapText.trim()) all.push({ relPath, startLine: start, endLine: lines.length, content: gapText, tokens: countTokens(gapText), kind: "file" });
+  }
+  return [...all, ...namedChunks].sort((a, b) => a.startLine - b.startLine);
+}
+
+// src/treesitter.ts
+import { createRequire } from "module";
+import { dirname, join } from "path";
+var require2 = createRequire(import.meta.url);
+var GRAMMAR_BY_EXT = {
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".cs": "c_sharp",
+  ".php": "php"
+};
+var DECL_TYPES = {
+  python: {
+    function_definition: "function",
+    class_definition: "class"
+  },
+  go: {
+    function_declaration: "function",
+    method_declaration: "method",
+    type_declaration: "type",
+    import_declaration: "import",
+    const_declaration: "unknown",
+    var_declaration: "unknown"
+  },
+  rust: {
+    function_item: "function",
+    struct_item: "type",
+    enum_item: "type",
+    union_item: "type",
+    trait_item: "type",
+    type_item: "type",
+    impl_item: "type",
+    mod_item: "unknown",
+    use_declaration: "import",
+    macro_definition: "unknown"
+  },
+  java: {
+    class_declaration: "class",
+    interface_declaration: "type",
+    enum_declaration: "type",
+    record_declaration: "type",
+    annotation_type_declaration: "type",
+    method_declaration: "method",
+    constructor_declaration: "method",
+    field_declaration: "unknown",
+    import_declaration: "import",
+    package_declaration: "import"
+  },
+  c_sharp: {
+    class_declaration: "class",
+    interface_declaration: "type",
+    struct_declaration: "type",
+    enum_declaration: "type",
+    record_declaration: "type",
+    delegate_declaration: "type",
+    method_declaration: "method",
+    constructor_declaration: "method",
+    property_declaration: "method",
+    field_declaration: "unknown",
+    using_directive: "import"
+  },
+  php: {
+    function_definition: "function",
+    class_declaration: "class",
+    interface_declaration: "type",
+    trait_declaration: "type",
+    enum_declaration: "type",
+    method_declaration: "method",
+    namespace_use_declaration: "import",
+    namespace_definition: "unknown"
+  }
+};
+var RECURSE_INTO = /* @__PURE__ */ new Set([
+  "program",
+  "module",
+  "translation_unit",
+  "compilation_unit",
+  "source_file",
+  "namespace_declaration",
+  "file_scoped_namespace_declaration",
+  "namespace_definition",
+  "declaration_list",
+  "decorated_definition",
+  "export_statement"
+]);
+var CONTAINER_TYPES = /* @__PURE__ */ new Set([
+  "class_definition",
+  "class_declaration",
+  "interface_declaration",
+  "enum_declaration",
+  "record_declaration",
+  "struct_declaration",
+  "impl_item",
+  "trait_item",
+  "trait_declaration"
+]);
+var MEMBER_TYPES = /* @__PURE__ */ new Set([
+  "function_definition",
+  "method_declaration",
+  "method_definition",
+  "function_item",
+  "constructor_declaration",
+  "property_declaration"
+]);
+var NAME_TYPES = /* @__PURE__ */ new Set([
+  "identifier",
+  "type_identifier",
+  "field_identifier",
+  "simple_type",
+  "name"
+]);
+var parser = null;
+var initPromise = null;
+var languages = /* @__PURE__ */ new Map();
+var langPromises = /* @__PURE__ */ new Map();
+async function initTreeSitter() {
+  if (parser) return true;
+  initPromise ??= (async () => {
+    try {
+      const mod = await import("web-tree-sitter");
+      const ParserClass = mod.default ?? mod;
+      const wasm = require2.resolve("web-tree-sitter/tree-sitter.wasm");
+      await ParserClass.init({ locateFile: () => wasm });
+      parser = new ParserClass();
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return initPromise;
+}
+function grammarPath(name) {
+  const pkg = require2.resolve("tree-sitter-wasms/package.json");
+  return join(dirname(pkg), "out", `tree-sitter-${name}.wasm`);
+}
+async function ensureLanguage(name) {
+  if (languages.has(name)) return languages.get(name);
+  let p = langPromises.get(name);
+  if (!p) {
+    p = (async () => {
+      try {
+        const mod = await import("web-tree-sitter");
+        const ParserClass = mod.default ?? mod;
+        const lang = await ParserClass.Language.load(grammarPath(name));
+        languages.set(name, lang);
+        return lang;
+      } catch {
+        languages.set(name, null);
+        return null;
+      }
+    })();
+    langPromises.set(name, p);
+  }
+  return p;
+}
+async function ensureTreeSitterForExt(ext) {
+  const name = GRAMMAR_BY_EXT[ext.toLowerCase()];
+  if (!name) return false;
+  if (!await initTreeSitter()) return false;
+  return await ensureLanguage(name) != null;
+}
+function disposeTreeSitter() {
+  try {
+    parser?.delete();
+  } catch {
+  }
+  parser = null;
+  initPromise = null;
+  languages.clear();
+  langPromises.clear();
+}
+function treeSitterReady(ext) {
+  const name = GRAMMAR_BY_EXT[ext.toLowerCase()];
+  return !!name && !!parser && languages.get(name) != null;
+}
+function nodeName(node) {
+  const named = node.childForFieldName("name");
+  if (named) return named.text;
+  for (const child of node.namedChildren) {
+    if (NAME_TYPES.has(child.type)) return child.text;
+    const inner = child.childForFieldName("name");
+    if (inner) return inner.text;
+  }
+  return void 0;
+}
+function toChunk(node, kind, relPath, content, name) {
+  const startLine = node.startPosition.row + 1;
+  const endLine = node.endPosition.row + 1;
+  const text = content.split("\n").slice(startLine - 1, endLine).join("\n");
+  return { relPath, startLine, endLine, content: text, tokens: countTokens(text), kind, name };
+}
+function extractWithTreeSitter(ext, relPath, content) {
+  if (!parser || !treeSitterReady(ext)) return void 0;
+  const name = GRAMMAR_BY_EXT[ext.toLowerCase()];
+  const lang = languages.get(name);
+  const declTypes = DECL_TYPES[name] ?? {};
+  let tree;
+  try {
+    parser.setLanguage(lang);
+    tree = parser.parse(content);
+  } catch {
+    return void 0;
+  }
+  if (!tree) return void 0;
+  try {
+    const chunks = [];
+    const visitedRanges = [];
+    const handle = (child) => {
+      const kind = declTypes[child.type];
+      if (kind) {
+        const target = child.parent?.type === "decorated_definition" ? child.parent : child;
+        chunks.push(toChunk(target, kind, relPath, content, nodeName(child)));
+        visitedRanges.push([target.startPosition.row + 1, target.endPosition.row + 1]);
+        if (CONTAINER_TYPES.has(child.type)) {
+          const body = child.childForFieldName("body") ?? child;
+          for (const member of body.namedChildren) {
+            if (MEMBER_TYPES.has(member.type)) {
+              chunks.push(toChunk(member, "method", relPath, content, nodeName(member)));
+            } else if (declTypes[member.type]) {
+              handle(member);
+            }
+          }
+        }
+        return;
+      }
+      if (RECURSE_INTO.has(child.type) || child.namedChildren.some((c) => declTypes[c.type] || RECURSE_INTO.has(c.type))) {
+        visit(child);
+      }
+    };
+    const visit = (node) => {
+      for (const child of node.namedChildren) handle(child);
+    };
+    visit(tree.rootNode);
+    return mergeGaps(content, relPath, chunks, visitedRanges);
+  } finally {
+    tree.delete();
+  }
+}
+
+// src/extractor.ts
 var JS_LIKE = /* @__PURE__ */ new Set([
   ".js",
   ".jsx",
@@ -162,51 +429,6 @@ function extractTopLevelWithBabel(relPath, content) {
   });
   return mergeGaps(content, relPath, chunks, visitedRanges);
 }
-function mergeGaps(content, relPath, namedChunks, visitedRanges) {
-  const lines = content.split("\n");
-  if (lines.length === 0) return namedChunks;
-  const covered = /* @__PURE__ */ new Set();
-  for (const [start2, end] of visitedRanges) {
-    for (let i = start2; i <= end; i++) covered.add(i);
-  }
-  const all = [];
-  let start = 1;
-  for (let i = 1; i <= lines.length; i++) {
-    if (!covered.has(i)) {
-      if (i === start) {
-        start++;
-        continue;
-      }
-      continue;
-    }
-    if (i > start) {
-      const gap = {
-        relPath,
-        startLine: start,
-        endLine: i - 1,
-        content: lines.slice(start - 1, i - 1).join("\n"),
-        tokens: 0,
-        kind: "file"
-      };
-      gap.tokens = countTokens(gap.content);
-      if (gap.content.trim()) all.push(gap);
-    }
-    start = i + 1;
-  }
-  if (start <= lines.length) {
-    const gap = {
-      relPath,
-      startLine: start,
-      endLine: lines.length,
-      content: lines.slice(start - 1).join("\n"),
-      tokens: 0,
-      kind: "file"
-    };
-    gap.tokens = countTokens(gap.content);
-    if (gap.content.trim()) all.push(gap);
-  }
-  return [...all, ...namedChunks].sort((a, b) => a.startLine - b.startLine);
-}
 function extractWithRegex(relPath, content) {
   const lines = content.split("\n");
   const chunks = [];
@@ -255,6 +477,13 @@ function extractChunks(relPath, content) {
       return extractWithRegex(relPath, content);
     }
   }
+  if (treeSitterReady(ext)) {
+    try {
+      const chunks = extractWithTreeSitter(ext, relPath, content);
+      if (chunks && chunks.length) return chunks;
+    } catch {
+    }
+  }
   return extractWithRegex(relPath, content);
 }
 
@@ -309,10 +538,64 @@ function cosineSimilarity(a, b) {
 }
 
 // src/project.ts
-import { readdir, readFile, stat } from "fs/promises";
-import { extname, join, resolve, isAbsolute } from "path";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import { extname, join as join3, relative, resolve, sep, isAbsolute } from "path";
 import { createHash } from "crypto";
 import { homedir } from "os";
+
+// src/config.ts
+import { readFile } from "fs/promises";
+import { join as join2 } from "path";
+var CONFIG_FILE = ".codebase-chat.json";
+var configCache = /* @__PURE__ */ new Map();
+function strArray(v) {
+  if (!Array.isArray(v)) return void 0;
+  const out = v.filter((x) => typeof x === "string" && x.trim().length > 0);
+  return out.length ? out.map((s) => s.trim()) : void 0;
+}
+function sanitize(raw) {
+  if (raw == null || typeof raw !== "object") return {};
+  const o = raw;
+  const cfg = {};
+  if (o.lang === "fr" || o.lang === "en") cfg.lang = o.lang;
+  if (typeof o.maxTokens === "number" && Number.isFinite(o.maxTokens) && o.maxTokens > 0) {
+    cfg.maxTokens = Math.floor(o.maxTokens);
+  }
+  const ignoreDirs = strArray(o.ignoreDirs);
+  if (ignoreDirs) cfg.ignoreDirs = ignoreDirs;
+  const ignoreFiles = strArray(o.ignoreFiles);
+  if (ignoreFiles) cfg.ignoreFiles = ignoreFiles;
+  const ignoreGlobs = strArray(o.ignoreGlobs);
+  if (ignoreGlobs) cfg.ignoreGlobs = ignoreGlobs;
+  const protectedPaths = strArray(o.protectedPaths);
+  if (protectedPaths) cfg.protectedPaths = protectedPaths;
+  return cfg;
+}
+async function loadProjectConfig(absProject) {
+  const cached = configCache.get(absProject);
+  if (cached) return cached;
+  let cfg = {};
+  try {
+    cfg = sanitize(JSON.parse(await readFile(join2(absProject, CONFIG_FILE), "utf8")));
+  } catch {
+  }
+  configCache.set(absProject, cfg);
+  return cfg;
+}
+function escapeSegment(s) {
+  return s.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]");
+}
+function globToRegExp(glob) {
+  const src = glob.replace(/\\/g, "/").split("**").map(escapeSegment).join(".*");
+  return new RegExp(`^${src}$`);
+}
+function matchesAnyGlob(relPath, globs) {
+  if (!globs || globs.length === 0) return false;
+  const rel = relPath.replace(/\\/g, "/");
+  return globs.some((g) => globToRegExp(g).test(rel));
+}
+
+// src/project.ts
 var SOURCE_EXTS = /* @__PURE__ */ new Set([
   ".ts",
   ".tsx",
@@ -368,6 +651,14 @@ var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
   ".dsh-vision-router"
 ]);
 var DEFAULT_SKIP_FILES = /* @__PURE__ */ new Set([]);
+async function getWalkOptions(absProject) {
+  const cfg = await loadProjectConfig(absProject);
+  return {
+    skipDirs: /* @__PURE__ */ new Set([...DEFAULT_SKIP_DIRS, ...cfg.ignoreDirs ?? []]),
+    skipFiles: /* @__PURE__ */ new Set([...DEFAULT_SKIP_FILES, ...cfg.ignoreFiles ?? []]),
+    ignoreGlobs: cfg.ignoreGlobs ?? []
+  };
+}
 function projectHash(absProject) {
   return createHash("sha256").update(absProject.toLowerCase()).digest("hex").slice(0, 16);
 }
@@ -388,16 +679,16 @@ async function findProjectRoot(absProject) {
   }
 }
 function getCacheDir() {
-  const base = process.env.CODEBASE_CACHE_DIR || process.env.LOCALAPPDATA || process.env.APPDATA || join(homedir(), ".cache");
-  return join(base, "dsh-codebase-chat-cache");
+  const base = process.env.CODEBASE_CACHE_DIR || process.env.LOCALAPPDATA || process.env.APPDATA || join3(homedir(), ".cache");
+  return join3(base, "dsh-codebase-chat-cache");
 }
 function cacheFilePath(absProject) {
-  return join(getCacheDir(), `${projectHash(absProject)}.json`);
+  return join3(getCacheDir(), `${projectHash(absProject)}.json`);
 }
 function fileHash(stats, firstBytes = "") {
   return createHash("sha256").update(`${stats.mtimeMs}:${stats.size}:${firstBytes.slice(0, 512)}`).digest("hex").slice(0, 24);
 }
-async function* walkFiles(startDir, skipDirs = DEFAULT_SKIP_DIRS, skipFiles = DEFAULT_SKIP_FILES) {
+async function* walkFiles(startDir, skipDirs = DEFAULT_SKIP_DIRS, skipFiles = DEFAULT_SKIP_FILES, ignoreGlobs = []) {
   const queue = [startDir];
   while (queue.length) {
     const dir = queue.shift();
@@ -408,13 +699,15 @@ async function* walkFiles(startDir, skipDirs = DEFAULT_SKIP_DIRS, skipFiles = DE
       continue;
     }
     for (const entry of entries) {
-      const fullPath = join(dir, entry.name);
+      const fullPath = join3(dir, entry.name);
+      const rel = relative(startDir, fullPath).split(sep).join("/");
       if (entry.isDirectory()) {
-        if (!skipDirs.has(entry.name)) queue.push(fullPath);
+        if (!skipDirs.has(entry.name) && !matchesAnyGlob(rel, ignoreGlobs)) queue.push(fullPath);
         continue;
       }
       if (!entry.isFile()) continue;
       if (skipFiles.has(entry.name)) continue;
+      if (matchesAnyGlob(rel, ignoreGlobs)) continue;
       const ext = extname(entry.name).toLowerCase();
       if (!SOURCE_EXTS.has(ext)) continue;
       yield fullPath;
@@ -423,7 +716,7 @@ async function* walkFiles(startDir, skipDirs = DEFAULT_SKIP_DIRS, skipFiles = DE
 }
 async function safeReadText(filePath) {
   try {
-    const text = await readFile(filePath, "utf8");
+    const text = await readFile2(filePath, "utf8");
     return text;
   } catch {
     return void 0;
@@ -443,7 +736,7 @@ async function buildTree(startDir, maxLines = 500, skipDirs = DEFAULT_SKIP_DIRS)
     for (const entry of entries) {
       if (lines.length >= maxLines) return;
       if (skipDirs.has(entry.name)) continue;
-      const fullPath = join(dir, entry.name);
+      const fullPath = join3(dir, entry.name);
       if (entry.isDirectory()) {
         lines.push(`${prefix}${entry.name}/`);
         await walk(fullPath, `${prefix}  `);
@@ -582,7 +875,7 @@ async function loadIndex(projectPath) {
   const p = cacheFilePath(absProject);
   if (!existsSync(p)) return null;
   try {
-    const raw = await readFile2(p, "utf8");
+    const raw = await readFile3(p, "utf8");
     const data = JSON.parse(raw);
     if (data.version !== INDEX_VERSION) return null;
     return data;
@@ -592,7 +885,7 @@ async function loadIndex(projectPath) {
 }
 async function saveIndex(index) {
   const p = cacheFilePath(index.projectPath);
-  await mkdir(dirname(p), { recursive: true });
+  await mkdir(dirname2(p), { recursive: true });
   await writeFile(p, JSON.stringify(index), "utf8");
 }
 async function embedIndex(index, progress) {
@@ -618,17 +911,18 @@ async function embedIndex(index, progress) {
 }
 async function buildIndex(projectPath, progress) {
   const absProject = await findProjectRoot(resolveProjectPath(projectPath));
-  const projectName = absProject.split(sep).pop() ?? "project";
+  const projectName = absProject.split(sep2).pop() ?? "project";
   progress?.(`Indexing ${projectName}...`);
-  const tree = await buildTree(absProject);
+  const walk = await getWalkOptions(absProject);
+  const tree = await buildTree(absProject, void 0, walk.skipDirs);
   const startDir = absProject;
   const previous = await loadIndex(absProject);
   const previousFiles = previous?.projectPath === absProject ? previous.files : {};
   const files = {};
   let totalTokens = 0;
   let reused = 0;
-  for await (const fullPath of walkFiles(startDir)) {
-    const relPath = relative(startDir, fullPath).split(sep).join("/");
+  for await (const fullPath of walkFiles(startDir, walk.skipDirs, walk.skipFiles, walk.ignoreGlobs)) {
+    const relPath = relative2(startDir, fullPath).split(sep2).join("/");
     progress?.(`Reading ${relPath}`);
     const fstats = await stat2(fullPath);
     const cached = previousFiles[relPath];
@@ -641,6 +935,8 @@ async function buildIndex(projectPath, progress) {
     const text = await safeReadText(fullPath);
     if (!text) continue;
     const hash = fileHash(fstats, text);
+    const ext = relPath.slice(relPath.lastIndexOf(".")).toLowerCase();
+    await ensureTreeSitterForExt(ext);
     const chunks = extractChunks(relPath, text).map((chunk) => ({
       ...chunk,
       // recompute tokens to be safe
@@ -678,7 +974,7 @@ async function getIndex(projectPath, progress, force = false) {
   if (existing && existing.projectPath === absProject) {
     let stale = false;
     for (const file of Object.values(existing.files)) {
-      const fullPath = join2(absProject, file.relPath);
+      const fullPath = join4(absProject, file.relPath);
       try {
         const fstats = await stat2(fullPath);
         if (fstats.mtimeMs !== file.mtimeMs || fstats.size !== file.size) {
@@ -897,7 +1193,7 @@ async function extractProductConstraints(absProject) {
   const candidates = ["README.md", "README.MD", "readme.md", "MEMORY.md", "CONTRIBUTING.md"];
   const constraints = [];
   for (const name of candidates) {
-    const text = await safeReadText(join3(absProject, name));
+    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;
     let m;
@@ -917,9 +1213,12 @@ function formatChunk(chunk) {
 ${chunk.content}`;
 }
 async function buildContext(options) {
-  const { project, query, filePath, searchQuery, maxTokens = DEFAULT_MAX_TOKENS, lang = "fr", instruction, embed = false } = options;
-  const labels = getLabels(lang);
+  const { project, query, filePath, searchQuery, instruction, embed = false } = 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);
   if (embed) {
     try {
@@ -991,8 +1290,8 @@ ${finalInstruction}`;
 }
 
 // src/analysis.ts
-import { basename, extname as extname2, join as join4, relative as relative2, sep as sep2, posix as posixPath } from "path";
-import { readFile as readFile3 } from "fs/promises";
+import { basename, extname as extname2, join as join6, relative as relative3, sep as sep3, 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"]);
 var SKIP_EXTS = /* @__PURE__ */ new Set([".d.ts", ".test.ts", ".test.js", ".spec.ts", ".spec.js", ".config.js", ".config.ts", ".config.mjs"]);
@@ -1068,6 +1367,8 @@ function findCycles(edges) {
 function looksLikeEntry(rel, pkg) {
   const base = basename(rel).toLowerCase().replace(extname2(rel), "");
   if (ENTRY_BASENAMES.has(base)) return true;
+  if (/\.(test|spec)\.[cm]?[jt]sx?$/.test(rel) || rel.includes("__tests__/") || /^e2e[.-]/.test(basename(rel))) return true;
+  if (/\.(config|rc)\.[cm]?[jt]s$/.test(rel)) return true;
   if (/^(pages|app|routes|api|bin|scripts)\//.test(rel) || rel.includes("/pages/") || rel.includes("/routes/")) return true;
   const fields = [pkg?.main, pkg?.module, pkg?.bin, pkg?.exports?.["."]];
   for (const f of fields.flatMap((v) => typeof v === "string" ? [v] : v ? Object.values(v) : [])) {
@@ -1108,8 +1409,9 @@ async function analyzeProject(projectPath) {
   const abs = await findProjectRoot(resolveProjectPath(projectPath));
   const fileTexts = /* @__PURE__ */ new Map();
   const codeFiles = [];
-  for await (const full of walkFiles(abs)) {
-    const rel = relative2(abs, full).split(sep2).join("/");
+  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 ext = extname2(rel).toLowerCase();
     if (!CODE_EXTS.has(ext) || SKIP_EXTS.has(ext) || rel.includes(".min.")) continue;
     const text = await safeReadText(full);
@@ -1119,7 +1421,7 @@ async function analyzeProject(projectPath) {
   }
   let pkg = {};
   try {
-    pkg = JSON.parse(await readFile3(join4(abs, "package.json"), "utf8"));
+    pkg = JSON.parse(await readFile4(join6(abs, "package.json"), "utf8"));
   } catch {
   }
   const known = new Set(codeFiles);
@@ -1159,7 +1461,7 @@ async function analyzeProject(projectPath) {
   hotspots.sort((a, b) => b.score - a.score);
   const codeLines = [...fileTexts.values()].reduce((s, t2) => s + t2.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) + hotspots.length * 2;
+  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 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 {
@@ -1170,7 +1472,7 @@ async function analyzeProject(projectPath) {
     unusedFiles,
     unusedExports,
     duplicates,
-    hotspots: hotspots.slice(0, 15),
+    hotspots,
     score,
     grade
   };
@@ -1224,6 +1526,17 @@ function formatHealthReport(r, lang = "fr") {
 }
 
 // src/cli.ts
+var ExitSignal = class {
+  constructor(code) {
+    this.code = code;
+  }
+  code;
+};
+function exit(code) {
+  disposeTreeSitter();
+  setTimeout(() => process.exit(code), 2e3).unref();
+  throw new ExitSignal(code);
+}
 function printHelp() {
   console.log(`
 dsh-codebase-chat CLI
@@ -1245,9 +1558,13 @@ Options:
   -t, --stats            Print indexing stats
   -H, --health           Deterministic static analysis (cycles, dead code, dupes, complexity)
   -e, --embed            Enable local semantic embeddings (slower, more relevant)
-  --lang <en|fr>         Language for headings (default: fr)
+  --lang <en|fr>         Language for headings (default: .codebase-chat.json lang, else fr)
   -h, --help             Show this help
 
+Config:
+  .codebase-chat.json    Per-project settings: lang, maxTokens, ignoreDirs,
+                         ignoreFiles, ignoreGlobs, protectedPaths
+
 Environment:
   CODEBASE_CACHE_DIR     Directory for the index cache
 `);
@@ -1263,20 +1580,21 @@ async function main() {
       stats: { type: "boolean", short: "t", default: false },
       health: { type: "boolean", short: "H", default: false },
       embed: { type: "boolean", short: "e", default: false },
-      lang: { type: "string", default: "fr" },
+      lang: { type: "string" },
       help: { type: "boolean", short: "h", default: false }
     },
     allowPositionals: false
   });
   if (values.help) {
     printHelp();
-    process.exit(0);
+    exit(0);
   }
-  const lang = values.lang === "en" ? "en" : "fr";
   const project = resolveProjectPath(values.project);
+  const cfg = await loadProjectConfig(project);
+  const lang = values.lang === "en" || values.lang === "fr" ? values.lang : cfg.lang ?? "fr";
   if (values.index) {
     await getIndex(project, (m) => console.log(m), true);
-    process.exit(0);
+    exit(0);
   }
   if (values.stats) {
     const index = await getIndex(project, (m) => console.log(m));
@@ -1288,12 +1606,12 @@ async function main() {
     console.log(`Tokens:  ${totalTokens}`);
     console.log(`Terms:   ${termCount}`);
     console.log(`Cache:   ${index.projectHash}`);
-    process.exit(0);
+    exit(0);
   }
   if (values.health) {
     const report = await analyzeProject(project);
     console.log(formatHealthReport(report, lang));
-    process.exit(0);
+    exit(0);
   }
   if (values.ask || values.search || values.file) {
     const result = await buildContext({
@@ -1310,13 +1628,19 @@ async function main() {
     console.log(`Project: ${result.absProject}`);
     console.log(`Chunks:  ${result.chunks.length}`);
     console.log(`Tokens:  ${result.tokenCount}`);
-    process.exit(0);
+    exit(0);
   }
   printHelp();
-  process.exit(1);
+  exit(1);
 }
 main().catch((err) => {
+  disposeTreeSitter();
+  if (err instanceof ExitSignal) {
+    process.exitCode = err.code;
+    return;
+  }
   console.error(err?.message ?? err);
-  process.exit(1);
+  process.exitCode = 1;
+  setTimeout(() => process.exit(1), 2e3).unref();
 });
 //# sourceMappingURL=cli.js.map