agentsbestfriend 0.1.4 → 0.3.0

package/dist/index.js

@@ -18059,9 +18059,52 @@ Summary:`;
 // ../core/dist/llm/pipelines.js
 import { readFile } from "fs/promises";
 import { join as join4 } from "path";
+async function generateSummaries(projectRoot, opts) {
+  const start = Date.now();
+  const provider = getLlmProvider();
+  if (!provider) {
+    throw new LlmUnavailableError("none", "LLM provider is set to 'none'");
+  }
+  if (!await provider.isAvailable()) {
+    throw new LlmUnavailableError(provider.name, "Cannot reach Ollama. Is it running?");
+  }
+  const db = createProjectDb(projectRoot);
+  const stats = {
+    generated: 0,
+    skipped: 0,
+    errors: 0,
+    durationMs: 0
+  };
+  try {
+    const rows = opts?.force ? db.select({ id: files.id, path: files.path }).from(files).all() : db.select({ id: files.id, path: files.path }).from(files).where(isNull(files.summary)).all();
+    const batchSize = opts?.batchSize ?? 5;
+    for (let i = 0; i < rows.length; i += batchSize) {
+      const batch = rows.slice(i, i + batchSize);
+      for (const row of batch) {
+        try {
+          const absPath = join4(projectRoot, row.path);
+          const content = await readFile(absPath, "utf-8");
+          const summary = await provider.generateSummary(content, row.path);
+          db.update(files).set({ summary }).where(eq(files.id, row.id)).run();
+          stats.generated++;
+        } catch (err) {
+          if (err instanceof LlmUnavailableError)
+            throw err;
+          stats.errors++;
+        }
+      }
+    }
+    stats.skipped = rows.length === 0 ? db.select({ id: files.id }).from(files).all().length : 0;
+    stats.durationMs = Date.now() - start;
+    return stats;
+  } finally {
+    closeDb(db);
+  }
+}
 var init_pipelines = __esm({
   "../core/dist/llm/pipelines.js"() {
     "use strict";
+    init_drizzle_orm();
     init_connection();
     init_schema2();
     init_llm();
@@ -44512,12 +44555,12 @@ var GitActionSchema = external_exports3.enum(["log", "file_history", "blame", "d
 function registerGitTool(server) {
   server.tool("abf_git", "Query git history, blame, and diff for the project.", {
     action: GitActionSchema.describe("Git action: log (recent commits), file_history, blame, diff"),
-    file: external_exports3.string().optional().describe("File path (required for file_history, blame; optional for diff)"),
+    file_path: external_exports3.string().optional().describe("File path (required for file_history, blame; optional for diff)"),
     count: external_exports3.number().int().min(1).max(100).default(10).describe("Number of commits (log, file_history)"),
     line_start: external_exports3.number().int().optional().describe("Start line for blame range"),
     line_end: external_exports3.number().int().optional().describe("End line for blame range")
-  }, async ({ action, file: file2, count, line_start, line_end }) => {
-    const cwd = process.cwd();
+  }, async ({ action, file_path, count, line_start, line_end }) => {
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     if (!await isGitRepo(cwd)) {
       return {
         content: [
@@ -44537,25 +44580,25 @@ function registerGitTool(server) {
           break;
         }
         case "file_history": {
-          if (!file2) {
-            return errorResult("file_history requires a `file` parameter.");
+          if (!file_path) {
+            return errorResult("file_history requires a `file_path` parameter.");
           }
-          const history = await getFileHistory(cwd, file2, count);
+          const history = await getFileHistory(cwd, file_path, count);
           text4 = `History for ${history.filePath}:
 ` + formatCommits(history.commits);
           break;
         }
         case "blame": {
-          if (!file2) {
-            return errorResult("blame requires a `file` parameter.");
+          if (!file_path) {
+            return errorResult("blame requires a `file_path` parameter.");
           }
           const range = line_start && line_end ? [line_start, line_end] : void 0;
-          const blameLines = await getBlame(cwd, file2, range);
+          const blameLines = await getBlame(cwd, file_path, range);
           text4 = formatBlame(blameLines);
           break;
         }
         case "diff": {
-          const diff = await getDiff(cwd, file2);
+          const diff = await getDiff(cwd, file_path);
           const { filesChanged, insertions, deletions } = diff.stats;
           const header = `${filesChanged} file(s) changed, +${insertions} -${deletions}`;
           text4 = diff.combined ? `${header}
