agentsbestfriend 0.1.4 → 0.2.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();
@@ -44517,7 +44560,7 @@ function registerGitTool(server) {
     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();
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     if (!await isGitRepo(cwd)) {
       return {
         content: [
@@ -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 (requires Ollama).", {
+    action: IndexActionSchema.describe("status: show index info, rebuild: full re-index, update: incremental update, summarize: 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,7 +44661,7 @@ function registerIndexTool(server) {
         }
         case "rebuild":
         case "update": {
-          const stats = await runIndexPipeline(cwd);
+          const stats = await runIndexPipeline(projectRoot);
           const text4 = [
             `Index ${action} complete (${stats.durationMs}ms)`,
             `Discovered: ${stats.totalDiscovered}`,
@@ -44629,6 +44673,16 @@ function registerIndexTool(server) {
           ].filter(Boolean).join("\n");
           return { content: [{ type: "text", text: text4 }] };
         }
+        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 }] };
+        }
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
@@ -44647,7 +44701,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 +44743,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 +44802,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 +44812,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 +44906,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 {
@@ -44938,7 +45032,7 @@ function registerImpactTool(server) {
     symbol_name: 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();
+    const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     try {
       const results = await ripgrepSearch({
         query: `\\b${escapeRegex2(symbol_name)}\\b`,