dsh-codebase-chat 0.16.4 → 0.21.0

package/dist/index.js

@@ -0,0 +1,1557 @@
+// src/context.ts
+import { join as join5 } from "path";
+
+// src/tokenizer.ts
+import { encode, decode } from "gpt-tokenizer";
+function countTokens(text) {
+  return encode(text).length;
+}
+function chunkByTokens(text, maxTokens, overlapTokens = 0) {
+  if (maxTokens <= 0) throw new RangeError("maxTokens must be positive");
+  const tokens = encode(text);
+  const chunks = [];
+  const step = maxTokens - overlapTokens;
+  for (let i = 0; i < tokens.length; i += step) {
+    const end = Math.min(i + maxTokens, tokens.length);
+    const slice = tokens.slice(i, end);
+    chunks.push(decode(slice));
+    if (end === tokens.length) break;
+  }
+  return chunks;
+}
+function truncateToTokens(text, maxTokens) {
+  const tokens = encode(text);
+  if (tokens.length <= maxTokens) return text;
+  const keep = Math.max(0, maxTokens - 5);
+  const truncated = tokens.slice(0, keep);
+  return `${decode(truncated)} [...]`;
+}
+
+// src/indexer.ts
+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",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx"
+]);
+function getName(node) {
+  if (t.isFunctionDeclaration(node) || t.isClassDeclaration(node) || t.isTSInterfaceDeclaration(node) || t.isTSTypeAliasDeclaration(node)) {
+    return node.id?.name;
+  }
+  if (t.isVariableDeclaration(node)) {
+    const first = node.declarations[0];
+    if (first && t.isIdentifier(first.id)) return first.id.name;
+  }
+  if (t.isObjectMethod(node) || t.isClassMethod(node) || t.isClassPrivateMethod(node)) {
+    const key = node.key;
+    if (t.isIdentifier(node.key) || t.isStringLiteral(node.key) || t.isNumericLiteral(node.key)) {
+      return String(key.name ?? key.value ?? "anonymous");
+    }
+    if (t.isPrivateName(node.key)) {
+      return node.key.id?.name;
+    }
+  }
+  if (t.isExportNamedDeclaration(node) && node.declaration) {
+    return getName(node.declaration);
+  }
+  if (t.isExportDefaultDeclaration(node) && node.declaration) {
+    if (t.isFunctionDeclaration(node.declaration) || t.isClassDeclaration(node.declaration)) {
+      return getName(node.declaration) ?? "default";
+    }
+    if (t.isVariableDeclaration(node.declaration)) {
+      return getName(node.declaration) ?? "default";
+    }
+    return "default";
+  }
+  return void 0;
+}
+function getKind(node) {
+  if (t.isClassMethod(node) || t.isClassPrivateMethod(node) || t.isObjectMethod(node)) return "method";
+  if (t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node)) return "function";
+  if (t.isClassDeclaration(node) || t.isClassExpression(node)) return "class";
+  if (t.isTSInterfaceDeclaration(node) || t.isTSTypeAliasDeclaration(node)) return "type";
+  if (t.isImportDeclaration(node) || t.isExportAllDeclaration(node) || t.isExportNamespaceSpecifier(node)) return "import";
+  if (t.isVariableDeclaration(node)) return "unknown";
+  if (t.isExportNamedDeclaration(node) && node.declaration) return getKind(node.declaration);
+  if (t.isExportDefaultDeclaration(node) && node.declaration) return getKind(node.declaration);
+  if (t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node)) return "import";
+  return "unknown";
+}
+function sliceLines(content, start, end) {
+  const lines = content.split("\n");
+  return lines.slice(start - 1, end).join("\n");
+}
+function extractTopLevelWithBabel(relPath, content) {
+  const ast = parse(content, {
+    sourceType: "module",
+    allowImportExportEverywhere: true,
+    allowReturnOutsideFunction: true,
+    plugins: [
+      "typescript",
+      "jsx",
+      "decorators-legacy",
+      "classProperties",
+      "asyncGenerators",
+      "bigInt",
+      "dynamicImport",
+      "exportDefaultFrom",
+      "nullishCoalescingOperator",
+      "numericSeparator",
+      "objectRestSpread",
+      "optionalCatchBinding",
+      "optionalChaining",
+      "topLevelAwait"
+    ]
+  });
+  const chunks = [];
+  const visitedRanges = [];
+  traverse(ast, {
+    enter(path) {
+      const node = path.node;
+      if (t.isFunctionDeclaration(node) || t.isClassDeclaration(node) || t.isTSInterfaceDeclaration(node) || t.isTSTypeAliasDeclaration(node) || t.isVariableDeclaration(node) || t.isImportDeclaration(node) || t.isExportNamedDeclaration(node) || t.isExportDefaultDeclaration(node) || t.isExportAllDeclaration(node)) {
+        const loc = node.loc;
+        if (!loc) return;
+        if (path.parentPath && !t.isProgram(path.parentPath.node)) return;
+        if (t.isClassDeclaration(node) && node.body?.body) {
+          for (const member of node.body.body) {
+            if (!member.loc) continue;
+            if (t.isClassMethod(member) || t.isClassPrivateMethod(member) || t.isClassProperty(member)) {
+              const methodChunk = {
+                relPath,
+                startLine: member.loc.start.line,
+                endLine: member.loc.end.line,
+                content: sliceLines(content, member.loc.start.line, member.loc.end.line),
+                tokens: 0,
+                kind: getKind(member),
+                name: getName(member)
+              };
+              methodChunk.tokens = countTokens(methodChunk.content);
+              chunks.push(methodChunk);
+            }
+          }
+        }
+        const chunk = {
+          relPath,
+          startLine: loc.start.line,
+          endLine: loc.end.line,
+          content: sliceLines(content, loc.start.line, loc.end.line),
+          tokens: 0,
+          kind: getKind(node),
+          name: getName(node)
+        };
+        chunk.tokens = countTokens(chunk.content);
+        chunks.push(chunk);
+        visitedRanges.push([loc.start.line, loc.end.line]);
+      }
+    }
+  });
+  return mergeGaps(content, relPath, chunks, visitedRanges);
+}
+function extractWithRegex(relPath, content) {
+  const lines = content.split("\n");
+  const chunks = [];
+  let currentStart = 1;
+  let currentLines = [];
+  const re = /^(export\s+)?(?:async\s+)?(?:function\s+\w+|class\s+\w+|const\s+\w+|let\s+\w+|var\s+\w+|interface\s+\w+|type\s+\w+|def\s+\w+|struct\s+\w+|fn\s+\w+)/;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.match(re) && currentLines.length > 0) {
+      const chunk = {
+        relPath,
+        startLine: currentStart,
+        endLine: i,
+        content: currentLines.join("\n"),
+        tokens: 0,
+        kind: "unknown"
+      };
+      chunk.tokens = countTokens(chunk.content);
+      chunks.push(chunk);
+      currentStart = i + 1;
+      currentLines = [line];
+    } else {
+      currentLines.push(line);
+    }
+  }
+  if (currentLines.length) {
+    const chunk = {
+      relPath,
+      startLine: currentStart,
+      endLine: lines.length,
+      content: currentLines.join("\n"),
+      tokens: 0,
+      kind: "unknown"
+    };
+    chunk.tokens = countTokens(chunk.content);
+    chunks.push(chunk);
+  }
+  return chunks.filter((c) => c.content.trim());
+}
+function extractChunks(relPath, content) {
+  const ext = relPath.slice(relPath.lastIndexOf(".")).toLowerCase();
+  if (JS_LIKE.has(ext)) {
+    try {
+      return extractTopLevelWithBabel(relPath, content);
+    } catch {
+      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);
+}
+
+// src/embeddings.ts
+import { pipeline } from "@xenova/transformers";
+var DEFAULT_MODEL = "Xenova/paraphrase-multilingual-MiniLM-L12-v2";
+var extractor = null;
+var activeModel = "";
+async function getExtractor(model = DEFAULT_MODEL) {
+  if (extractor && activeModel === model) return extractor;
+  activeModel = model;
+  extractor = await pipeline("feature-extraction", model, {
+    quantized: true
+  });
+  return extractor;
+}
+function prepareText(text, maxTokens = 256) {
+  if (countTokens(text) <= maxTokens) return text;
+  return chunkByTokens(text, maxTokens)[0] ?? text.slice(0, 1024);
+}
+function tensorToVectors(tensor) {
+  const [count, dim] = tensor.dims;
+  const vectors = [];
+  for (let i = 0; i < count; i++) {
+    vectors.push(Array.from(tensor.data.subarray(i * dim, (i + 1) * dim)));
+  }
+  return vectors;
+}
+async function getEmbedding(text, model = DEFAULT_MODEL) {
+  const pipe = await getExtractor(model);
+  const out = await pipe(prepareText(text), {
+    pooling: "mean",
+    normalize: true
+  });
+  return Array.from(out.data);
+}
+async function getEmbeddings(texts, model = DEFAULT_MODEL) {
+  const pipe = await getExtractor(model);
+  const inputs = texts.map((t2) => prepareText(t2));
+  const out = await pipe(inputs, {
+    pooling: "mean",
+    normalize: true
+  });
+  return tensorToVectors(out);
+}
+function cosineSimilarity(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+  }
+  return dot;
+}
+
+// src/project.ts
+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 clearConfigCache(absProject) {
+  if (absProject == null) configCache.clear();
+  else configCache.delete(absProject);
+}
+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",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".vue",
+  ".svelte",
+  ".py",
+  ".rs",
+  ".go",
+  ".java",
+  ".kt",
+  ".swift",
+  ".cs",
+  ".cpp",
+  ".c",
+  ".h",
+  ".hpp",
+  ".css",
+  ".scss",
+  ".less",
+  ".html",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".md"
+]);
+var DEFAULT_SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "out",
+  ".output",
+  "coverage",
+  "tmp",
+  "temp",
+  ".cache",
+  ".turbo",
+  ".next",
+  "android",
+  "ios",
+  "e2e-shots",
+  "playstore_screenshots",
+  ".cursor",
+  ".idea",
+  ".memsearch",
+  ".vscode",
+  "__pycache__",
+  ".dsh-tmp",
+  ".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);
+}
+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);
+}
+async function findProjectRoot(absProject) {
+  try {
+    const s = await stat(absProject);
+    if (s.isDirectory()) return absProject;
+    return resolve(absProject, "..");
+  } catch {
+    throw new Error(`Project path not found: ${absProject}`);
+  }
+}
+function getCacheDir() {
+  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 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, ignoreGlobs = []) {
+  const queue = [startDir];
+  while (queue.length) {
+    const dir = queue.shift();
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      const rel = relative(startDir, fullPath).split(sep).join("/");
+      if (entry.isDirectory()) {
+        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;
+    }
+  }
+}
+async function safeReadText(filePath) {
+  try {
+    const text = await readFile2(filePath, "utf8");
+    return text;
+  } catch {
+    return void 0;
+  }
+}
+async function buildTree(startDir, maxLines = 500, skipDirs = DEFAULT_SKIP_DIRS) {
+  const lines = [];
+  async function walk(dir, prefix = "") {
+    if (lines.length >= maxLines) return;
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((a, b) => a.isDirectory() === b.isDirectory() ? a.name.localeCompare(b.name) : a.isDirectory() ? -1 : 1);
+    for (const entry of entries) {
+      if (lines.length >= maxLines) return;
+      if (skipDirs.has(entry.name)) continue;
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        lines.push(`${prefix}${entry.name}/`);
+        await walk(fullPath, `${prefix}  `);
+      } else {
+        lines.push(`${prefix}${entry.name}`);
+      }
+    }
+  }
+  await walk(startDir);
+  return lines.join("\n");
+}
+
+// src/indexer.ts
+var INDEX_VERSION = 5;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "and",
+  "or",
+  "but",
+  "so",
+  "yet",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "he",
+  "she",
+  "they",
+  "them",
+  "their",
+  "we",
+  "us",
+  "our",
+  "you",
+  "your",
+  "i",
+  "me",
+  "my",
+  "le",
+  "la",
+  "les",
+  "un",
+  "une",
+  "des",
+  "du",
+  "de",
+  "et",
+  "ou",
+  "que",
+  "qui",
+  "quoi",
+  "dont",
+  "ce",
+  "cet",
+  "cette",
+  "ces",
+  "est",
+  "sont",
+  "etait",
+  "etaient",
+  "avoir",
+  "etre",
+  "faire",
+  "dans",
+  "pour",
+  "sur",
+  "avec",
+  "par",
+  "a",
+  "au",
+  "aux"
+]);
+function tokenizeTerms(text) {
+  return text.replace(/[^a-zA-Z0-9\u00C0-\u017F]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter(Boolean).filter((t2) => t2.length > 1 && !STOP_WORDS.has(t2));
+}
+function buildInvertedIndex(files) {
+  const index = {};
+  for (const file of Object.values(files)) {
+    for (const chunk of file.chunks) {
+      const terms = /* @__PURE__ */ new Set([
+        ...tokenizeTerms(chunk.content),
+        ...tokenizeTerms(chunk.relPath),
+        ...tokenizeTerms(chunk.name ?? "")
+      ]);
+      for (const term of terms) {
+        if (!index[term]) index[term] = {};
+        if (!index[term][file.relPath]) index[term][file.relPath] = 0;
+        index[term][file.relPath] += 1;
+      }
+    }
+  }
+  return index;
+}
+async function loadIndex(projectPath) {
+  const absProject = await findProjectRoot(resolveProjectPath(projectPath));
+  const p = cacheFilePath(absProject);
+  if (!existsSync(p)) return null;
+  try {
+    const raw = await readFile3(p, "utf8");
+    const data = JSON.parse(raw);
+    if (data.version !== INDEX_VERSION) return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function saveIndex(index) {
+  const p = cacheFilePath(index.projectPath);
+  await mkdir(dirname2(p), { recursive: true });
+  await writeFile(p, JSON.stringify(index), "utf8");
+}
+async function embedIndex(index, progress) {
+  const allChunks = Object.values(index.files).flatMap((f) => f.chunks);
+  const missing = allChunks.filter((c) => !c.embedding || c.embedding.length === 0);
+  if (missing.length === 0) return;
+  const batchSize = 32;
+  for (let i = 0; i < missing.length; i += batchSize) {
+    const batch = missing.slice(i, i + batchSize);
+    progress?.(`Embedding ${i + batch.length}/${missing.length} chunks...`);
+    try {
+      const vectors = await getEmbeddings(batch.map((c) => c.content));
+      for (let j = 0; j < batch.length; j++) {
+        batch[j].embedding = vectors[j];
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      progress?.(`Embedding failed: ${msg}`);
+      break;
+    }
+  }
+  await saveIndex(index);
+}
+async function buildIndex(projectPath, progress) {
+  const absProject = await findProjectRoot(resolveProjectPath(projectPath));
+  const projectName = absProject.split(sep2).pop() ?? "project";
+  progress?.(`Indexing ${projectName}...`);
+  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, 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];
+    if (cached && cached.mtimeMs === fstats.mtimeMs && cached.size === fstats.size) {
+      files[relPath] = cached;
+      reused++;
+      totalTokens += cached.chunks.reduce((sum, c) => sum + c.tokens, 0);
+      continue;
+    }
+    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
+      tokens: countTokens(chunk.content)
+    }));
+    totalTokens += chunks.reduce((sum, c) => sum + c.tokens, 0);
+    files[relPath] = {
+      relPath,
+      size: fstats.size,
+      mtimeMs: fstats.mtimeMs,
+      hash,
+      chunks
+    };
+  }
+  const now = Date.now();
+  const index = {
+    projectPath: absProject,
+    projectHash: projectHash(absProject),
+    version: INDEX_VERSION,
+    createdAt: previous?.createdAt ?? now,
+    updatedAt: now,
+    tree,
+    constraints: [],
+    files,
+    terms: buildInvertedIndex(files)
+  };
+  await saveIndex(index);
+  progress?.(`Indexed ${Object.keys(files).length} files, ~${totalTokens} tokens${reused ? ` (${reused} unchanged reused)` : ""}`);
+  return index;
+}
+async function getIndex(projectPath, progress, force = false) {
+  const resolved = resolveProjectPath(projectPath);
+  const absProject = await findProjectRoot(resolved);
+  const existing = force ? null : await loadIndex(resolved);
+  if (existing && existing.projectPath === absProject) {
+    let stale = false;
+    for (const file of Object.values(existing.files)) {
+      const fullPath = join4(absProject, file.relPath);
+      try {
+        const fstats = await stat2(fullPath);
+        if (fstats.mtimeMs !== file.mtimeMs || fstats.size !== file.size) {
+          stale = true;
+          break;
+        }
+      } catch {
+        stale = true;
+        break;
+      }
+    }
+    if (!stale) {
+      progress?.("Loaded index from cache");
+      return existing;
+    }
+  }
+  return buildIndex(projectPath, progress);
+}
+
+// src/retriever.ts
+var STOP_WORDS2 = /* @__PURE__ */ new Set([
+  "the",
+  "is",
+  "are",
+  "was",
+  "were",
+  "be",
+  "been",
+  "being",
+  "have",
+  "has",
+  "had",
+  "do",
+  "does",
+  "did",
+  "will",
+  "would",
+  "could",
+  "should",
+  "may",
+  "might",
+  "must",
+  "shall",
+  "can",
+  "need",
+  "dare",
+  "ought",
+  "used",
+  "to",
+  "of",
+  "in",
+  "for",
+  "on",
+  "with",
+  "at",
+  "by",
+  "from",
+  "as",
+  "and",
+  "or",
+  "but",
+  "so",
+  "yet",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "it",
+  "its",
+  "he",
+  "she",
+  "they",
+  "them",
+  "their",
+  "we",
+  "us",
+  "our",
+  "you",
+  "your",
+  "i",
+  "me",
+  "my",
+  "le",
+  "la",
+  "les",
+  "un",
+  "une",
+  "des",
+  "du",
+  "de",
+  "et",
+  "ou",
+  "que",
+  "qui",
+  "quoi",
+  "dont",
+  "ce",
+  "cet",
+  "cette",
+  "ces",
+  "est",
+  "sont",
+  "etait",
+  "etaient",
+  "avoir",
+  "etre",
+  "faire",
+  "dans",
+  "pour",
+  "sur",
+  "avec",
+  "par",
+  "a",
+  "au",
+  "aux"
+]);
+function tokenizeQuery(text) {
+  return text.replace(/[^a-zA-Z0-9\u00C0-\u017F]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").toLowerCase().split(/\s+/).filter(Boolean).filter((t2) => t2.length > 2 && !STOP_WORDS2.has(t2));
+}
+function getChunkKey(chunk) {
+  return `${chunk.relPath}:${chunk.startLine}:${chunk.endLine}`;
+}
+function lexicalScore(index, query) {
+  const terms = tokenizeQuery(query);
+  const scores = /* @__PURE__ */ new Map();
+  if (terms.length === 0) return scores;
+  for (const term of terms) {
+    const posting = index.terms[term];
+    if (!posting) continue;
+    for (const [relPath, count] of Object.entries(posting)) {
+      const file = index.files[relPath];
+      if (!file) continue;
+      for (const chunk of file.chunks) {
+        const key = getChunkKey(chunk);
+        const contentHit = chunk.content.toLowerCase().includes(term);
+        const nameHit = chunk.name ? tokenizeQuery(chunk.name).includes(term) : false;
+        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);
+      }
+    }
+  }
+  return scores;
+}
+async function scoreChunks(index, query, embed = false) {
+  const lexScores = lexicalScore(index, query);
+  const allChunks = [];
+  for (const file of Object.values(index.files)) {
+    allChunks.push(...file.chunks);
+  }
+  let queryEmbedding = null;
+  const hasEmbeddings = embed && allChunks.some((c) => c.embedding && c.embedding.length > 0);
+  if (hasEmbeddings) {
+    try {
+      queryEmbedding = await getEmbedding(query);
+    } catch {
+      queryEmbedding = null;
+    }
+  }
+  const scored = [];
+  for (const chunk of allChunks) {
+    const key = getChunkKey(chunk);
+    let score = lexScores.get(key) ?? 0;
+    if (queryEmbedding && chunk.embedding && chunk.embedding.length === queryEmbedding.length) {
+      const sim = cosineSimilarity(queryEmbedding, chunk.embedding);
+      score += sim * 50;
+    } else if (score === 0 && !hasEmbeddings) {
+      score = 0.1;
+    }
+    scored.push({ ...chunk, score });
+  }
+  return scored.sort((a, b) => b.score - a.score);
+}
+function selectChunks(scored, maxTokens, maxChunkTokens = Infinity) {
+  const result = [];
+  const covered = /* @__PURE__ */ new Map();
+  let used = 0;
+  for (const chunk of scored) {
+    if (chunk.tokens > maxChunkTokens) continue;
+    if (used + chunk.tokens > maxTokens) continue;
+    const ranges = covered.get(chunk.relPath) ?? [];
+    const duplicated = ranges.some(([s, e]) => chunk.startLine >= s && chunk.endLine <= e);
+    if (duplicated) continue;
+    ranges.push([chunk.startLine, chunk.endLine]);
+    covered.set(chunk.relPath, ranges);
+    result.push(chunk);
+    used += chunk.tokens;
+  }
+  return { chunks: result, tokens: used };
+}
+
+// src/context.ts
+var DEFAULT_MAX_TOKENS = 6e4;
+var HEAD_BUDGET_TOKENS = 800;
+function getLabels(lang) {
+  return lang === "en" ? {
+    project: "Project",
+    focus: "Focus",
+    tree: "File tree",
+    noConstraints: "No explicit constraints documented.",
+    constraints: "IDENTIFIED PRODUCT CONSTRAINTS",
+    answerIn: "Answer in English."
+  } : {
+    project: "Projet",
+    focus: "Focus",
+    tree: "Arborescence",
+    noConstraints: "Aucune contrainte explicite document\xE9e.",
+    constraints: "CONTRAINTES PRODUIT IDENTIFI\xC9ES",
+    answerIn: "R\xE9ponds obligatoirement en fran\xE7ais."
+  };
+}
+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(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;
+    while ((m = regex.exec(text)) !== null) {
+      const line = m[0].replace(/\s+/g, " ").trim();
+      if (line.length > 20) constraints.push(`[${name}] ${line}`);
+    }
+  }
+  return constraints.slice(0, 12);
+}
+function formatChunk(chunk) {
+  const kind = chunk.kind.toUpperCase();
+  const source = `[source: ${chunk.relPath}:${chunk.startLine}-${chunk.endLine}]`;
+  const kindLabel = chunk.kind === "unknown" ? "" : ` (${kind})`;
+  const header = `--- ${chunk.relPath}${chunk.name ? ` :: ${chunk.name}` : ""}${kindLabel} ${source} ---`;
+  return `${header}
+${chunk.content}`;
+}
+async function buildContext(options) {
+  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 {
+      await embedIndex(index);
+    } catch {
+    }
+  }
+  const focus = filePath ?? searchQuery ?? query;
+  let selectedChunks = [];
+  const bodyLimit = maxTokens - HEAD_BUDGET_TOKENS;
+  const maxChunkTokens = Math.floor(bodyLimit / 2);
+  if (filePath) {
+    const all = Object.values(index.files);
+    const target = all.find((f) => f.relPath === filePath) ?? all.filter((f) => f.relPath.endsWith(`/${filePath}`) || f.relPath.endsWith(filePath)).sort((a, b) => a.relPath.length - b.relPath.length)[0];
+    if (target) {
+      const { chunks } = selectChunks(
+        target.chunks.map((c) => ({ ...c, score: 0 })),
+        bodyLimit,
+        Infinity
+      );
+      selectedChunks = chunks;
+    } else {
+      const scored = await scoreChunks(index, 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 { chunks } = selectChunks(scored, bodyLimit, maxChunkTokens);
+    selectedChunks = chunks;
+  } else {
+    const scored = await scoreChunks(index, query, embed);
+    const { chunks } = selectChunks(scored, bodyLimit, maxChunkTokens);
+    selectedChunks = chunks;
+  }
+  const constraints = await extractProductConstraints(absProject);
+  const constraintsText = constraints.length ? `== ${labels.constraints} ==
+${constraints.map((c) => `- ${c}`).join("\n")}` : `== ${labels.constraints} ==
+${labels.noConstraints}`;
+  const head = `${labels.project} : ${absProject}
+${labels.focus} : ${focus}
+${constraintsText}
+
+== ${labels.tree} ==
+${index.tree}
+`;
+  const headTokens = countTokens(head);
+  const body = selectedChunks.map((c) => formatChunk(c)).join("\n\n");
+  const bodyBudget = Math.max(0, maxTokens - headTokens - 100);
+  const truncatedBody = truncateToTokens(body, bodyBudget);
+  const baseInstruction = `${labels.answerIn}
+Answer the question or perform the requested task using the code context above. Cite every technical claim with [source: relative/path:line]. Provide confidence and severity where relevant.`;
+  const finalInstruction = instruction ? `${instruction}
+
+${baseInstruction}` : baseInstruction;
+  const prompt = `${head}
+
+${truncatedBody}
+
+${finalInstruction}`;
+  const tokenCount = countTokens(prompt);
+  return {
+    absProject,
+    context: prompt,
+    chunks: selectedChunks,
+    tokenCount
+  };
+}
+
+// src/analysis.ts
+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"]);
+var IMPORT_RE = /(?:import|export)\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]+)['"]|require\(\s*['"]([^'"]+)['"]\s*\)|import\(\s*['"]([^'"]+)['"]\s*\)/g;
+var EXPORT_RE = /export\s+(?:async\s+)?(?:function|class|const|let|var|interface|type|enum)\s+([A-Za-z_$][\w$]*)|export\s*\{\s*([^}]+)\}|export\s+default\b/g;
+function parseImports(text, relPath, known) {
+  const out = [];
+  let m;
+  IMPORT_RE.lastIndex = 0;
+  while ((m = IMPORT_RE.exec(text)) !== null) {
+    const spec = m[1] ?? m[2] ?? m[3];
+    if (!spec || !spec.startsWith(".")) continue;
+    const base = posixPath.normalize(posixPath.join(posixPath.dirname(relPath), spec));
+    const noExt = base.replace(/\.(js|jsx|mjs|cjs|ts|tsx)$/, "");
+    for (const cand of [base, `${noExt}.ts`, `${noExt}.tsx`, `${noExt}.js`, `${noExt}.jsx`, `${noExt}.mjs`, `${base}/index.ts`, `${base}/index.js`]) {
+      if (known.has(cand)) {
+        out.push(cand);
+        break;
+      }
+    }
+  }
+  return out;
+}
+function parseExports(text) {
+  const out = [];
+  let m;
+  EXPORT_RE.lastIndex = 0;
+  while ((m = EXPORT_RE.exec(text)) !== null) {
+    const line = text.slice(0, m.index).split("\n").length;
+    if (m[1]) out.push({ name: m[1], line });
+    else if (m[2]) {
+      for (const part of m[2].split(",")) {
+        const name = part.trim().split(/\s+as\s+/).pop()?.trim();
+        if (name) out.push({ name, line });
+      }
+    } else out.push({ name: "default", line });
+  }
+  return out;
+}
+function findCycles(edges) {
+  const adj = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    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 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 });
+        }
+      } else if (!stack.includes(next)) {
+        dfs(next);
+      }
+    }
+    stack.pop();
+    onStack.delete(node);
+  }
+  for (const n of adj.keys()) dfs(n);
+  return cycles;
+}
+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) : [])) {
+    if (typeof f === "string" && rel.endsWith(f.replace(/^\.\//, ""))) return true;
+  }
+  return false;
+}
+function complexityOf(text) {
+  const matches = text.match(/\b(if|else if|for|while|case|catch|&&|\|\||\?)\b|\?\./g);
+  return 1 + (matches ? matches.length : 0);
+}
+var WINDOW = 6;
+function findDuplicates(fileTexts) {
+  const windows = /* @__PURE__ */ new Map();
+  for (const [file, text] of fileTexts) {
+    const lines = text.split("\n").map((l) => l.trim()).filter((l) => l && !l.startsWith("//") && l !== "{" && l !== "}");
+    for (let i = 0; i + WINDOW <= lines.length; i++) {
+      const key = lines.slice(i, i + WINDOW).join("\n");
+      if (key.length < 60) continue;
+      if (!windows.has(key)) windows.set(key, []);
+      const arr = windows.get(key);
+      if (!arr.some((w) => w.file === file)) arr.push({ file, line: i + 1 });
+    }
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const [key, hits] of windows) {
+    if (hits.length < 2) continue;
+    const files = [...new Set(hits.map((h) => h.file))].sort();
+    const gk = files.join("|");
+    const preview = key.split("\n")[0].slice(0, 80);
+    const g = groups.get(gk);
+    if (g) g.lines += WINDOW;
+    else groups.set(gk, { files, lines: WINDOW, preview });
+  }
+  return [...groups.values()].sort((a, b) => b.lines - a.lines).slice(0, 15);
+}
+async function analyzeProject(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 ext = extname2(rel).toLowerCase();
+    if (!CODE_EXTS.has(ext) || SKIP_EXTS.has(ext) || rel.includes(".min.")) continue;
+    const text = await safeReadText(full);
+    if (!text) continue;
+    codeFiles.push(rel);
+    fileTexts.set(rel, text);
+  }
+  let pkg = {};
+  try {
+    pkg = JSON.parse(await readFile4(join6(abs, "package.json"), "utf8"));
+  } catch {
+  }
+  const known = new Set(codeFiles);
+  const edges = [];
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const rel of codeFiles) {
+    for (const to of parseImports(fileTexts.get(rel), rel, known)) {
+      edges.push({ from: rel, to });
+      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);
+  const unusedExports = [];
+  for (const rel of codeFiles) {
+    for (const exp of parseExports(fileTexts.get(rel))) {
+      if (exp.name === "default") continue;
+      let used = false;
+      for (const [otherFile, text] of fileTexts) {
+        if (otherFile === rel) continue;
+        if (new RegExp(`\\b${exp.name.replace(/[$_]/g, "\\$&")}\\b`).test(text)) {
+          used = true;
+          break;
+        }
+      }
+      if (!used) unusedExports.push({ file: rel, name: exp.name, line: exp.line });
+    }
+  }
+  const duplicates = findDuplicates(fileTexts);
+  const hotspots = [];
+  for (const [rel, text] of fileTexts) {
+    const score2 = complexityOf(text);
+    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 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 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,
+    importEdges: edges.length,
+    cycles,
+    unusedFiles,
+    unusedExports,
+    duplicates,
+    hotspots,
+    score,
+    grade
+  };
+}
+function formatHealthReport(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"
+  } : {
+    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"
+  };
+  const out = [];
+  out.push(`== ${t2.title} \u2014 ${basename(r.projectPath)} ==`);
+  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 ")}`);
+  if (r.cycles.length === 0) out.push(`  ${t2.none}`);
+  out.push("");
+  out.push(`\u25CF ${t2.unusedFiles} (${r.unusedFiles.length}) \u2014 ${t2.noteUnused}`);
+  for (const f of r.unusedFiles.slice(0, 15)) out.push(`  ${f}`);
+  out.push("");
+  out.push(`\u25CF ${t2.unusedExports} (${r.unusedExports.length})`);
+  for (const e of r.unusedExports.slice(0, 15)) out.push(`  ${e.file}:${e.line} \u2014 ${e.name}`);
+  out.push("");
+  out.push(`\u25CF ${t2.dupes} (${r.duplicates.length})`);
+  for (const d of r.duplicates.slice(0, 8)) out.push(`  ${d.lines} lines \xD7 ${d.files.length} files \u2014 ${d.files.join(", ")}`);
+  out.push("");
+  out.push(`\u25CF ${t2.hotspots} (${r.hotspots.length})`);
+  for (const h of r.hotspots.slice(0, 10)) out.push(`  ${h.file} \u2014 score ${h.score}`);
+  return out.join("\n");
+}
+export {
+  CONFIG_FILE,
+  analyzeProject,
+  buildContext,
+  buildIndex,
+  chunkByTokens,
+  clearConfigCache,
+  cosineSimilarity,
+  countTokens,
+  disposeTreeSitter,
+  embedIndex,
+  ensureTreeSitterForExt,
+  extractChunks,
+  findProjectRoot,
+  formatHealthReport,
+  getEmbedding,
+  getEmbeddings,
+  getExtractor,
+  getIndex,
+  globToRegExp,
+  initTreeSitter,
+  loadIndex,
+  loadProjectConfig,
+  matchesAnyGlob,
+  resolveProjectPath,
+  saveIndex,
+  scoreChunks,
+  selectChunks,
+  treeSitterReady,
+  truncateToTokens
+};
+//# sourceMappingURL=index.js.map