@@ -44595,16 +44638,17 @@ function errorResult(msg) {
 
 // ../server/dist/tools/index-tool.js
 init_indexer();
-var IndexActionSchema = external_exports3.enum(["status", "rebuild", "update"]);
+init_llm();
+var IndexActionSchema = external_exports3.enum(["status", "rebuild", "update", "summarize"]);
 function registerIndexTool(server) {
-  server.tool("abf_index", "Manage the file index: check status, trigger rebuild, or incremental update.", {
-    action: IndexActionSchema.describe("status: show index info, rebuild: full re-index, update: incremental update")
+  server.tool("abf_index", "Manage the file index: check status, trigger rebuild, incremental update, or generate LLM summaries. Rebuild/update will auto-generate summaries when Ollama is available.", {
+    action: IndexActionSchema.describe("status: show index info, rebuild: full re-index, update: incremental update, summarize: (re)generate LLM file summaries (requires Ollama)")
   }, async ({ action }) => {
-    const cwd = process.cwd();
+    const projectRoot = process.env.ABF_PROJECT_ROOT || process.cwd();
     try {
       switch (action) {
         case "status": {
-          const status = await getIndexStatus(cwd);
+          const status = await getIndexStatus(projectRoot);
           const lastUp = status.lastUpdated ? status.lastUpdated.toISOString() : "never";
           const sizeMb = (status.indexSizeBytes / (1024 * 1024)).toFixed(2);
           const text4 = [
@@ -44617,8 +44661,8 @@ function registerIndexTool(server) {
         }
         case "rebuild":
         case "update": {
-          const stats = await runIndexPipeline(cwd);
-          const text4 = [
+          const stats = await runIndexPipeline(projectRoot);
+          const textParts = [
             `Index ${action} complete (${stats.durationMs}ms)`,
             `Discovered: ${stats.totalDiscovered}`,
             `New: ${stats.indexed}`,
@@ -44626,6 +44670,27 @@ function registerIndexTool(server) {
             `Removed: ${stats.removed}`,
             `Unchanged: ${stats.skipped}`,
             stats.errors > 0 ? `Errors: ${stats.errors}` : null
+          ].filter(Boolean);
+          const provider = getLlmProvider();
+          if (provider && await provider.isAvailable()) {
+            try {
+              const sumStats = await generateSummaries(projectRoot);
+              textParts.push("", `LLM summaries: ${sumStats.generated} generated, ${sumStats.skipped} skipped${sumStats.errors > 0 ? `, ${sumStats.errors} errors` : ""} (${sumStats.durationMs}ms)`);
+            } catch {
+              textParts.push("", "LLM summaries: skipped (Ollama error)");
+            }
+          }
+          return {
+            content: [{ type: "text", text: textParts.join("\n") }]
+          };
+        }
+        case "summarize": {
+          const stats = await generateSummaries(projectRoot);
+          const text4 = [
+            `Summary generation complete (${stats.durationMs}ms)`,
+            `Generated: ${stats.generated}`,
+            `Skipped (already have summary): ${stats.skipped}`,
+            stats.errors > 0 ? `Errors: ${stats.errors}` : null
           ].filter(Boolean).join("\n");
           return { content: [{ type: "text", text: text4 }] };
         }
@@ -44647,7 +44712,7 @@ function registerSymbolsTool(server) {
     file_path: external_exports3.string().describe("Path to the file (relative or absolute)"),
     depth: external_exports3.number().int().min(1).max(5).default(2).describe("How deep to show nested symbols")
   }, async ({ file_path, depth }) => {
-    const cwd = process.cwd();
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     const absPath = file_path.startsWith("/") ? file_path : join9(cwd, file_path);
     try {
       const content = readFileSync6(absPath, "utf-8");
@@ -44689,17 +44754,43 @@ function formatSymbolTree(symbols2, maxDepth, currentDepth) {
 import { readFileSync as readFileSync7 } from "fs";
 import { join as join10 } from "path";
 function registerChunkTool(server) {
-  server.tool("abf_chunk", "Smart file chunking by symbol boundaries. Without chunk_index: returns chunk overview. With chunk_index: returns that chunk's content.", {
-    file_path: external_exports3.string().describe("Path to the file"),
-    chunk_index: external_exports3.number().int().min(0).optional().describe("Request a specific chunk by index (0-based). Omit for overview.")
-  }, async ({ file_path, chunk_index }) => {
-    const cwd = process.cwd();
-    const absPath = file_path.startsWith("/") ? file_path : join10(cwd, file_path);
+  server.tool("abf_chunk", `Smart file chunking by symbol boundaries. Returns actual source code.
+Use EXACTLY ONE of these modes:
+- symbol: pass a symbol name to get its full source code directly
+- chunk_index: pass a 0-based chunk index to get that chunk's code
+- (neither): returns a chunk overview listing \u2014 use this first to discover available chunks, then call again with chunk_index to retrieve code`, {
+    file_path: external_exports3.string().describe("Path to the file (relative or absolute)"),
+    chunk_index: external_exports3.number().int().min(0).optional().describe("0-based chunk index to retrieve that chunk's source code. Get the index from the overview first."),
+    symbol: external_exports3.string().optional().describe("Name of a symbol (function, class, etc.) to retrieve its full source code directly.")
+  }, async ({ file_path, chunk_index, symbol: symbol2 }) => {
+    const projectRoot = process.env.ABF_PROJECT_ROOT || process.cwd();
+    const absPath = file_path.startsWith("/") ? file_path : join10(projectRoot, file_path);
     try {
       const content = readFileSync7(absPath, "utf-8");
       const lines = content.split("\n");
-      const { symbols: symbols2 } = parseFile(absPath, content);
-      const chunks = buildChunks(symbols2, lines.length);
+      const { symbols: parsedSymbols } = parseFile(absPath, content);
+      if (symbol2) {
+        const match = findSymbol(parsedSymbols, symbol2);
+        if (!match) {
+          const available = parsedSymbols.map((s) => `${s.kind} ${s.name}`).join(", ");
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Symbol "${symbol2}" not found in ${file_path}. Available: ${available || "(none)"}`
+              }
+            ]
+          };
+        }
+        const chunkLines = lines.slice(match.startLine - 1, match.endLine);
+        const text5 = [
+          `${match.kind} ${match.name} (L${match.startLine}-${match.endLine})`,
+          "---",
+          ...chunkLines
+        ].join("\n");
+        return { content: [{ type: "text", text: text5 }] };
+      }
+      const chunks = buildChunks(parsedSymbols, lines.length);
       if (chunk_index !== void 0) {
         if (chunk_index < 0 || chunk_index >= chunks.length) {
           return {
@@ -44722,7 +44813,9 @@ function registerChunkTool(server) {
       }
       const overview = chunks.map((c, i) => `[${i}] ${c.label}  L${c.startLine}-${c.endLine} (${c.endLine - c.startLine + 1} lines)`).join("\n");
       const text4 = `${chunks.length} chunks in ${file_path}:
-${overview}`;
+${overview}
+
+To get source code, call again with chunk_index=<number> or symbol=<name>.`;
       return { content: [{ type: "text", text: text4 }] };
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -44730,6 +44823,18 @@ ${overview}`;
     }
   });
 }
+function findSymbol(symbols2, name) {
+  const lower = name.toLowerCase();
+  for (const sym of symbols2) {
+    if (sym.name.toLowerCase() === lower)
+      return sym;
+    for (const child of sym.children) {
+      if (child.name.toLowerCase() === lower)
+        return child;
+    }
+  }
+  return void 0;
+}
 var MAX_CHUNK_LINES = 200;
 function buildChunks(symbols2, totalLines) {
   if (symbols2.length === 0) {
@@ -44812,7 +44917,7 @@ function registerDependenciesTool(server) {
     direction: external_exports3.enum(["imports", "imported_by", "both"]).default("both").describe("Which direction to analyze"),
     depth: external_exports3.number().int().min(1).max(3).default(1).describe("Depth of transitive dependencies")
   }, async ({ file_path, direction, depth }) => {
-    const cwd = process.cwd();
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     const absPath = file_path.startsWith("/") ? file_path : join11(cwd, file_path);
     const relPath = file_path.startsWith("/") ? file_path.slice(cwd.length + 1) : file_path;
     try {
@@ -44935,13 +45040,13 @@ function importMatchesTarget(importPath, sourceFile, targetRelPath, targetName)
 init_search();
 function registerImpactTool(server) {
   server.tool("abf_impact", "Find all files and lines that reference a given symbol name. Useful for change impact analysis.", {
-    symbol_name: external_exports3.string().describe("The symbol (function, class, variable) name to find references for"),
+    symbol: external_exports3.string().describe("The symbol (function, class, variable) name to find references for"),
     file_path: external_exports3.string().optional().describe("Optional: scope search to usages of this symbol from this file")
-  }, async ({ symbol_name, file_path }) => {
-    const cwd = process.cwd();
+  }, async ({ symbol: symbol2, file_path }) => {
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     try {
       const results = await ripgrepSearch({
-        query: `\\b${escapeRegex2(symbol_name)}\\b`,
+        query: `\\b${escapeRegex2(symbol2)}\\b`,
         cwd,
         maxResults: 50,
         regex: true,
@@ -44952,7 +45057,7 @@ function registerImpactTool(server) {
           content: [
             {
               type: "text",
-              text: `No references found for "${symbol_name}".`
+              text: `No references found for "${symbol2}".`
             }
           ]
         };
@@ -44963,12 +45068,12 @@ function registerImpactTool(server) {
         group.push({
           line: match.lineNumber,
           text: match.lineText.trim(),
-          usage: classifyUsage(match.lineText, symbol_name)
+          usage: classifyUsage(match.lineText, symbol2)
         });
         byFile.set(match.filePath, group);
       }
       const lines = [
-        `${results.totalMatches} references to "${symbol_name}" in ${byFile.size} files:`,
+        `${results.totalMatches} references to "${symbol2}" in ${byFile.size} files:`,
         ""
       ];
       for (const [filePath, refs] of byFile) {