agentsbestfriend 0.8.0 → 0.10.0

package/dist/index.js

@@ -2983,7 +2983,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve6.call(this, root, ref);
+      let _sch = resolve7.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -3010,7 +3010,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve6(root, ref) {
+    function resolve7(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3585,55 +3585,55 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve6(baseURI, relativeURI, options) {
+    function resolve7(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
       return serialize(resolved, schemelessOptions);
     }
-    function resolveComponent(base, relative5, options, skipNormalization) {
+    function resolveComponent(base, relative6, options, skipNormalization) {
       const target = {};
       if (!skipNormalization) {
         base = parse3(serialize(base, options), options);
-        relative5 = parse3(serialize(relative5, options), options);
+        relative6 = parse3(serialize(relative6, options), options);
       }
       options = options || {};
-      if (!options.tolerant && relative5.scheme) {
-        target.scheme = relative5.scheme;
-        target.userinfo = relative5.userinfo;
-        target.host = relative5.host;
-        target.port = relative5.port;
-        target.path = removeDotSegments(relative5.path || "");
-        target.query = relative5.query;
+      if (!options.tolerant && relative6.scheme) {
+        target.scheme = relative6.scheme;
+        target.userinfo = relative6.userinfo;
+        target.host = relative6.host;
+        target.port = relative6.port;
+        target.path = removeDotSegments(relative6.path || "");
+        target.query = relative6.query;
       } else {
-        if (relative5.userinfo !== void 0 || relative5.host !== void 0 || relative5.port !== void 0) {
-          target.userinfo = relative5.userinfo;
-          target.host = relative5.host;
-          target.port = relative5.port;
-          target.path = removeDotSegments(relative5.path || "");
-          target.query = relative5.query;
+        if (relative6.userinfo !== void 0 || relative6.host !== void 0 || relative6.port !== void 0) {
+          target.userinfo = relative6.userinfo;
+          target.host = relative6.host;
+          target.port = relative6.port;
+          target.path = removeDotSegments(relative6.path || "");
+          target.query = relative6.query;
         } else {
-          if (!relative5.path) {
+          if (!relative6.path) {
             target.path = base.path;
-            if (relative5.query !== void 0) {
-              target.query = relative5.query;
+            if (relative6.query !== void 0) {
+              target.query = relative6.query;
             } else {
               target.query = base.query;
             }
           } else {
-            if (relative5.path[0] === "/") {
-              target.path = removeDotSegments(relative5.path);
+            if (relative6.path[0] === "/") {
+              target.path = removeDotSegments(relative6.path);
             } else {
               if ((base.userinfo !== void 0 || base.host !== void 0 || base.port !== void 0) && !base.path) {
-                target.path = "/" + relative5.path;
+                target.path = "/" + relative6.path;
               } else if (!base.path) {
-                target.path = relative5.path;
+                target.path = relative6.path;
               } else {
-                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative5.path;
+                target.path = base.path.slice(0, base.path.lastIndexOf("/") + 1) + relative6.path;
               }
               target.path = removeDotSegments(target.path);
             }
-            target.query = relative5.query;
+            target.query = relative6.query;
           }
           target.userinfo = base.userinfo;
           target.host = base.host;
@@ -3641,7 +3641,7 @@ var require_fast_uri = __commonJS({
         }
         target.scheme = base.scheme;
       }
-      target.fragment = relative5.fragment;
+      target.fragment = relative6.fragment;
       return target;
     }
     function equal(uriA, uriB, options) {
@@ -3812,7 +3812,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve6,
+      resolve: resolve7,
       resolveComponent,
       equal,
       serialize,
@@ -12405,7 +12405,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join12(chunks, separator) {
+      function join13(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -12415,7 +12415,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join12;
+      sql2.join = join13;
       function identifier(value) {
         return new Name(value);
       }
@@ -15400,7 +15400,7 @@ var init_select2 = __esm({
           const baseTableName = this.tableName;
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table)) this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join12) => join12.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join13) => join13.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -16290,7 +16290,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join12) => join12.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join13) => join13.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -18342,10 +18342,10 @@ async function getIndexStatus(projectRoot) {
     }
     const lastUpdated = allFiles.length > 0 ? new Date(Math.max(...allFiles.map((f) => f.lastIndexedAt.getTime()))) : null;
     const { statSync: statSync3 } = await import("fs");
-    const { join: join12 } = await import("path");
+    const { join: join13 } = await import("path");
     let indexSizeBytes = 0;
     try {
-      const dbPath = join12(projectRoot, ".abf", "index.db");
+      const dbPath = join13(projectRoot, ".abf", "index.db");
       indexSizeBytes = statSync3(dbPath).size;
     } catch {
     }
@@ -19265,28 +19265,28 @@ __export(init_exports, {
   initCommand: () => initCommand
 });
 import * as clack from "@clack/prompts";
-import { resolve as resolve2 } from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync9, appendFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync10, appendFileSync } from "fs";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify5 } from "util";
 async function initCommand(projectPath) {
-  const root = resolve2(projectPath);
+  const root = resolve3(projectPath);
   clack.intro("ABF Init");
-  if (!existsSync5(root)) {
+  if (!existsSync6(root)) {
     clack.log.error(`Path does not exist: ${root}`);
     process.exit(1);
   }
-  const abfDir = resolve2(root, ".abf");
-  const isNew = !existsSync5(abfDir);
+  const abfDir = resolve3(root, ".abf");
+  const isNew = !existsSync6(abfDir);
   if (isNew) {
     mkdirSync3(abfDir, { recursive: true });
     clack.log.info(`Created ${abfDir}`);
   } else {
     clack.log.info(`ABF directory already exists at ${abfDir}`);
   }
-  const gitignorePath = resolve2(root, ".gitignore");
-  const gitignoreExists = existsSync5(gitignorePath);
-  const alreadyIgnored = gitignoreExists && readFileSync9(gitignorePath, "utf-8").split("\n").some((line) => line.trim() === ".abf" || line.trim() === ".abf/");
+  const gitignorePath = resolve3(root, ".gitignore");
+  const gitignoreExists = existsSync6(gitignorePath);
+  const alreadyIgnored = gitignoreExists && readFileSync10(gitignorePath, "utf-8").split("\n").some((line) => line.trim() === ".abf" || line.trim() === ".abf/");
   if (!alreadyIgnored) {
     const addToGitignore = await clack.confirm({
       message: "Add .abf/ to .gitignore?",
@@ -19396,7 +19396,27 @@ async function initCommand(projectPath) {
     clack.outro(isNew ? "Project initialized!" : "Index rebuilt!");
     return;
   }
-  const addMcpArgs = ["add-mcp", "abf start", "--name", "abf", "-y"];
+  const mcpSource = await clack.select({
+    message: "How should agents run ABF?",
+    options: [
+      {
+        value: "npx",
+        label: "npx (recommended)",
+        hint: "Always uses the latest version via npx agentsbestfriend start"
+      },
+      {
+        value: "local",
+        label: "Local install",
+        hint: "Uses your locally installed abf binary"
+      }
+    ]
+  });
+  if (clack.isCancel(mcpSource)) {
+    clack.outro(isNew ? "Project initialized!" : "Index rebuilt!");
+    return;
+  }
+  const mcpCommand = mcpSource === "npx" ? "npx agentsbestfriend start" : "abf start";
+  const addMcpArgs = ["add-mcp", mcpCommand, "--name", "abf", "-y"];
   for (const agent of selectedAgents) {
     addMcpArgs.push("-a", agent);
   }
@@ -19413,16 +19433,22 @@ async function initCommand(projectPath) {
       timeout: 6e4
     });
     mcpSpinner.stop("MCP server installed successfully");
-    clack.log.info(
-      `Agents can now use ABF via the "abf start" command.
+    if (mcpSource === "npx") {
+      clack.log.info(
+        `Agents will use ABF via "npx agentsbestfriend start" (always latest version).`
+      );
+    } else {
+      clack.log.info(
+        `Agents will use ABF via "abf start".
 Make sure abf is installed globally: npm install -g agentsbestfriend`
-    );
+      );
+    }
   } catch (err) {
     mcpSpinner.stop("MCP installation failed");
     const msg = err instanceof Error ? err.message : String(err);
     clack.log.warn(
       `Could not install MCP server: ${msg}
-You can install manually: npx add-mcp "abf start" --name abf -y`
+You can install manually: npx add-mcp "${mcpCommand}" --name abf -y`
     );
   }
   clack.outro(isNew ? "Project initialized!" : "Index rebuilt!");
@@ -19455,9 +19481,9 @@ __export(index_cmd_exports, {
   indexCommand: () => indexCommand
 });
 import * as clack2 from "@clack/prompts";
-import { resolve as resolve3 } from "path";
+import { resolve as resolve4 } from "path";
 async function indexCommand(projectPath) {
-  const root = resolve3(projectPath);
+  const root = resolve4(projectPath);
   clack2.intro("ABF Index");
   const s = clack2.spinner();
   s.start("Indexing project...");
@@ -19489,7 +19515,7 @@ __export(portal_exports, {
   portalCommand: () => portalCommand
 });
 import * as clack3 from "@clack/prompts";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve5 } from "path";
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify6 } from "util";
 async function portalCommand() {
@@ -19595,7 +19621,7 @@ async function showStatus() {
     initialValue: process.cwd()
   });
   if (clack3.isCancel(projectPath)) return;
-  const root = resolve4(projectPath);
+  const root = resolve5(projectPath);
   const s = clack3.spinner();
   s.start("Loading index status...");
   try {
@@ -19623,7 +19649,7 @@ async function reindex() {
     initialValue: process.cwd()
   });
   if (clack3.isCancel(projectPath)) return;
-  const root = resolve4(projectPath);
+  const root = resolve5(projectPath);
   const s = clack3.spinner();
   s.start("Indexing...");
   try {
@@ -19957,9 +19983,9 @@ __export(status_exports, {
   statusCommand: () => statusCommand
 });
 import * as clack5 from "@clack/prompts";
-import { resolve as resolve5 } from "path";
+import { resolve as resolve6 } from "path";
 async function statusCommand(projectPath) {
-  const root = resolve5(projectPath);
+  const root = resolve6(projectPath);
   const config2 = loadConfig();
   clack5.intro("ABF Status");
   try {
@@ -41312,7 +41338,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
+        await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error48) {
@@ -41329,7 +41355,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       const earlyReject = (error48) => {
         reject(error48);
       };
@@ -41407,7 +41433,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve6(parseResult.data);
+            resolve7(parseResult.data);
           }
         } catch (error48) {
           reject(error48);
@@ -41668,12 +41694,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve6, reject) => {
+    return new Promise((resolve7, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve6, interval);
+      const timeoutId = setTimeout(resolve7, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -42773,7 +42799,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve6) => setTimeout(resolve6, pollInterval));
+      await new Promise((resolve7) => setTimeout(resolve7, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -43422,12 +43448,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve6) => {
+    return new Promise((resolve7) => {
       const json2 = serializeMessage(message);
       if (this._stdout.write(json2)) {
-        resolve6();
+        resolve7();
       } else {
-        this._stdout.once("drain", resolve6);
+        this._stdout.once("drain", resolve7);
       }
     });
   }
@@ -43445,7 +43471,7 @@ function registerPingTool(server) {
     const status = {
       status: "ok",
       server: "agents-best-friend",
-      version: "0.8.0",
+      version: "0.10.0",
       projectRoot,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -43477,9 +43503,9 @@ function registerSearchTool(server) {
 - "keyword": Exploratory search \u2014 splits the query into keywords, scores every file by keyword density, returns the top matching files ranked by relevance. Best when you're not sure of exact names.
 - "semantic": (Requires Ollama + embeddings index) Embedding-based similarity search. Falls back to keyword mode if unavailable.
 
-Use "exact" when you know what to search for. Use "keyword" when exploring or looking for files related to a concept.`, {
+Use "exact" when you EXACTLY know what to search for. Use "keyword" when exploring or looking for files related to a concept.`, {
     query: external_exports3.string().describe("Search query \u2014 exact text, regex, or space-separated keywords depending on mode"),
-    mode: external_exports3.enum(["exact", "keyword", "semantic"]).default("exact").describe('Search mode: "exact" (ripgrep), "keyword" (file scoring), or "semantic" (embedding similarity)'),
+    mode: external_exports3.enum(["exact", "keyword", "semantic"]).default("keyword").describe('Search mode: "exact" (ripgrep), "keyword" (file scoring), or "semantic" (embedding similarity)'),
     path_filter: external_exports3.string().optional().describe('Glob pattern to filter files, e.g. "src/**/*.ts" or "*.py"'),
     max_results: external_exports3.number().int().positive().optional().default(20).describe("Maximum number of results to return (default: 20)"),
     case_sensitive: external_exports3.boolean().optional().default(false).describe("Case-sensitive search (exact mode only)"),
@@ -44610,6 +44636,366 @@ function parseBiomePresence(_content) {
   ];
 }
 
+// ../core/dist/analysis/context-bundle.js
+init_parse();
+import { readFileSync as readFileSync6, existsSync as existsSync4 } from "fs";
+import { join as join9, dirname, resolve, relative as relative5 } from "path";
+import { execFileSync } from "child_process";
+function buildContextBundle(opts) {
+  const { projectRoot, depth = 1, include = "smart", focusSymbol, reverse = false } = opts;
+  const entryPath = opts.entry.startsWith("/") ? opts.entry : join9(projectRoot, opts.entry);
+  const entryRel = relative5(projectRoot, entryPath);
+  const visited = /* @__PURE__ */ new Set();
+  const bundledFiles = [];
+  traverseImports(entryPath, projectRoot, 0, depth, include, focusSymbol, visited, bundledFiles);
+  if (reverse) {
+    const reverseFiles = findReverseDeps(projectRoot, entryRel);
+    for (const revFile of reverseFiles) {
+      const absPath = join9(projectRoot, revFile.file);
+      if (visited.has(absPath))
+        continue;
+      visited.add(absPath);
+      try {
+        const content = readFileSync6(absPath, "utf-8");
+        const parsed = parseFile(absPath, content);
+        bundledFiles.push({
+          path: revFile.file,
+          depth: -1,
+          // reverse
+          symbols: parsed.symbols,
+          imports: parsed.imports,
+          isReverse: true
+        });
+      } catch {
+      }
+    }
+  }
+  let totalSymbols = 0;
+  for (const f of bundledFiles) {
+    totalSymbols += countSymbols(f.symbols);
+  }
+  return {
+    entry: entryRel,
+    focusSymbol,
+    depth,
+    include,
+    files: bundledFiles,
+    totalSymbols
+  };
+}
+function traverseImports(filePath, projectRoot, currentDepth, maxDepth, include, focusSymbol, visited, out) {
+  if (visited.has(filePath))
+    return;
+  visited.add(filePath);
+  let content;
+  try {
+    content = readFileSync6(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  const parsed = parseFile(filePath, content);
+  const relPath = relative5(projectRoot, filePath);
+  const isEntry = currentDepth === 0;
+  const includeContent = include === "full" || include === "smart" && isEntry;
+  const bundled = {
+    path: relPath,
+    depth: currentDepth,
+    symbols: parsed.symbols,
+    imports: parsed.imports,
+    content: includeContent ? content : void 0
+  };
+  out.push(bundled);
+  if (currentDepth >= maxDepth)
+    return;
+  for (const imp of parsed.imports) {
+    const resolved = resolveImportPath(imp.targetPath, filePath, projectRoot);
+    if (!resolved)
+      continue;
+    if (focusSymbol && isEntry) {
+      if (!isImportRelevantToSymbol(content, focusSymbol, imp))
+        continue;
+    }
+    traverseImports(
+      resolved,
+      projectRoot,
+      currentDepth + 1,
+      maxDepth,
+      include,
+      void 0,
+      // no focus filtering beyond entry
+      visited,
+      out
+    );
+  }
+}
+function resolveImportPath(importPath, fromFile, projectRoot) {
+  if (importPath.startsWith(".")) {
+    const fromDir = dirname(fromFile);
+    return tryResolveFile(resolve(fromDir, importPath));
+  }
+  if (importPath.startsWith("@")) {
+    return resolveMonorepoImport(importPath, projectRoot);
+  }
+  return null;
+}
+function tryResolveFile(base) {
+  const extensions = [
+    "",
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    "/index.ts",
+    "/index.tsx",
+    "/index.js"
+  ];
+  const stripped = base.replace(/\.js$/, "");
+  for (const ext of extensions) {
+    const candidate = stripped + ext;
+    if (existsSync4(candidate))
+      return candidate;
+  }
+  for (const ext of extensions) {
+    const candidate = base + ext;
+    if (existsSync4(candidate))
+      return candidate;
+  }
+  return null;
+}
+function resolveMonorepoImport(importPath, projectRoot) {
+  const parts = importPath.split("/");
+  if (parts.length < 2)
+    return null;
+  const scope = parts[0];
+  const pkgName = parts[1];
+  const subpath = parts.slice(2).join("/");
+  const pkgDir = join9(projectRoot, "packages", pkgName);
+  if (!existsSync4(pkgDir))
+    return null;
+  const pkgJsonPath = join9(pkgDir, "package.json");
+  if (!existsSync4(pkgJsonPath))
+    return null;
+  try {
+    const pkgJson = JSON.parse(readFileSync6(pkgJsonPath, "utf-8"));
+    const exportKey = subpath ? `./${subpath}` : ".";
+    const exportEntry = pkgJson.exports?.[exportKey];
+    if (exportEntry) {
+      const distPath = typeof exportEntry === "string" ? exportEntry : exportEntry.import ?? exportEntry.types;
+      if (distPath) {
+        const srcPath = distPath.replace(/^\.\/dist\//, "./src/").replace(/\.js$/, ".ts").replace(/\.d\.ts$/, ".ts");
+        const resolved = join9(pkgDir, srcPath);
+        if (existsSync4(resolved))
+          return resolved;
+        const distResolved = join9(pkgDir, distPath);
+        if (existsSync4(distResolved))
+          return distResolved;
+      }
+    }
+  } catch {
+  }
+  const fallbacks = [
+    join9(pkgDir, "src", subpath || "index", "index.ts"),
+    join9(pkgDir, "src", (subpath || "index") + ".ts")
+  ];
+  for (const fb of fallbacks) {
+    if (existsSync4(fb))
+      return fb;
+  }
+  return null;
+}
+function isImportRelevantToSymbol(fileContent, focusSymbol, imp) {
+  const lines = fileContent.split("\n");
+  const symbolRegex = new RegExp(`(?:function|const|class|interface|type)\\s+${escapeRegex2(focusSymbol)}`);
+  let inSymbol = false;
+  let braceDepth = 0;
+  let symbolFound = false;
+  for (const line of lines) {
+    if (!inSymbol && symbolRegex.test(line)) {
+      inSymbol = true;
+      symbolFound = true;
+    }
+    if (inSymbol) {
+      for (const ch of line) {
+        if (ch === "{")
+          braceDepth++;
+        if (ch === "}")
+          braceDepth--;
+      }
+      for (const sym of imp.importedSymbols) {
+        if (sym === "*")
+          return true;
+        if (line.includes(sym))
+          return true;
+      }
+      if (braceDepth <= 0 && symbolFound) {
+        return false;
+      }
+    }
+  }
+  return !symbolFound;
+}
+function findReverseDeps(projectRoot, targetRelPath) {
+  let filePaths;
+  try {
+    const stdout = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: projectRoot, maxBuffer: 10 * 1024 * 1024 }).toString();
+    filePaths = stdout.trim().split("\n").filter(Boolean);
+  } catch {
+    return [];
+  }
+  const codeExts = /* @__PURE__ */ new Set([
+    ".ts",
+    ".tsx",
+    ".js",
+    ".jsx",
+    ".mjs",
+    ".cjs",
+    ".py"
+  ]);
+  const results = [];
+  const targetName = targetRelPath.replace(/\.[^.]+$/, "").replace(/\/index$/, "");
+  for (const fp of filePaths) {
+    if (fp === targetRelPath)
+      continue;
+    const ext = fp.slice(fp.lastIndexOf("."));
+    if (!codeExts.has(ext))
+      continue;
+    try {
+      const content = readFileSync6(join9(projectRoot, fp), "utf-8");
+      const parsed = parseFile(join9(projectRoot, fp), content);
+      for (const imp of parsed.imports) {
+        if (importMatchesTarget(imp.targetPath, fp, targetRelPath, targetName)) {
+          results.push({ file: fp, symbols: imp.importedSymbols });
+          break;
+        }
+      }
+    } catch {
+    }
+  }
+  return results;
+}
+function importMatchesTarget(importPath, sourceFile, targetRelPath, targetName) {
+  if (!importPath.startsWith("."))
+    return false;
+  const sourceDir = dirname(sourceFile);
+  const resolved = join9(sourceDir, importPath).replace(/\.[^.]+$/, "").replace(/\/index$/, "");
+  return resolved === targetName || resolved === targetRelPath.replace(/\.[^.]+$/, "");
+}
+function formatContextBundle(result) {
+  const lines = [];
+  lines.push(`Bundle for ${result.entry}${result.focusSymbol ? ` \u2192 ${result.focusSymbol}` : ""}`);
+  lines.push(`  Depth: ${result.depth} | Files: ${result.files.length} | Symbols: ${result.totalSymbols} | Mode: ${result.include}`);
+  lines.push("");
+  const forwardFiles = result.files.filter((f) => !f.isReverse);
+  const reverseFiles = result.files.filter((f) => f.isReverse);
+  for (const file2 of forwardFiles) {
+    const depthLabel = file2.depth === 0 ? "ENTRY" : `DEPTH ${file2.depth}`;
+    lines.push(`\u2550\u2550\u2550 ${depthLabel}: ${file2.path} \u2550\u2550\u2550`);
+    if (file2.content && result.focusSymbol && file2.depth === 0) {
+      const focused = findSymbolInList(file2.symbols, result.focusSymbol);
+      if (focused) {
+        const contentLines = file2.content.split("\n");
+        const code = contentLines.slice(focused.startLine - 1, focused.endLine).join("\n");
+        lines.push(`  [${focused.kind} ${focused.name} L${focused.startLine}-${focused.endLine}]`);
+        lines.push(code);
+        lines.push("");
+        const others = file2.symbols.filter((s) => s.name !== result.focusSymbol);
+        if (others.length > 0) {
+          lines.push("  Other symbols:");
+          for (const sym of others) {
+            lines.push(formatSymbolSignature(sym, "  "));
+          }
+          lines.push("");
+        }
+      } else {
+        lines.push(file2.content);
+        lines.push("");
+      }
+    } else if (file2.content) {
+      lines.push(file2.content);
+      lines.push("");
+    } else {
+      if (file2.symbols.length > 0) {
+        for (const sym of file2.symbols) {
+          lines.push(formatSymbolSignature(sym, "  "));
+        }
+      } else if (file2.imports.length > 0) {
+        lines.push("  Re-exports:");
+        for (const imp of file2.imports) {
+          const syms = imp.importedSymbols.join(", ");
+          lines.push(`    ${imp.targetPath} \u2192 {${syms}}`);
+        }
+      } else {
+        lines.push("  (no symbols parsed)");
+      }
+      lines.push("");
+    }
+    if (file2.imports.length > 0) {
+      lines.push("  Imports:");
+      for (const imp of file2.imports) {
+        const syms = imp.importedSymbols.join(", ");
+        lines.push(`    ${imp.targetPath} \u2192 {${syms}}`);
+      }
+      lines.push("");
+    }
+  }
+  if (reverseFiles.length > 0) {
+    lines.push(`\u2550\u2550\u2550 REVERSE (imports ${result.entry}) \u2550\u2550\u2550`);
+    const entryBaseName = result.entry.replace(/\.[^.]+$/, "").replace(/\/index$/, "");
+    for (const file2 of reverseFiles) {
+      const relevantImps = file2.imports.filter((imp) => {
+        const resolved = imp.targetPath.replace(/\.[^.]+$/, "").replace(/\/index$/, "");
+        return imp.targetPath.includes(entryBaseName.split("/").pop()) || resolved.endsWith(entryBaseName.split("/").pop());
+      });
+      if (relevantImps.length > 0) {
+        for (const imp of relevantImps) {
+          const syms = imp.importedSymbols.join(", ");
+          lines.push(`  ${file2.path} \u2192 {${syms}} from ${imp.targetPath}`);
+        }
+      } else {
+        lines.push(`  ${file2.path}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatSymbolSignature(sym, indent) {
+  const exported = sym.exported ? "\u2605 " : "";
+  const sig = sym.signature ?? sym.name;
+  const range = `L${sym.startLine}-${sym.endLine}`;
+  let line = `${indent}${exported}${sym.kind} ${sig}  (${range})`;
+  if (sym.children.length > 0) {
+    for (const child of sym.children) {
+      line += "\n" + formatSymbolSignature(child, indent + "  ");
+    }
+  }
+  return line;
+}
+function findSymbolInList(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;
+}
+function countSymbols(symbols2) {
+  let count = 0;
+  for (const sym of symbols2) {
+    count++;
+    count += countSymbols(sym.children);
+  }
+  return count;
+}
+function escapeRegex2(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
 // ../server/dist/tools/project-overview.js
 function registerProjectOverviewTool(server) {
   server.tool("abf_project_overview", `Get a comprehensive overview of the current project. Returns detected tech stack, frameworks, entry points, directory structure with purposes, language distribution, config files, and architectural patterns. Very token-efficient way to orient yourself in a new codebase. No index required.`, {
@@ -44992,17 +45378,17 @@ function registerIndexTool(server) {
 }
 
 // ../server/dist/tools/symbols.js
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join9 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join10 } from "path";
 function registerSymbolsTool(server) {
   server.tool("abf_symbols", "Get the symbol outline (functions, classes, methods, types) of a file.", {
     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.env.ABF_PROJECT_ROOT || process.cwd();
-    const absPath = file_path.startsWith("/") ? file_path : join9(cwd, file_path);
+    const absPath = file_path.startsWith("/") ? file_path : join10(cwd, file_path);
     try {
-      const content = readFileSync6(absPath, "utf-8");
+      const content = readFileSync7(absPath, "utf-8");
       const { symbols: symbols2 } = parseFile(absPath, content);
       if (symbols2.length === 0) {
         return {
@@ -45038,8 +45424,8 @@ function formatSymbolTree(symbols2, maxDepth, currentDepth) {
 }
 
 // ../server/dist/tools/chunk.js
-import { readFileSync as readFileSync7 } from "fs";
-import { join as join10 } from "path";
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join11 } from "path";
 function registerChunkTool(server) {
   server.tool("abf_chunk", `Smart file chunking by symbol boundaries. Returns actual source code.
 Use EXACTLY ONE of these modes:
@@ -45051,9 +45437,9 @@ Use EXACTLY ONE of these modes:
     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);
+    const absPath = file_path.startsWith("/") ? file_path : join11(projectRoot, file_path);
     try {
-      const content = readFileSync7(absPath, "utf-8");
+      const content = readFileSync8(absPath, "utf-8");
       const lines = content.split("\n");
       const { symbols: parsedSymbols } = parseFile(absPath, content);
       if (symbol2) {
@@ -45194,10 +45580,10 @@ function buildChunks(symbols2, totalLines) {
 }
 
 // ../server/dist/tools/dependencies.js
-import { readFileSync as readFileSync8 } from "fs";
-import { join as join11, dirname, resolve } from "path";
-import { existsSync as existsSync4 } from "fs";
-import { execFileSync } from "child_process";
+import { readFileSync as readFileSync9 } from "fs";
+import { join as join12, dirname as dirname2, resolve as resolve2 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { execFileSync as execFileSync2 } from "child_process";
 function registerDependenciesTool(server) {
   server.tool("abf_dependencies", "Show imports and reverse dependencies (imported_by) for a file.", {
     file_path: external_exports3.string().describe("Path to the file"),
@@ -45205,19 +45591,19 @@ function registerDependenciesTool(server) {
     depth: external_exports3.number().int().min(1).max(3).default(1).describe("Depth of transitive dependencies")
   }, async ({ file_path, direction, depth }) => {
     const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
-    const absPath = file_path.startsWith("/") ? file_path : join11(cwd, file_path);
+    const absPath = file_path.startsWith("/") ? file_path : join12(cwd, file_path);
     const relPath = file_path.startsWith("/") ? file_path.slice(cwd.length + 1) : file_path;
     try {
       const result = [];
       if (direction === "imports" || direction === "both") {
-        const content = readFileSync8(absPath, "utf-8");
+        const content = readFileSync9(absPath, "utf-8");
         const parsed = parseFile(absPath, content);
         result.push(`Imports from ${relPath}:`);
         if (parsed.imports.length === 0) {
           result.push("  (none)");
         } else {
           for (const imp of parsed.imports) {
-            const resolved = tryResolve(imp.targetPath, dirname(absPath));
+            const resolved = tryResolve(imp.targetPath, dirname2(absPath));
             const syms = imp.importedSymbols.join(", ");
             const resolvedNote = resolved ? ` \u2192 ${resolved.slice(cwd.length + 1)}` : "";
             result.push(`  ${imp.targetPath} {${syms}}${resolvedNote}`);
@@ -45261,10 +45647,10 @@ function tryResolve(importPath, fromDir) {
     "/index.ts",
     "/index.js"
   ];
-  const base = resolve(fromDir, importPath);
+  const base = resolve2(fromDir, importPath);
   for (const ext of extensions) {
     const candidate = base + ext;
-    if (existsSync4(candidate))
+    if (existsSync5(candidate))
       return candidate;
   }
   return null;
@@ -45272,7 +45658,7 @@ function tryResolve(importPath, fromDir) {
 function findImportedBy(cwd, targetRelPath) {
   let filePaths;
   try {
-    const stdout = execFileSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd, maxBuffer: 10 * 1024 * 1024 }).toString();
+    const stdout = execFileSync2("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd, maxBuffer: 10 * 1024 * 1024 }).toString();
     filePaths = stdout.trim().split("\n").filter(Boolean);
   } catch {
     return [];
@@ -45299,10 +45685,10 @@ function findImportedBy(cwd, targetRelPath) {
     if (!codeExts.has(ext))
       continue;
     try {
-      const content = readFileSync8(join11(cwd, fp), "utf-8");
-      const parsed = parseFile(join11(cwd, fp), content);
+      const content = readFileSync9(join12(cwd, fp), "utf-8");
+      const parsed = parseFile(join12(cwd, fp), content);
       for (const imp of parsed.imports) {
-        if (importMatchesTarget(imp.targetPath, fp, targetRelPath, targetName)) {
+        if (importMatchesTarget2(imp.targetPath, fp, targetRelPath, targetName)) {
           results.push({
             file: fp,
             symbols: imp.importedSymbols
@@ -45315,11 +45701,11 @@ function findImportedBy(cwd, targetRelPath) {
   }
   return results;
 }
-function importMatchesTarget(importPath, sourceFile, targetRelPath, targetName) {
+function importMatchesTarget2(importPath, sourceFile, targetRelPath, targetName) {
   if (!importPath.startsWith("."))
     return false;
-  const sourceDir = dirname(sourceFile);
-  const resolved = join11(sourceDir, importPath).replace(/\.[^.]+$/, "").replace(/\/index$/, "");
+  const sourceDir = dirname2(sourceFile);
+  const resolved = join12(sourceDir, importPath).replace(/\.[^.]+$/, "").replace(/\/index$/, "");
   return resolved === targetName || resolved === targetRelPath.replace(/\.[^.]+$/, "");
 }
 
@@ -45333,7 +45719,7 @@ function registerImpactTool(server) {
     const cwd = process.env.ABF_PROJECT_ROOT || process.cwd();
     try {
       const results = await ripgrepSearch({
-        query: `\\b${escapeRegex2(symbol2)}\\b`,
+        query: `\\b${escapeRegex3(symbol2)}\\b`,
         cwd,
         maxResults: 50,
         regex: true,
@@ -45388,33 +45774,33 @@ function classifyUsage(lineText, symbolName) {
   if (/^import\b/.test(trimmed) || /^from\b/.test(trimmed) || /require\(/.test(trimmed)) {
     return "import";
   }
-  if (new RegExp(`^(export\\s+)?(class|interface|type|enum)\\s+${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`^(export\\s+)?(class|interface|type|enum)\\s+${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "definition";
   }
-  if (new RegExp(`^(export\\s+)?(function|const|let|var|async\\s+function)\\s+${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`^(export\\s+)?(function|const|let|var|async\\s+function)\\s+${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "definition";
   }
-  if (new RegExp(`^(pub\\s+)?fn\\s+${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`^(pub\\s+)?fn\\s+${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "definition";
   }
-  if (new RegExp(`^def\\s+${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`^def\\s+${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "definition";
   }
-  if (new RegExp(`extends\\s+${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`extends\\s+${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "extends";
   }
-  if (new RegExp(`implements\\s+.*${escapeRegex2(symbolName)}`).test(trimmed)) {
+  if (new RegExp(`implements\\s+.*${escapeRegex3(symbolName)}`).test(trimmed)) {
     return "implements";
   }
-  if (new RegExp(`:\\s*${escapeRegex2(symbolName)}[<\\[|\\s,;>)]`).test(trimmed)) {
+  if (new RegExp(`:\\s*${escapeRegex3(symbolName)}[<\\[|\\s,;>)]`).test(trimmed)) {
     return "type_ref";
   }
-  if (new RegExp(`${escapeRegex2(symbolName)}\\s*\\(`).test(trimmed)) {
+  if (new RegExp(`${escapeRegex3(symbolName)}\\s*\\(`).test(trimmed)) {
     return "call";
   }
   return "reference";
 }
-function escapeRegex2(str) {
+function escapeRegex3(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
@@ -45572,9 +45958,51 @@ Purely heuristic \u2014 no LLM required. Useful to understand a project's style
   });
 }
 
+// ../server/dist/tools/context-bundle.js
+function registerContextBundleTool(server) {
+  server.tool("abf_context_bundle", `Bundle multi-file context around an entry point in a single call.
+Traverses the import graph from the entry file, collecting symbols and optionally source code from all connected files.
+Replaces multiple read_file + abf_symbols + abf_dependencies calls with one compact result.
+
+Modes:
+- "signatures": compact \u2014 shows exported symbols with type signatures for all files (lowest tokens)
+- "full": returns full source code for all files up to the specified depth
+- "smart" (default): full source code for the entry file, signatures for dependencies
+
+Use focus_symbol to narrow the bundle to only imports relevant to a specific function/class.
+Use reverse=true to also find files that import the entry file.`, {
+    entry: external_exports3.string().describe("Entry file path (relative to project root or absolute)"),
+    depth: external_exports3.number().int().min(0).max(4).default(1).describe("How deep to follow the import graph (0 = entry only, default: 1)"),
+    include: external_exports3.enum(["signatures", "full", "smart"]).default("smart").describe('What to include: "signatures" (compact types), "full" (source code), "smart" (full entry + signature deps)'),
+    focus_symbol: external_exports3.string().optional().describe("Focus on a specific symbol \u2014 only follows imports relevant to this function/class"),
+    reverse: external_exports3.boolean().default(false).describe("Also include files that import the entry file (reverse dependencies)")
+  }, async ({ entry, depth, include, focus_symbol, reverse }) => {
+    const projectRoot = process.env.ABF_PROJECT_ROOT || process.cwd();
+    try {
+      const result = buildContextBundle({
+        entry,
+        projectRoot,
+        depth,
+        include,
+        focusSymbol: focus_symbol,
+        reverse
+      });
+      const formatted = formatContextBundle(result);
+      return {
+        content: [{ type: "text", text: formatted }]
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text", text: `Error: ${msg}` }]
+      };
+    }
+  });
+}
+
 // ../server/dist/server.js
 var SERVER_NAME = "agents-best-friend";
-var SERVER_VERSION = "0.8.0";
+var SERVER_VERSION = "0.10.0";
 function createAbfServer() {
   const server = new McpServer({
     name: SERVER_NAME,
@@ -45598,6 +46026,7 @@ function createAbfServer() {
   registerImpactTool(server);
   registerFileSummaryTool(server);
   registerConventionsTool(server);
+  registerContextBundleTool(server);
   return server;
 }
 async function startStdioServer() {
@@ -45623,7 +46052,7 @@ async function startCommand() {
 
 // src/index.ts
 var program = new Command();
-program.name("abf").description("AgentsBestFriend \u2014 AI-first code navigation and analysis tools").version("0.8.0");
+program.name("abf").description("AgentsBestFriend \u2014 AI-first code navigation and analysis tools").version("0.10.0");
 program.command("start").description("Start the MCP server in stdio mode (for AI agent connections)").action(async () => {
   await startCommand();
 });