dsh-codebase-chat 0.21.0 → 0.23.0

package/dist/cli.js

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