feat(tools): consolidate view_range into read_file and remove view_range

`read_file` now supports:

- whole-file reads: `{ path }`
- ranged reads: `{ path, startLine, endLine }`
- first N lines: `{ path, maxLines }`
- N lines from a start: `{ path, startLine, maxLines }`
- start to EOF: `{ path, startLine }`

Partial reads return line-numbered output. `endLine` and `maxLines` cannot be combined.

Updated:

- tool constants/read tool set
- tool definitions
- dispatcher validation/execution
- prompt text
- filesystem and dispatcher tests
- registry tests

Author: remarkablemark

src/constants/prompt.ts

@@ -16,7 +16,7 @@ Follow these rules:
 When tools return results, incorporate them into your response naturally`;
 
 export const TOOL_INSTRUCTIONS = `Available tools:
-- read_file: Read file contents at a path
+- read_file: Read file contents at a path; supports startLine, endLine, and maxLines options
 - write_file: Write content to a file (requires approval)
 - edit_file: Replace one exact text match in a file (requires approval)
 - create_directory: Create a directory and missing parent directories (requires approval)

src/constants/tool.ts

@@ -8,7 +8,6 @@ export const RUN_SHELL = 'run_shell';
 export const LIST_DIR = 'list_dir';
 export const FIND_FILES = 'find_files';
 export const GREP_SEARCH = 'grep_search';
-export const VIEW_RANGE = 'view_range';
 export const WEB_SEARCH = 'web_search';
 export const WEB_FETCH = 'web_fetch';
 
@@ -17,7 +16,6 @@ export const READ_TOOL_NAMES = [
   LIST_DIR,
   FIND_FILES,
   GREP_SEARCH,
-  VIEW_RANGE,
   WEB_SEARCH,
   WEB_FETCH,
 ] as const;

src/utils/tools/definitions.test.ts

