lonny-agent 0.2.6 → 0.2.7

package/src/index.ts

@@ -2,6 +2,7 @@
 import { execSync } from 'node:child_process'
 import * as os from 'node:os'
 import { runAgent } from './agent/index.js'
+import { Session } from './agent/session.js'
 import { parseArgs } from './cli/index.js'
 import { fmtErr } from './tools/errors.js'
 import { startTui } from './tui/index.js'
@@ -27,7 +28,9 @@ function tryEnableUtf8(): void {
 
 async function main() {
   tryEnableUtf8()
-  const { config, prompt, web, port, init } = await parseArgs(process.argv)
+  const { config, prompt, web, port, init, continueSession, sessionId } = await parseArgs(
+    process.argv,
+  )
 
   // init command exits after completion
   if (init) {
@@ -41,12 +44,36 @@ async function main() {
     process.exit(1)
   }
 
+  let loadedSession: Session | null = null
+
+  // Handle --continue and --session flags
+  if (continueSession || sessionId) {
+    if (sessionId) {
+      loadedSession = await Session.loadById(sessionId, config)
+      if (loadedSession) {
+        console.log(
+          `${BLD}Resuming session:${RS} ${loadedSession.sessionTitle || loadedSession.sessionId}`,
+        )
+      } else {
+        console.error(`${RE}Error:${RS} Session not found: ${sessionId}`)
+        process.exit(1)
+      }
+    } else {
+      loadedSession = await Session.load(config)
+      if (loadedSession) {
+        console.log(
+          `${BLD}Continuing last session:${RS} ${loadedSession.sessionTitle || loadedSession.sessionId}`,
+        )
+      }
+    }
+  }
+
   if (web) {
     await startWebUi(config, port || 15090)
   } else if (prompt) {
-    await runAgent(prompt, config)
+    await runAgent(prompt, config, loadedSession ?? undefined)
   } else {
-    await startTui(config)
+    await startTui(config, loadedSession ?? undefined)
   }
 }
 

package/src/tools/__tests__/bash.test.ts

@@ -1,5 +1,12 @@
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
 import { describe, expect, it } from 'vitest'
-import { bashTool } from '../bash.js'
+import { bashTool } from '../execute/bash/index.js'
+
+function makeTempDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'lonny-test-'))
+}
 
 describe('bash tool', () => {
   it('executes a command successfully', async () => {
@@ -25,4 +32,183 @@ describe('bash tool', () => {
     expect(result.success).toBe(true)
     expect(result.output).toContain('timed')
   })
+
+  it('includes description in output when provided', async () => {
+    const result = await bashTool.execute({
+      command: 'echo hello',
+      description: 'testing description',
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('[bash]')
+    expect(result.output).toContain('testing description')
+    expect(result.output).toContain('hello')
+  })
+
+  it('runs command in specified cwd', async () => {
+    const tmpDir = makeTempDir()
+    try {
+      // Create a marker file so we can verify cwd
+      const result = await bashTool.execute({ command: 'pwd', cwd: tmpDir })
+      expect(result.success).toBe(true)
+      // On Windows, PowerShell's Get-Location returns the path
+      // We just need to check the command executed without error
+      if (os.platform() === 'win32') {
+        // PowerShell: use Get-Location instead of pwd
+        const result2 = await bashTool.execute({
+          command: `Get-Location | Select-Object -ExpandProperty Path`,
+          cwd: tmpDir,
+        })
+        expect(result2.success).toBe(true)
+        const normalizedOutput = result2.output.replace(/\\/g, '/')
+        const normalizedTmp = tmpDir.replace(/\\/g, '/')
+        expect(normalizedOutput).toContain(normalizedTmp)
+      } else {
+        expect(result.output).toContain(tmpDir)
+      }
+    } finally {
+      fs.rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it('handles stderr output separately', async () => {
+    // PowerShell: write to stderr using Write-Error
+    const result = await bashTool.execute({
+      command: 'Write-Error "test error" 2>&1 | Out-Null; Write-Output "stdout ok"',
+    })
+    // 2>&1 redirects stderr to stdout in PowerShell, so it should succeed
+    expect(result.success).toBe(true)
+  })
+
+  it('shows (no output) for empty output', async () => {
+    // A command that produces no output
+    const result = await bashTool.execute({ command: 'Write-Output ""' })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('(no output)')
+  })
+
+  it('truncates very large output', async () => {
+    // Generate a very large output to trigger truncation
+    const result = await bashTool.execute({ command: '1..5000 | ForEach-Object { "Line $_" }' })
+    expect(result.success).toBe(true)
+    // Check if truncation warning is present (output > 10k chars)
+    if (result.output.length > 10000) {
+      expect(result.output).toContain('truncated at')
+    }
+  })
+
+  it('rejects whitespace-only command', async () => {
+    const result = await bashTool.execute({ command: '   ' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('whitespace')
+  })
+
+  it('rejects non-string command type', async () => {
+    const result = await bashTool.execute({ command: 123 })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('must be a string')
+  })
+
+  it('rejects non-existent cwd', async () => {
+    const result = await bashTool.execute({
+      command: 'echo test',
+      cwd: 'C:\\NonExistent_Directory_XYZ_123',
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('does not exist')
+  })
+
+  it('blocks destructive rm -rf / command', async () => {
+    const result = await bashTool.execute({ command: 'rm -rf /' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Destructive')
+    expect(result.error).toContain('destroy')
+  })
+
+  it('blocks destructive format command', async () => {
+    const result = await bashTool.execute({ command: 'format D: /Q' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Destructive')
+    expect(result.error).toContain('destroy')
+  })
+
+  it('clamps timeout to valid range', async () => {
+    // Very large timeout should be clamped, not cause error
+    const result = await bashTool.execute({ command: 'echo ok', timeout: 999999999 })
+    expect(result.success).toBe(true)
+  })
+
+  it('rejects filename-like command (no space before flag)', async () => {
+    // This test verifies that the tool handles edge case input gracefully
+    const result = await bashTool.execute({ command: '--version' })
+    // Should fail with exit code 1, not crash
+    expect(result.success).toBe(false)
+  })
+
+  it('blocks Remove-Item -Recurse -Force command', async () => {
+    const result = await bashTool.execute({ command: 'Remove-Item C:\\Windows -Recurse -Force' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Destructive')
+  })
+
+  it('blocks diskpart clean-all command', async () => {
+    const result = await bashTool.execute({ command: 'diskpart clean-all' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Destructive')
+  })
+
+  it('blocks reg delete command', async () => {
+    const result = await bashTool.execute({ command: 'reg delete HKLM\\Software' })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Destructive')
+  })
+
+  it('rejects cwd with path traversal', async () => {
+    const result = await bashTool.execute({
+      command: 'echo test',
+      cwd: 'C:\\Users\\..\\Windows',
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('path traversal')
+    expect(result.error).toContain('..')
+  })
+
+  it('rejects cwd with path traversal using forward slashes', async () => {
+    const result = await bashTool.execute({
+      command: 'echo test',
+      cwd: '/Users/../etc',
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('path traversal')
+  })
+
+  it('redacts sensitive data from output', async () => {
+    // Test redaction of API key pattern in output
+    const result = await bashTool.execute({
+      command: "Write-Output 'api_key=sk-abc123def456ghi789jkl012mno345pqr678stu'",
+    })
+    expect(result.success).toBe(true)
+    // The API key should be redacted
+    expect(result.output).not.toContain('sk-abc123def456ghi789jkl012mno345pqr678stu')
+    expect(result.output).toContain('[REDACTED]')
+  })
+
+  it('redacts sensitive data from stderr', async () => {
+    const result = await bashTool.execute({
+      command: "Write-Error 'The token ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx is invalid'",
+    })
+    // Should not crash; the redacted marker should appear in the output/error
+    if (!result.success && result.error) {
+      // The token may be split across lines in PowerShell error formatting,
+      // but [REDACTED] should appear at least once
+      expect(result.error).toContain('[REDACTED]')
+    }
+  })
+
+  it('shows platform-specific tip for grep on Windows', async () => {
+    if (os.platform() === 'win32') {
+      const result = await bashTool.execute({ command: 'grep "pattern" file.txt' })
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('findstr')
+    }
+  })
 })

package/src/tools/__tests__/edit.test.ts

@@ -3,16 +3,16 @@ import * as os from 'node:os'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { FileReadTracker } from '../../diff/apply.js'
+import { computeDiff } from '../edit/diff-compute.js'
 import {
-  computeDiff,
-  createEditTool,
   escapeHtml,
-  findAllLinesTolerant,
   generateDiff,
-  normalizeLine,
-  parseMarkdownEdit,
+  generateDiffWithContext,
   renderDiffTerminal,
-} from '../edit.js'
+} from '../edit/diff-render.js'
+import { createEditTool } from '../edit/edit.js'
+import { findAllLinesTolerant, normalizeLine } from '../edit/matcher.js'
+import { parseMarkdownEdit } from '../edit/parser.js'
 import { makeTempDir } from './helpers.js'
 
 // ── Minimal mock for FileReadTracker ─────────────────────────────────────
@@ -119,6 +119,34 @@ describe('findAllLinesTolerant', () => {
     const match = contentSlice('hello \nworld\n', result[0]!)
     expect(match).toBe('hello \nworld')
   })
+
+  it('handles CRLF content - correct position computation', () => {
+    const result = findAllLinesTolerant('hello\r\nworld\r\nfoo\r\n', 'hello\nworld')
+    expect(result).toHaveLength(1)
+    expect(result[0]!.index).toBe(0)
+    // 12 = 'hello\r' (6) + '\n' (1) + 'world' (5, trailing \r excluded)
+    expect(result[0]!.length).toBe(12)
+    const match = contentSlice('hello\r\nworld\r\nfoo\r\n', result[0]!)
+    expect(match).toBe('hello\r\nworld')
+  })
+
+  it('handles mixed CRLF/LF content', () => {
+    const result = findAllLinesTolerant('hello\r\nworld\nfoo\r\n', 'hello\nworld')
+    expect(result).toHaveLength(1)
+    expect(result[0]!.index).toBe(0)
+    expect(result[0]!.length).toBe(12)
+    const match = contentSlice('hello\r\nworld\nfoo\r\n', result[0]!)
+    expect(match).toBe('hello\r\nworld')
+  })
+
+  it('handles CRLF with whitespace normalization', () => {
+    const result = findAllLinesTolerant('hello \r\nworld\r\n', 'hello\nworld')
+    expect(result).toHaveLength(1)
+    // 13 = 'hello \r' (7) + '\n' (1) + 'world' (5, trailing \r excluded)
+    expect(result[0]!.length).toBe(13)
+    const match = contentSlice('hello \r\nworld\r\n', result[0]!)
+    expect(match).toBe('hello \r\nworld')
+  })
 })
 
 function contentSlice(s: string, m: { index: number; length: number }): string {
@@ -207,6 +235,59 @@ describe('generateDiff', () => {
   })
 })
 
+describe('generateDiffWithContext', () => {
+  it('returns context line before match', () => {
+    const output = generateDiffWithContext('keep\nreplace\nkeep', 'replace', 'REPLACE', 5, 7)
+    expect(output).toContain('keep')
+    expect(output).toContain('REPLACE')
+  })
+
+  it('returns no context before when match starts at first line', () => {
+    const output = generateDiffWithContext('line1\nline2', 'line1', 'LINE1', 0, 5)
+    expect(output).toContain('LINE1')
+    const dimCount = (output.match(/\x1b\[38;2;100;100;100m/g) || []).length
+    expect(dimCount).toBe(1)
+  })
+
+  it('returns no context after when match ends at last line', () => {
+    const output = generateDiffWithContext('line1\nline2', 'line2', 'LINE2', 6, 5)
+    expect(output).toContain('LINE2')
+    const dimCount = (output.match(/\x1b\[38;2;100;100;100m/g) || []).length
+    expect(dimCount).toBe(1)
+  })
+
+  it('handles matchIndex at exact end of content (append behavior)', () => {
+    const output = generateDiffWithContext('line1\nline2', '', 'appended', 11, 0)
+    expect(output).toContain('appended')
+    // Should show line 2 context (the last line)
+    expect(output).toContain('line2')
+  })
+
+  it('handles match spanning only the last line with no trailing newline', () => {
+    const output = generateDiffWithContext('first\nlast', 'last', 'LAST', 6, 4)
+    expect(output).toContain('LAST')
+    expect(output).toContain('first')
+    // No context after since match is on the last line
+    const dimCount = (output.match(/\x1b\[38;2;100;100;100m/g) || []).length
+    expect(dimCount).toBe(1)
+  })
+
+  it('handles fullContent with no trailing newline', () => {
+    const output = generateDiffWithContext('line1\nline2\nline3', 'line2', 'LINE2', 6, 5)
+    expect(output).toContain('LINE2')
+    expect(output).toContain('line1')
+    expect(output).toContain('line3')
+  })
+
+  it('handles match on single-line content with no trailing newline', () => {
+    const output = generateDiffWithContext('onlyline', 'onlyline', 'REPLACED', 0, 8)
+    expect(output).toContain('REPLACED')
+    // No context dim lines, only the diff
+    const dimCount = (output.match(/\x1b\[38;2;100;100;100m/g) || []).length
+    expect(dimCount).toBe(0)
+  })
+})
+
 describe('escapeHtml', () => {
   it('escapes ampersands', () => {
     expect(escapeHtml('a&b')).toBe('a&b')
@@ -312,7 +393,7 @@ describe('parseMarkdownEdit', () => {
     const input = '```edit\nfile: a.ts\nold: hello\nnew: world\n```'
     const edits = parseMarkdownEdit(input)
     expect(edits).toHaveLength(1)
-    // Non-pipe format: "old: hello" → content after "old: " includes the leading space
+    // Non-pipe format: "old: hello" �?content after "old: " includes the leading space
     expect(edits[0]!.old_string).toBe(' hello')
     expect(edits[0]!.new_string).toBe(' world')
   })
@@ -357,7 +438,7 @@ describe('parseMarkdownEdit', () => {
   })
 
   it('handles early-``` closing (new: outside the block)', () => {
-    // Model may close ``` before new: — common mistake
+    // Model may close ``` before new: �?common mistake
     const input = [
       '```edit',
       'file: a.ts',
@@ -393,10 +474,51 @@ describe('parseMarkdownEdit', () => {
     expect(edits[0]!.old_string).toBe('  hello')
     expect(edits[0]!.new_string).toBe('  world')
   })
+
+  it('handles old:| then new: (no pipe on new)', () => {
+    const input = '```edit\nfile: a.ts\nold: |\n  hello\nnew:\n  world\n```'
+    const edits = parseMarkdownEdit(input)
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.file_path).toBe('a.ts')
+    expect(edits[0]!.new_string).toBe('  world')
+  })
+
+  it('handles |2 pipe-with-digit syntax', () => {
+    const input = '```edit\nfile: a.ts\nold: |2\n  hello\n  world\nnew: |1\n  hi\n```'
+    const edits = parseMarkdownEdit(input)
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.file_path).toBe('a.ts')
+    expect(edits[0]!.old_string).toBe('  hello\n  world')
+    expect(edits[0]!.new_string).toBe('  hi')
+  })
+
+  it('handles backticks inside edit content', () => {
+    const input = '```edit\nfile: a.ts\nold: |\n  some `code` here\nnew: |\n  replaced `code`\n```'
+    const edits = parseMarkdownEdit(input)
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.file_path).toBe('a.ts')
+    expect(edits[0]!.old_string).toBe('  some `code` here')
+    expect(edits[0]!.new_string).toBe('  replaced `code`')
+  })
+
+  it('handles old_string with trailing whitespace line', () => {
+    const input = '```edit\nfile: a.ts\nold: |\n  hello\n  \nnew: |\n  hi\n```'
+    const edits = parseMarkdownEdit(input)
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.old_string).toBe('  hello\n  ')
+  })
+
+  it('handles new_string with empty content (deletion)', () => {
+    const input = '```edit\nfile: a.ts\nold: |\n  remove me\nnew:\n```'
+    const edits = parseMarkdownEdit(input)
+    expect(edits).toHaveLength(1)
+    expect(edits[0]!.old_string).toBe('  remove me')
+    expect(edits[0]!.new_string).toBe('')
+  })
 })
 
 // ── Markdown format integration tests ────────────────────────────────────
-describe('edit tool — markdown format', () => {
+describe('edit tool �?markdown format', () => {
   let tmpDir: string
   let applier: FileReadTracker
 
@@ -491,7 +613,7 @@ describe('edit tool — markdown format', () => {
 })
 
 // ── Advanced edge cases ──────────────────────────────────────────────────
-describe('edit tool — edge cases', () => {
+describe('edit tool �?edge cases', () => {
   let tmpDir: string
   let applier: FileReadTracker
 
@@ -610,6 +732,39 @@ describe('edit tool — edge cases', () => {
       expect(r.success).toBe(true)
       expect(fs.readFileSync(file, 'utf8')).toBe('brand new content\n')
     })
+    it('rejects empty old_string on existing non-empty file', async () => {
+      const file = path.join(tmpDir, 'empty-old-on-existing.txt')
+      fs.writeFileSync(file, 'some content\n')
+      applier.markRead(file)
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'empty-old-on-existing.txt',
+            old_string: '',
+            new_string: 'should not replace',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('already exists')
+    })
+
+    it('rejects create file when file already exists with empty content', async () => {
+      const file = path.join(tmpDir, 'empty-existing-file.txt')
+      fs.writeFileSync(file, '')
+      applier.markRead(file)
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'empty-existing-file.txt',
+            old_string: '',
+            new_string: 'add content',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('already exists')
+    })
   })
 
   describe('file path edge cases', () => {
@@ -644,8 +799,117 @@ describe('edit tool — edge cases', () => {
         fs.readFileSync(path.join(tmpDir, 'file-with-dashes_and_underscores.txt'), 'utf8'),
       ).toBe('special path')
     })
+
+    it('rejects path traversal with Windows drive letter', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'C:\\Windows\\system32\\drivers\\etc\\hosts',
+            old_string: '',
+            new_string: 'should not write',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+    })
   })
 
+  describe('path traversal security', () => {
+    it('rejects path traversal with ../', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: '../../outside-cwd.txt',
+            old_string: 'hello',
+            new_string: 'world',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+    })
+
+    it('rejects path traversal with deep nested ../', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'subdir/../../../outside-cwd.txt',
+            old_string: '',
+            new_string: 'should not create',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+    })
+
+    it('rejects absolute path', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: '/etc/passwd',
+            old_string: '',
+            new_string: 'should not write',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+    })
+
+    it('allows normal paths inside cwd', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'safe-file.txt',
+            old_string: '',
+            new_string: 'safe content',
+          },
+        ],
+      })
+      expect(r.success).toBe(true)
+    })
+
+    it('rejects path traversal via markdown format', async () => {
+      const input = '```edit\nfile: ../../escape.txt\nold:\nnew: |\n  hacked\n```'
+      const r = await tool().execute({ content: input })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+    })
+
+    it('rejects path traversal via symlink (if supported)', async () => {
+      let canSymlink = false
+      const externalDir = path.join(os.tmpdir(), 'lonny-symlink-target-' + Date.now())
+      const symLink = path.join(tmpDir, 'symlink-inside')
+      try {
+        fs.mkdirSync(externalDir, { recursive: true })
+        fs.writeFileSync(path.join(externalDir, 'malicious.txt'), 'evil')
+        fs.symlinkSync(externalDir, symLink, 'junction')
+        canSymlink = fs.existsSync(symLink)
+      } catch {
+        canSymlink = false
+      }
+      if (!canSymlink) return
+
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'symlink-inside/malicious.txt',
+            old_string: 'evil',
+            new_string: 'hacked',
+          },
+        ],
+      })
+      expect(r.success).toBe(false)
+      expect(r.error).toContain('traversal')
+
+      // Cleanup
+      try {
+        fs.rmSync(externalDir, { recursive: true, force: true })
+      } catch {}
+    })
+  })
   describe('error message quality', () => {
     it('includes proximity hint when old_string not found', async () => {
       const file = path.join(tmpDir, 'proximity.txt')
@@ -687,7 +951,7 @@ describe('edit tool — edge cases', () => {
     })
 
     it('includes read warning when file not read first', async () => {
-      // Don't call markRead — simulate stale content
+      // Don't call markRead �?simulate stale content
       const file = path.join(tmpDir, 'no-read.txt')
       fs.writeFileSync(file, 'content\n')
       const r = await tool().execute({

package/src/tools/__tests__/fetch.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { fetchTool } from '../fetch.js'
+import { fetchTool } from '../web/fetch.js'
 
 describe('fetch tool', () => {
   it('rejects missing url', async () => {

package/src/tools/__tests__/glob.test.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { globTool } from '../glob.js'
+import { globTool } from '../codebase/glob.js'
 import { makeTempDir } from './helpers.js'
 
 describe('glob tool', () => {

package/src/tools/__tests__/grep.test.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { createGrepTool } from '../grep.js'
+import { createGrepTool } from '../codebase/grep.js'
 import { makeTempDir } from './helpers.js'
 
 describe('grep tool', () => {

package/src/tools/__tests__/ls.test.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { createLsTool } from '../ls.js'
+import { createLsTool } from '../codebase/ls.js'
 import { makeTempDir } from './helpers.js'
 
 describe('ls tool', () => {

package/src/tools/__tests__/read.test.ts

@@ -2,7 +2,7 @@ import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { FileReadTracker } from '../../diff/apply.js'
-import { createReadTool } from '../read.js'
+import { createReadTool } from '../codebase/read.js'
 import { makeTempDir } from './helpers.js'
 
 describe('read tool', () => {