@flyingrobots/graft 0.4.0 → 0.6.0

package/src/mcp/tools/precision-live.ts

@@ -0,0 +1,158 @@
+import { getFileAtRef } from "../../git/diff.js";
+import { detectLang } from "../../parser/lang.js";
+import { extractOutline } from "../../parser/outline.js";
+import type { JumpEntry, OutlineEntry } from "../../parser/types.js";
+import type { ToolContext } from "../context.js";
+import { evaluateMcpRefusal, type McpPolicyRefusal } from "../policy.js";
+import type { RankedPrecisionSymbolMatch } from "./precision-query.js";
+import { PrecisionSearchRequest } from "./precision-query.js";
+import { PrecisionSymbolMatch } from "./precision-match.js";
+
+const MAX_RANGE_LINES = 250;
+
+function buildJumpLookup(
+  jumpTable: readonly JumpEntry[],
+): Map<string, { start: number; end: number }[]> {
+  const lookup = new Map<string, { start: number; end: number }[]>();
+  for (const entry of jumpTable) {
+    const existing = lookup.get(entry.symbol) ?? [];
+    existing.push({ start: entry.start, end: entry.end });
+    lookup.set(entry.symbol, existing);
+  }
+  return lookup;
+}
+
+export type PrecisionPolicyRefusal = McpPolicyRefusal;
+
+export function collectSymbols(
+  entries: readonly OutlineEntry[],
+  filePath: string,
+  jumpTable: readonly JumpEntry[],
+  jumpCursor: Map<string, number> = new Map<string, number>(),
+): PrecisionSymbolMatch[] {
+  const jumpLookup = buildJumpLookup(jumpTable);
+  const results: PrecisionSymbolMatch[] = [];
+
+  for (const entry of entries) {
+    const candidates = jumpLookup.get(entry.name) ?? [];
+    const jumpIndex = jumpCursor.get(entry.name) ?? 0;
+    const jump = candidates[jumpIndex];
+    if (jump !== undefined) {
+      jumpCursor.set(entry.name, jumpIndex + 1);
+    }
+    results.push(new PrecisionSymbolMatch({
+      name: entry.name,
+      kind: entry.kind,
+      path: filePath,
+      exported: entry.exported,
+      ...(entry.signature !== undefined ? { signature: entry.signature } : {}),
+      ...(jump?.start !== undefined ? { startLine: jump.start } : {}),
+      ...(jump?.end !== undefined ? { endLine: jump.end } : {}),
+    }));
+
+    if (entry.children !== undefined && entry.children.length > 0) {
+      results.push(...collectSymbols(entry.children, filePath, jumpTable, jumpCursor));
+    }
+  }
+
+  return results;
+}
+
+export async function loadFileContent(
+  ctx: ToolContext,
+  filePath: string,
+  ref?: string,
+): Promise<string | null> {
+  if (ref !== undefined) {
+    return getFileAtRef(ref, filePath, { cwd: ctx.projectRoot, git: ctx.git });
+  }
+
+  try {
+    return await ctx.fs.readFile(ctx.resolvePath(filePath), "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+export function evaluatePrecisionPolicy(
+  ctx: ToolContext,
+  filePath: string,
+  content: string,
+): PrecisionPolicyRefusal | null {
+  const actual = {
+    lines: content.split("\n").length,
+    bytes: Buffer.byteLength(content),
+  };
+  return evaluateMcpRefusal(ctx, filePath, actual);
+}
+
+export async function searchLiveSymbols(
+  ctx: ToolContext,
+  filePaths: readonly string[],
+  request: PrecisionSearchRequest,
+  ref?: string,
+): Promise<PrecisionSymbolMatch[]> {
+  const matches: RankedPrecisionSymbolMatch[] = [];
+
+  for (const filePath of filePaths) {
+    const lang = detectLang(filePath);
+    if (lang === null) continue;
+
+    const content = await loadFileContent(ctx, filePath, ref);
+    if (content === null) continue;
+
+    const result = extractOutline(content, lang);
+    const symbols = collectSymbols(result.entries, filePath, result.jumpTable ?? []);
+
+    for (const symbol of symbols) {
+      const ranked = request.rank(symbol);
+      if (ranked !== null) matches.push(ranked);
+    }
+  }
+
+  return request.sort(matches);
+}
+
+export function readRangeFromContent(
+  filePath: string,
+  content: string,
+  start: number,
+  end: number,
+): {
+  path: string;
+  content?: string | undefined;
+  startLine?: number | undefined;
+  endLine?: number | undefined;
+  truncated?: boolean | undefined;
+  clipped?: boolean | undefined;
+  reason?: string | undefined;
+} {
+  if (start > end) {
+    return { path: filePath, reason: "INVALID_RANGE" };
+  }
+
+  const allLines = content.split("\n");
+  const totalLines = allLines.length;
+  let effectiveEnd = end;
+  let truncated = false;
+  let clipped = false;
+
+  if (effectiveEnd - start + 1 > MAX_RANGE_LINES) {
+    effectiveEnd = start + MAX_RANGE_LINES - 1;
+    truncated = true;
+  }
+
+  if (effectiveEnd > totalLines) {
+    effectiveEnd = totalLines;
+    clipped = true;
+  }
+
+  return {
+    path: filePath,
+    content: allLines.slice(start - 1, effectiveEnd).join("\n"),
+    startLine: start,
+    endLine: effectiveEnd,
+    ...(truncated ? { truncated: true, reason: "RANGE_EXCEEDED" } : {}),
+    ...(clipped ? { clipped: true } : {}),
+  };
+}

package/src/mcp/tools/precision-match.ts

@@ -0,0 +1,54 @@
+export class PrecisionSymbolMatch {
+  readonly name: string;
+  readonly kind: string;
+  readonly path: string;
+  readonly identityId?: string;
+  readonly signature?: string;
+  readonly exported: boolean;
+  readonly startLine?: number;
+  readonly endLine?: number;
+
+  constructor(opts: {
+    name: string;
+    kind: string;
+    path: string;
+    identityId?: string;
+    signature?: string;
+    exported: boolean;
+    startLine?: number;
+    endLine?: number;
+  }) {
+    if (opts.name.trim().length === 0) {
+      throw new Error("PrecisionSymbolMatch: name must be non-empty");
+    }
+    if (opts.kind.trim().length === 0) {
+      throw new Error("PrecisionSymbolMatch: kind must be non-empty");
+    }
+    if (opts.path.trim().length === 0) {
+      throw new Error("PrecisionSymbolMatch: path must be non-empty");
+    }
+    if (opts.startLine !== undefined && (!Number.isInteger(opts.startLine) || opts.startLine < 1)) {
+      throw new Error("PrecisionSymbolMatch: startLine must be an integer >= 1");
+    }
+    if (opts.endLine !== undefined && (!Number.isInteger(opts.endLine) || opts.endLine < 1)) {
+      throw new Error("PrecisionSymbolMatch: endLine must be an integer >= 1");
+    }
+    if (
+      opts.startLine !== undefined &&
+      opts.endLine !== undefined &&
+      opts.endLine < opts.startLine
+    ) {
+      throw new Error("PrecisionSymbolMatch: endLine must be >= startLine");
+    }
+
+    this.name = opts.name.trim();
+    this.kind = opts.kind.trim();
+    this.path = opts.path.trim();
+    this.exported = opts.exported;
+    if (opts.identityId !== undefined) this.identityId = opts.identityId;
+    if (opts.signature !== undefined) this.signature = opts.signature;
+    if (opts.startLine !== undefined) this.startLine = opts.startLine;
+    if (opts.endLine !== undefined) this.endLine = opts.endLine;
+    Object.freeze(this);
+  }
+}

package/src/mcp/tools/precision-paths.ts

@@ -0,0 +1,59 @@
+import * as path from "node:path";
+import { GitError } from "../../git/diff.js";
+import type { GitClient } from "../../ports/git.js";
+
+async function git(gitClient: GitClient, args: readonly string[], cwd: string): Promise<string> {
+  const result = await gitClient.run({ args, cwd });
+  if (result.error !== undefined || result.status !== 0) {
+    throw result.error ?? new Error(result.stderr.trim() || `git exited with status ${String(result.status)}`);
+  }
+  return result.stdout;
+}
+
+export function normalizeRepoPath(projectRoot: string, input: string): string {
+  if (!path.isAbsolute(input)) return input;
+  const rel = path.relative(projectRoot, input);
+  if (rel === "") return ".";
+  return rel.startsWith("..") ? input : rel;
+}
+
+export function requireRepoPath(projectRoot: string, input: string): string {
+  const normalized = normalizeRepoPath(projectRoot, input);
+  if (path.isAbsolute(normalized)) {
+    throw new Error(`Path must be inside the repository for git-ref queries: ${input}`);
+  }
+  return normalized;
+}
+
+export async function resolveGitRef(ref: string, gitClient: GitClient, cwd: string): Promise<string> {
+  try {
+    return (await git(gitClient, ["rev-parse", "--verify", ref], cwd)).trim();
+  } catch {
+    throw new GitError(`ref does not exist: ${ref}`);
+  }
+}
+
+export async function listTrackedFilesAtRef(
+  dirPath: string,
+  gitClient: GitClient,
+  cwd: string,
+  ref: string,
+): Promise<string[]> {
+  try {
+    const args = dirPath.length > 0
+      ? ["ls-tree", "-r", "--name-only", ref, "--", dirPath]
+      : ["ls-tree", "-r", "--name-only", ref];
+    const output = (await git(gitClient, args, cwd)).trim();
+    return output.length === 0 ? [] : output.split("\n");
+  } catch {
+    return [];
+  }
+}
+
+export async function isWorkingTreeDirty(gitClient: GitClient, cwd: string): Promise<boolean> {
+  try {
+    return (await git(gitClient, ["status", "--porcelain"], cwd)).trim().length > 0;
+  } catch {
+    return true;
+  }
+}

package/src/mcp/tools/precision-query.ts

@@ -0,0 +1,127 @@
+import picomatch from "picomatch";
+import { PrecisionSymbolMatch } from "./precision-match.js";
+
+type SymbolQueryMode = "glob" | "plain";
+
+export class RankedPrecisionSymbolMatch {
+  readonly match: PrecisionSymbolMatch;
+  readonly score: number;
+
+  constructor(opts: {
+    match: PrecisionSymbolMatch;
+    score: number;
+  }) {
+    if (opts.score < 0) {
+      throw new Error("RankedPrecisionSymbolMatch: score must be >= 0");
+    }
+    this.match = opts.match;
+    this.score = opts.score;
+    Object.freeze(this);
+  }
+}
+
+class PrecisionSymbolQuery {
+  readonly text: string;
+  readonly mode: SymbolQueryMode;
+  readonly #globMatcher?: (name: string) => boolean;
+
+  constructor(query: string) {
+    const normalizedQuery = query.trim();
+    if (normalizedQuery.length === 0) {
+      throw new Error("PrecisionSymbolQuery: query must be non-empty");
+    }
+    this.text = normalizedQuery;
+    if (picomatch.scan(normalizedQuery).isGlob) {
+      this.mode = "glob";
+      this.#globMatcher = picomatch(normalizedQuery, { nocase: true });
+    } else {
+      this.mode = "plain";
+    }
+    Object.freeze(this);
+  }
+
+  score(name: string): number | null {
+    if (this.mode === "glob") {
+      return this.#globMatcher?.(name) === true ? 0 : null;
+    }
+
+    const loweredName = name.toLowerCase();
+    const loweredQuery = this.text.toLowerCase();
+    if (name === this.text) return 0;
+    if (loweredName === loweredQuery) return 1;
+    if (name.startsWith(this.text)) return 2;
+    if (loweredName.startsWith(loweredQuery)) return 3;
+    return loweredName.includes(loweredQuery) ? 4 : null;
+  }
+}
+
+export class PrecisionSearchRequest {
+  readonly exactName?: string;
+  readonly query?: PrecisionSymbolQuery;
+  readonly kind?: string;
+  readonly filePath?: string;
+  readonly pathPrefix?: string;
+  readonly ceiling?: number;
+
+  constructor(opts: {
+    exactName?: string;
+    query?: string;
+    kind?: string;
+    filePath?: string;
+    pathPrefix?: string;
+    ceiling?: number;
+  }) {
+    const exactName = opts.exactName?.trim();
+    const query = opts.query?.trim();
+    const kind = opts.kind?.trim().toLowerCase();
+    const filePath = opts.filePath?.trim();
+    const pathPrefix = opts.pathPrefix?.trim();
+
+    if ((exactName?.length ?? 0) === 0 && (query?.length ?? 0) === 0) {
+      throw new Error("PrecisionSearchRequest: exactName or query is required");
+    }
+    if (
+      opts.ceiling !== undefined &&
+      (!Number.isInteger(opts.ceiling) || opts.ceiling < 1)
+    ) {
+      throw new Error("PrecisionSearchRequest: ceiling must be an integer >= 1");
+    }
+
+    if (exactName !== undefined && exactName.length > 0) this.exactName = exactName;
+    if (query !== undefined && query.length > 0) this.query = new PrecisionSymbolQuery(query);
+    if (kind !== undefined && kind.length > 0) this.kind = kind;
+    if (filePath !== undefined && filePath.length > 0) this.filePath = filePath;
+    if (pathPrefix !== undefined && pathPrefix.length > 0) this.pathPrefix = pathPrefix;
+    if (opts.ceiling !== undefined) this.ceiling = opts.ceiling;
+    Object.freeze(this);
+  }
+
+  selectLens(): "file" | "exact" | "all" {
+    if (this.filePath !== undefined) return "file";
+    if (this.exactName !== undefined) return "exact";
+    return "all";
+  }
+
+  rank(match: PrecisionSymbolMatch): RankedPrecisionSymbolMatch | null {
+    if (this.exactName !== undefined && match.name !== this.exactName) return null;
+    if (this.kind !== undefined && match.kind.toLowerCase() !== this.kind) return null;
+    if (this.filePath !== undefined && match.path !== this.filePath) return null;
+    if (this.pathPrefix !== undefined && !match.path.startsWith(this.pathPrefix)) return null;
+    if (this.query === undefined) {
+      return new RankedPrecisionSymbolMatch({ match, score: 0 });
+    }
+    const score = this.query.score(match.name);
+    return score === null ? null : new RankedPrecisionSymbolMatch({ match, score });
+  }
+
+  sort(matches: readonly RankedPrecisionSymbolMatch[]): PrecisionSymbolMatch[] {
+    return [...matches]
+      .sort((a, b) =>
+        a.score - b.score ||
+        (this.query?.mode === "plain" ? a.match.name.length - b.match.name.length : 0) ||
+        a.match.path.localeCompare(b.match.path) ||
+        a.match.name.localeCompare(b.match.name)
+      )
+      .map((entry) => entry.match);
+  }
+}

package/src/mcp/tools/precision-show.ts

@@ -0,0 +1,86 @@
+import type { ToolContext } from "../context.js";
+import { listProjectFiles } from "./git-files.js";
+import {
+  getIndexedCommitCeilings,
+  searchWarpSymbols,
+} from "./precision-warp.js";
+import {
+  listTrackedFilesAtRef,
+  requireRepoPath,
+  resolveGitRef,
+} from "./precision-paths.js";
+import {
+  searchLiveSymbols,
+} from "./precision-live.js";
+import { PrecisionSearchRequest } from "./precision-query.js";
+import type { PrecisionSymbolMatch } from "./precision-match.js";
+
+export interface CodeShowResolution {
+  readonly layer: "commit_worldline" | "ref_view" | "workspace_overlay";
+  readonly source: "warp" | "live";
+  readonly resolvedRef?: string | undefined;
+  readonly locations: PrecisionSymbolMatch[];
+}
+
+export async function resolveCodeShowLocations(
+  ctx: ToolContext,
+  input: {
+    symbolName: string;
+    targetPath?: string | undefined;
+    ref?: string | undefined;
+    allowWarp: boolean;
+  },
+): Promise<CodeShowResolution> {
+  const repoState = ctx.getRepoState();
+  const layer = input.ref !== undefined
+    ? "commit_worldline"
+    : repoState.dirty
+      ? "workspace_overlay"
+      : "ref_view";
+
+  let resolvedRef: string | undefined;
+  if (input.ref !== undefined) {
+    resolvedRef = await resolveGitRef(input.ref, ctx.git, ctx.projectRoot);
+  }
+
+  if (resolvedRef !== undefined) {
+    const repoPath = input.targetPath !== undefined
+      ? requireRepoPath(ctx.projectRoot, input.targetPath)
+      : undefined;
+
+    if (input.allowWarp) {
+      const warp = await ctx.getWarp();
+      const ceilings = await getIndexedCommitCeilings(warp);
+      const ceiling = ceilings.get(resolvedRef);
+      if (ceiling !== undefined) {
+        const locations = await searchWarpSymbols(warp, new PrecisionSearchRequest({
+          exactName: input.symbolName,
+          ...(repoPath !== undefined ? { filePath: repoPath } : {}),
+          ceiling,
+        }));
+        return { layer, source: "warp", resolvedRef, locations };
+      }
+    }
+
+    const filePaths = repoPath !== undefined
+      ? [repoPath]
+      : await listTrackedFilesAtRef("", ctx.git, ctx.projectRoot, resolvedRef);
+    const locations = await searchLiveSymbols(
+      ctx,
+      filePaths,
+      new PrecisionSearchRequest({ exactName: input.symbolName }),
+      resolvedRef,
+    );
+    return { layer, source: "live", resolvedRef, locations };
+  }
+
+  const filePaths = input.targetPath !== undefined
+    ? [input.targetPath]
+    : await listProjectFiles("", ctx.projectRoot, ctx.git);
+  const locations = await searchLiveSymbols(
+    ctx,
+    filePaths,
+    new PrecisionSearchRequest({ exactName: input.symbolName }),
+  );
+  return { layer, source: "live", locations };
+}

package/src/mcp/tools/precision-visibility.ts

@@ -0,0 +1,44 @@
+import type { ToolContext } from "../context.js";
+import {
+  evaluatePrecisionPolicy,
+  loadFileContent,
+  type PrecisionPolicyRefusal,
+} from "./precision-live.js";
+import type { PrecisionSymbolMatch } from "./precision-match.js";
+
+export interface PrecisionVisibilityResult {
+  readonly visibleMatches: PrecisionSymbolMatch[];
+  readonly fileCache: Map<string, string>;
+  readonly firstRefusal:
+    | PrecisionPolicyRefusal
+    | undefined;
+}
+
+export async function filterVisiblePrecisionMatches(
+  ctx: ToolContext,
+  matches: readonly PrecisionSymbolMatch[],
+  ref?: string,
+): Promise<PrecisionVisibilityResult> {
+  const visibleMatches: PrecisionSymbolMatch[] = [];
+  const fileCache = new Map<string, string>();
+  let firstRefusal: PrecisionPolicyRefusal | undefined;
+
+  for (const match of matches) {
+    let content = fileCache.get(match.path);
+    if (content === undefined) {
+      const loaded = await loadFileContent(ctx, match.path, ref);
+      if (loaded === null) continue;
+      fileCache.set(match.path, loaded);
+      content = loaded;
+    }
+
+    const refusal = evaluatePrecisionPolicy(ctx, match.path, content);
+    if (refusal !== null) {
+      firstRefusal ??= refusal;
+      continue;
+    }
+    visibleMatches.push(match);
+  }
+
+  return { visibleMatches, fileCache, firstRefusal };
+}

package/src/mcp/tools/precision-warp.ts

@@ -0,0 +1,90 @@
+import type { WarpHandle } from "../../ports/warp.js";
+import { allSymbolsLens, commitsLens, fileSymbolsLens, symbolByNameLens } from "../../warp/observers.js";
+import type { RankedPrecisionSymbolMatch } from "./precision-query.js";
+import { PrecisionSearchRequest } from "./precision-query.js";
+import { PrecisionSymbolMatch } from "./precision-match.js";
+
+function decodeSymbolPath(nodeId: string): string | null {
+  if (!nodeId.startsWith("sym:")) return null;
+  const lastColon = nodeId.lastIndexOf(":");
+  if (lastColon <= "sym:".length) return null;
+  return nodeId.slice("sym:".length, lastColon);
+}
+
+function toMatch(
+  nodeId: string,
+  props: Record<string, unknown>,
+): PrecisionSymbolMatch | null {
+  const name = props["name"];
+  const kind = props["kind"];
+  const path = decodeSymbolPath(nodeId);
+  if (typeof name !== "string" || typeof kind !== "string" || path === null) {
+    return null;
+  }
+
+  return new PrecisionSymbolMatch({
+    name,
+    kind,
+    path,
+    ...(typeof props["identityId"] === "string" ? { identityId: props["identityId"] } : {}),
+    ...(typeof props["signature"] === "string" ? { signature: props["signature"] } : {}),
+    exported: props["exported"] === true,
+    ...(typeof props["startLine"] === "number" ? { startLine: props["startLine"] } : {}),
+    ...(typeof props["endLine"] === "number" ? { endLine: props["endLine"] } : {}),
+  });
+}
+
+export async function getIndexedCommitCeilings(warp: WarpHandle): Promise<ReadonlyMap<string, number>> {
+  const ceilings = new Map<string, number>();
+  const observer = await warp.observer(commitsLens());
+  const nodeIds = await observer.getNodes();
+
+  for (const nodeId of nodeIds) {
+    const props = await observer.getNodeProps(nodeId);
+    const sha = typeof props?.["sha"] === "string" ? props["sha"] : null;
+    const tick = typeof props?.["tick"] === "number" ? props["tick"] : null;
+    if (sha !== null && tick !== null) {
+      ceilings.set(sha, tick);
+    }
+  }
+
+  return ceilings;
+}
+
+export async function searchWarpSymbols(
+  warp: WarpHandle,
+  request: PrecisionSearchRequest,
+): Promise<PrecisionSymbolMatch[]> {
+  const lensMode = request.selectLens();
+  let lens;
+  if (lensMode === "file") {
+    if (request.filePath === undefined) {
+      throw new Error("PrecisionSearchRequest selected file lens without filePath");
+    }
+    lens = fileSymbolsLens(request.filePath);
+  } else if (lensMode === "exact") {
+    if (request.exactName === undefined) {
+      throw new Error("PrecisionSearchRequest selected exact lens without exactName");
+    }
+    lens = symbolByNameLens(request.exactName);
+  } else {
+    lens = allSymbolsLens();
+  }
+
+  const observer = await warp.observer(
+    lens,
+    request.ceiling !== undefined ? { source: { kind: "live", ceiling: request.ceiling } } : undefined,
+  );
+  const nodeIds = await observer.getNodes();
+
+  const matches = await Promise.all(nodeIds.map(async (nodeId) => {
+    const props = await observer.getNodeProps(nodeId);
+    if (props === null) return null;
+    const match = toMatch(nodeId, props);
+    if (match === null) return null;
+    return request.rank(match);
+  }));
+
+  const visibleMatches = matches.filter((match): match is RankedPrecisionSymbolMatch => match !== null);
+  return request.sort(visibleMatches);
+}

package/src/mcp/tools/precision.ts

@@ -0,0 +1,21 @@
+export { PrecisionSearchRequest } from "./precision-query.js";
+export { PrecisionSymbolMatch } from "./precision-match.js";
+export type { PrecisionPolicyRefusal } from "./precision-live.js";
+export {
+  collectSymbols,
+  loadFileContent,
+  evaluatePrecisionPolicy,
+  searchLiveSymbols,
+  readRangeFromContent,
+} from "./precision-live.js";
+export {
+  normalizeRepoPath,
+  requireRepoPath,
+  resolveGitRef,
+  listTrackedFilesAtRef,
+  isWorkingTreeDirty,
+} from "./precision-paths.js";
+export {
+  getIndexedCommitCeilings,
+  searchWarpSymbols,
+} from "./precision-warp.js";

package/src/mcp/tools/read-range.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { readRange } from "../../operations/read-range.js";
-import type { ToolDefinition, ToolContext, ToolHandler } from "../context.js";
+import type { ToolDefinition, ToolHandler } from "../context.js";
+import { toJsonObject } from "../../operations/result-dto.js";
 
 export const readRangeTool: ToolDefinition = {
   name: "read_range",
@@ -10,12 +11,18 @@ export const readRangeTool: ToolDefinition = {
     "specific symbols.",
   schema: { path: z.string(), start: z.number(), end: z.number() },
   policyCheck: true,
-  createHandler(ctx: ToolContext): ToolHandler {
-    return async (args) => {
+  createHandler(): ToolHandler {
+    return async (args, ctx) => {
       const filePath = ctx.resolvePath(args["path"] as string);
-      const result = await readRange(filePath, args["start"] as number, args["end"] as number, { fs: ctx.fs });
+      const startLine = args["start"] as number;
+      const endLine = args["end"] as number;
+      const result = await readRange(filePath, startLine, endLine, { fs: ctx.fs });
       ctx.metrics.recordRead();
-      return ctx.respond("read_range", result);
+      ctx.recordFootprint({
+        paths: [filePath],
+        regions: [{ path: filePath, startLine, endLine }],
+      });
+      return ctx.respond("read_range", toJsonObject(result));
     };
   },
 };