dsh-codebase-chat 0.16.4 → 0.19.0

package/dist/cli.js

@@ -0,0 +1,1322 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "util";
+
+// src/context.ts
+import { join as join3 } 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 readFile2, stat as stat2, writeFile } from "fs/promises";
+import { dirname, join as join2, relative, sep } 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";
+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 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 = [];
+  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);
+    }
+  }
+  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, stat } from "fs/promises";
+import { extname, join, resolve, isAbsolute } from "path";
+import { createHash } from "crypto";
+import { homedir } from "os";
+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([]);
+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 || join(homedir(), ".cache");
+  return join(base, "dsh-codebase-chat-cache");
+}
+function cacheFilePath(absProject) {
+  return join(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) {
+  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 = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!skipDirs.has(entry.name)) queue.push(fullPath);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      if (skipFiles.has(entry.name)) continue;
+      const ext = extname(entry.name).toLowerCase();
+      if (!SOURCE_EXTS.has(ext)) continue;
+      yield fullPath;
+    }
+  }
+}
+async function safeReadText(filePath) {
+  try {
+    const text = await readFile(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 = join(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 readFile2(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(dirname(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(sep).pop() ?? "project";
+  progress?.(`Indexing ${projectName}...`);
+  const tree = await buildTree(absProject);
+  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("/");
+    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 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 = join2(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(join3(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, maxTokens = DEFAULT_MAX_TOKENS, lang = "fr", instruction, embed = false } = options;
+  const labels = getLabels(lang);
+  const absProject = await findProjectRoot(resolveProjectPath(project));
+  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 join4, relative as relative2, sep as sep2, posix as posixPath } from "path";
+import { readFile as readFile3 } 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 (/^(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 = [];
+  for await (const full of walkFiles(abs)) {
+    const rel = relative2(abs, full).split(sep2).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 readFile3(join4(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) + hotspots.length * 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: hotspots.slice(0, 15),
+    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");
+}
+
+// src/cli.ts
+function printHelp() {
+  console.log(`
+dsh-codebase-chat CLI
+
+Usage:
+  npx dsh-codebase-chat --project <path> --ask "Explain auth flow"
+  npx dsh-codebase-chat --project <path> --search "rate limiting"
+  npx dsh-codebase-chat --project <path> --file src/auth.ts
+  npx dsh-codebase-chat --project <path> --index
+  npx dsh-codebase-chat --project <path> --stats
+  npx dsh-codebase-chat --project <path> --health
+
+Options:
+  -p, --project <path>   Project directory (default: current directory)
+  -a, --ask <question>   Ask a question about the codebase
+  -s, --search <query>   Search code by semantic terms
+  -f, --file <path>      Focus on a specific file
+  -i, --index            Force re-index the project
+  -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)
+  -h, --help             Show this help
+
+Environment:
+  CODEBASE_CACHE_DIR     Directory for the index cache
+`);
+}
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      project: { type: "string", short: "p", default: "." },
+      ask: { type: "string", short: "a" },
+      search: { type: "string", short: "s" },
+      file: { type: "string", short: "f" },
+      index: { type: "boolean", short: "i", default: false },
+      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" },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: false
+  });
+  if (values.help) {
+    printHelp();
+    process.exit(0);
+  }
+  const lang = values.lang === "en" ? "en" : "fr";
+  const project = resolveProjectPath(values.project);
+  if (values.index) {
+    await getIndex(project, (m) => console.log(m), true);
+    process.exit(0);
+  }
+  if (values.stats) {
+    const index = await getIndex(project, (m) => console.log(m));
+    const fileCount = Object.keys(index.files).length;
+    const totalTokens = Object.values(index.files).reduce((sum, f) => sum + f.chunks.reduce((s, c) => s + c.tokens, 0), 0);
+    const termCount = Object.keys(index.terms).length;
+    console.log(`Project: ${index.projectPath}`);
+    console.log(`Files:   ${fileCount}`);
+    console.log(`Tokens:  ${totalTokens}`);
+    console.log(`Terms:   ${termCount}`);
+    console.log(`Cache:   ${index.projectHash}`);
+    process.exit(0);
+  }
+  if (values.health) {
+    const report = await analyzeProject(project);
+    console.log(formatHealthReport(report, lang));
+    process.exit(0);
+  }
+  if (values.ask || values.search || values.file) {
+    const result = await buildContext({
+      project: values.project,
+      query: values.ask ?? values.search ?? "",
+      searchQuery: values.search,
+      filePath: values.file,
+      lang,
+      embed: values.embed
+    });
+    console.log(result.context);
+    console.log(`
+--- Stats ---`);
+    console.log(`Project: ${result.absProject}`);
+    console.log(`Chunks:  ${result.chunks.length}`);
+    console.log(`Tokens:  ${result.tokenCount}`);
+    process.exit(0);
+  }
+  printHelp();
+  process.exit(1);
+}
+main().catch((err) => {
+  console.error(err?.message ?? err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map