@@ -3,7 +3,7 @@ import { READ_TOOLS, TOOLS, WRITE_TOOLS } from './definitions';
 describe('definitions', () => {
   describe('TOOLS', () => {
     it('exports tool definitions', () => {
-      expect(TOOLS).toHaveLength(13);
+      expect(TOOLS).toHaveLength(12);
       expect(TOOLS.map((t) => t.function.name)).toContain('read_file');
       expect(TOOLS.map((t) => t.function.name)).toContain('write_file');
       expect(TOOLS.map((t) => t.function.name)).toContain('edit_file');
@@ -14,7 +14,6 @@ describe('definitions', () => {
       expect(TOOLS.map((t) => t.function.name)).toContain('list_dir');
       expect(TOOLS.map((t) => t.function.name)).toContain('find_files');
       expect(TOOLS.map((t) => t.function.name)).toContain('grep_search');
-      expect(TOOLS.map((t) => t.function.name)).toContain('view_range');
       expect(TOOLS.map((t) => t.function.name)).toContain('web_search');
       expect(TOOLS.map((t) => t.function.name)).toContain('web_fetch');
     });

src/utils/tools/definitions.ts

@@ -37,9 +37,22 @@ function defineTool(
 export const TOOLS = [
   defineTool(
     TOOL.READ_FILE,
-    'Read the contents of a file at the specified path',
+    'Read the contents of a file at the specified path, optionally limited by line range',
     {
       path: { type: 'string', description: 'The path to the file to read' },
+      startLine: {
+        type: 'number',
+        description: 'Optional starting line number to read from (1-indexed)',
+      },
+      endLine: {
+        type: 'number',
+        description: 'Optional ending line number to read through (inclusive)',
+      },
+      maxLines: {
+        type: 'number',
+        description:
+          'Optional maximum number of lines to read; cannot be combined with endLine',
+      },
     },
     ['path'],
   ),
@@ -184,23 +197,6 @@ export const TOOLS = [
     ['pattern', 'path'],
   ),
 
-  defineTool(
-    TOOL.VIEW_RANGE,
-    'View a specific range of lines from a file',
-    {
-      path: { type: 'string', description: 'The path to the file' },
-      start: {
-        type: 'number',
-        description: 'The starting line number (1-indexed)',
-      },
-      end: {
-        type: 'number',
-        description: 'The ending line number (inclusive)',
-      },
-    },
-    ['path', 'start', 'end'],
-  ),
-
   defineTool(
     TOOL.WEB_SEARCH,
     'Search the web for external or current information',

src/utils/tools/dispatcher.test.ts

@@ -282,6 +282,52 @@ describe('dispatcher', () => {
       );
     });
 
+    it('returns error when read_file range args are not numbers', async () => {
+      const result = await executeTool('read_file', {
+        path: '/test.txt',
+        startLine: '2',
+      });
+
+      expect(result.error).toContain(
+        'Invalid optional numeric argument: startLine',
+      );
+    });
+
+    it('returns error when read_file range args are below one', async () => {
+      const result = await executeTool('read_file', {
+        path: '/test.txt',
+        maxLines: 0,
+      });
+
+      expect(result.error).toContain(
+        'Invalid read range: startLine, endLine, and maxLines must be >= 1',
+      );
+    });
+
+    it('returns error when read_file combines endLine and maxLines', async () => {
+      const result = await executeTool('read_file', {
+        path: '/test.txt',
+        endLine: 3,
+        maxLines: 2,
+      });
+
+      expect(result.error).toContain(
+        'Invalid read range: endLine cannot be combined with maxLines',
+      );
+    });
+
+    it('returns error when read_file endLine is less than startLine', async () => {
+      const result = await executeTool('read_file', {
+        path: '/test.txt',
+        endLine: 2,
+        startLine: 5,
+      });
+
+      expect(result.error).toContain(
+        'Invalid read range: endLine must be >= startLine',
+      );
+    });
+
     it('executes read_file tool', async () => {
       vi.mocked(existsSync).mockReturnValue(true);
       vi.mocked(readFileSync).mockReturnValue('file content');
@@ -291,6 +337,20 @@ describe('dispatcher', () => {
       expect(result.error).toBeUndefined();
     });
 
+    it('executes read_file tool with line range', async () => {
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(readFileSync).mockReturnValue('line1\nline2\nline3');
+
+      const result = await executeTool('read_file', {
+        path: '/test.txt',
+        endLine: 3,
+        startLine: 2,
+      });
+
+      expect(result.content).toBe('2: line2\n3: line3');
+      expect(result.error).toBeUndefined();
+    });
+
     it('executes write_file tool', async () => {
       const result = await executeTool('write_file', {
         path: '/test.txt',
@@ -499,43 +559,6 @@ describe('dispatcher', () => {
       expect(result.error).toBeUndefined();
     });
 
-    it('executes view_range tool', async () => {
-      vi.mocked(existsSync).mockReturnValue(true);
-      vi.mocked(readFileSync).mockReturnValue(
-        'line1\nline2\nline3\nline4\nline5',
-      );
-
-      const result = await executeTool('view_range', {
-        path: '/test.txt',
-        start: 2,
-        end: 4,
-      });
-      expect(result.content).toContain('line2');
-      expect(result.content).toContain('line3');
-      expect(result.content).toContain('line4');
-      expect(result.error).toBeUndefined();
-    });
-
-    it('returns error for invalid view_range numeric arguments', async () => {
-      const result = await executeTool('view_range', {
-        path: '/test.txt',
-        start: '2',
-        end: 4,
-      });
-
-      expect(result.error).toContain('Missing required numeric arguments');
-    });
-
-    it('returns error when view_range end is less than start', async () => {
-      const result = await executeTool('view_range', {
-        path: '/test.txt',
-        start: 5,
-        end: 2,
-      });
-
-      expect(result.error).toContain('Invalid line range');
-    });
-
     it('executes web_search tool', async () => {
       mockFetch.mockResolvedValue({
         ok: true,

src/utils/tools/dispatcher.ts

@@ -12,7 +12,6 @@ import {
   listDir,
   readFile,
   renamePath,
-  viewRange,
   writeFile,
 } from './filesystem';
 import { runShell } from './shell';
@@ -39,7 +38,6 @@ const REQUIRED_STRING_ARGS: Record<ToolName, string[]> = {
   [TOOL.LIST_DIR]: ['path'],
   [TOOL.FIND_FILES]: ['path'],
   [TOOL.GREP_SEARCH]: ['pattern', 'path'],
-  [TOOL.VIEW_RANGE]: ['path'],
   [TOOL.WEB_SEARCH]: ['query'],
   [TOOL.WEB_FETCH]: ['url'],
 } as const;
@@ -68,22 +66,45 @@ function validateArgs(
     }
   }
 
-  if (name === TOOL.VIEW_RANGE) {
-    if (!Number.isInteger(args.start) || !Number.isInteger(args.end)) {
+  if (name === TOOL.READ_FILE) {
+    const numericArgs = ['startLine', 'endLine', 'maxLines'] as const;
+
+    for (const key of numericArgs) {
+      if (args[key] !== undefined && !Number.isInteger(args[key])) {
+        return {
+          content: '',
+          error: `Invalid optional numeric argument: ${key} (received keys: ${received})`,
+        };
+      }
+    }
+
+    if (
+      (typeof args.startLine === 'number' && args.startLine < 1) ||
+      (typeof args.endLine === 'number' && args.endLine < 1) ||
+      (typeof args.maxLines === 'number' && args.maxLines < 1)
+    ) {
       return {
         content: '',
-        error: `Missing required numeric arguments: start, end (received keys: ${received})`,
+        error:
+          'Invalid read range: startLine, endLine, and maxLines must be >= 1',
+      };
+    }
+
+    if (args.endLine !== undefined && args.maxLines !== undefined) {
+      return {
+        content: '',
+        error: 'Invalid read range: endLine cannot be combined with maxLines',
       };
     }
 
     if (
-      (args.start as number) < 1 ||
-      (args.end as number) < (args.start as number)
+      typeof args.startLine === 'number' &&
+      typeof args.endLine === 'number' &&
+      args.endLine < args.startLine
     ) {
       return {
         content: '',
-        error:
-          'Invalid line range: start must be >= 1 and end must be >= start',
+        error: 'Invalid read range: endLine must be >= startLine',
       };
     }
   }
@@ -248,7 +269,11 @@ export async function executeTool(
 
   switch (name) {
     case TOOL.READ_FILE:
-      return readFile(stringArgs.path);
+      return readFile(stringArgs.path, {
+        endLine: args.endLine as number | undefined,
+        maxLines: args.maxLines as number | undefined,
+        startLine: args.startLine as number | undefined,
+      });
 
     case TOOL.WRITE_FILE:
       return writeFile(stringArgs.path, stringArgs.content);
@@ -281,13 +306,6 @@ export async function executeTool(
     case TOOL.GREP_SEARCH:
       return await grepSearch(stringArgs.pattern, stringArgs.path);
 
-    case TOOL.VIEW_RANGE:
-      return viewRange(
-        stringArgs.path,
-        args.start as number,
-        args.end as number,
-      );
-
     case TOOL.WEB_SEARCH:
       return await webSearch(stringArgs.query);