dsh-codebase-chat 0.22.0 → 0.23.0

package/dist/index.d.ts

@@ -57,12 +57,16 @@ interface ContextOptions {
     instruction?: string;
     /** Enable local semantic embeddings for retrieval */
     embed?: boolean;
+    /** Git ref (branch/tag/SHA) — scope retrieval to files changed vs this ref */
+    diff?: string;
 }
 interface ContextResult {
     absProject: string;
     context: string;
     chunks: CodeChunk[];
     tokenCount: number;
+    /** Project-relative files in scope when `diff` was requested */
+    diffFiles?: string[];
 }
 
 declare function buildContext(options: ContextOptions): Promise<ContextResult>;
@@ -166,7 +170,11 @@ interface HealthReport {
     score: number;
     grade: 'A' | 'B' | 'C' | 'D' | 'E';
 }
-declare function analyzeProject(projectPath: string): Promise<HealthReport>;
+interface AnalyzeOptions {
+    /** Restrict analysis to these project-relative paths (e.g. a diff scope). */
+    files?: Set<string>;
+}
+declare function analyzeProject(projectPath: string, opts?: AnalyzeOptions): Promise<HealthReport>;
 declare function formatHealthReport(r: HealthReport, lang?: 'fr' | 'en'): string;
 declare function formatHealthReportMd(r: HealthReport, lang?: 'fr' | 'en'): string;
 
@@ -199,4 +207,18 @@ declare function globToRegExp(glob: string): RegExp;
 /** Match a project-relative path (posix separators) against a list of globs. */
 declare function matchesAnyGlob(relPath: string, globs: string[] | undefined): boolean;
 
-export { CONFIG_FILE, type CloneGroup, type CodeChunk, type CodeIndex, type ConfigLang, type ContextOptions, type ContextResult, type Cycle, type HealthReport, type Hotspot, type IndexedFile, type InvertedIndex, type ProjectConfig, type UnusedExport, analyzeProject, buildContext, buildIndex, chunkByTokens, clearConfigCache, cosineSimilarity, countTokens, disposeTreeSitter, embedIndex, ensureTreeSitterForExt, extractChunks, findProjectRoot, formatHealthReport, formatHealthReportMd, getEmbedding, getEmbeddings, getExtractor, getIndex, globToRegExp, initTreeSitter, loadIndex, loadProjectConfig, matchesAnyGlob, resolveProjectPath, saveIndex, scoreChunks, selectChunks, treeSitterReady, truncateToTokens };
+interface DiffScope {
+    /** Project-relative paths (forward slashes) changed vs the base ref. */
+    files: Set<string>;
+    /** False when the project is not a git repo or git is unavailable. */
+    ok: boolean;
+    /** Why the scope could not be computed (when ok === false). */
+    error?: string;
+}
+/**
+ * Files changed vs a git ref — committed diffs, staged/unstaged edits and
+ * untracked files. Used to scope retrieval and audits to "what changed".
+ */
+declare function getChangedFiles(absProject: string, base: string): Promise<DiffScope>;
+
+export { CONFIG_FILE, type CloneGroup, type CodeChunk, type CodeIndex, type ConfigLang, type ContextOptions, type ContextResult, type Cycle, type DiffScope, type HealthReport, type Hotspot, type IndexedFile, type InvertedIndex, type ProjectConfig, type UnusedExport, analyzeProject, buildContext, buildIndex, chunkByTokens, clearConfigCache, cosineSimilarity, countTokens, disposeTreeSitter, embedIndex, ensureTreeSitterForExt, extractChunks, findProjectRoot, formatHealthReport, formatHealthReportMd, getChangedFiles, getEmbedding, getEmbeddings, getExtractor, getIndex, globToRegExp, initTreeSitter, loadIndex, loadProjectConfig, matchesAnyGlob, resolveProjectPath, saveIndex, scoreChunks, selectChunks, treeSitterReady, truncateToTokens };

package/dist/index.js

@@ -1168,6 +1168,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;
@@ -1178,14 +1205,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) {
@@ -1212,13 +1243,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);
@@ -1240,17 +1288,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;
   }
@@ -1260,7 +1308,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}
@@ -1284,12 +1332,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"]);
@@ -1404,15 +1453,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);
@@ -1624,6 +1674,7 @@ export {
   findProjectRoot,
   formatHealthReport,
   formatHealthReportMd,
+  getChangedFiles,
   getEmbedding,
   getEmbeddings,
   getExtractor,