lonny-agent 0.2.2 → 0.2.4

package/src/tools/edit.ts

@@ -4,22 +4,101 @@ import type { FileReadTracker } from '../diff/apply.js'
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
-// ── ANSI colors for diff output ─────────────────────────────────────────
+// ── Diff types ────────────────────────────────────────────────────────────
+export type DiffLineType = 'old' | 'new'
+
+export interface DiffLine {
+  lineNum: number
+  type: DiffLineType
+  content: string
+}
+
+// ── ANSI colors for terminal output ───────────────────────────────────────
 const DIFF_RED = '\x1b[38;2;255;80;80m'
 const DIFF_GREEN = '\x1b[38;2;0;200;100m'
 const DIFF_RESET = '\x1b[0m'
 
-function generateDiff(oldStr: string, newStr: string): string {
+// ── ANSI colors for HTML output ───────────────────────────────────────────
+const HTML_RED = '#ff5050'
+const HTML_GREEN = '#00c864'
+
+/** Build diagnostic JSON for error messages */
+function buildDiag(edit: SingleEdit): string {
+  return JSON.stringify({
+    file_path: edit.file_path,
+    old_string: edit.old_string,
+    new_string: edit.new_string,
+  })
+}
+
+/** Compute diff lines (pure data, no rendering) */
+export function computeDiff(oldStr: string, newStr: string, startLine = 0): DiffLine[] {
   const oldLines = oldStr === '' ? [] : oldStr.split('\n')
   const newLines = newStr.split('\n')
-  const lines: string[] = []
-  for (const line of oldLines) {
-    lines.push(`  ${DIFF_RED}- ${line}${DIFF_RESET}`)
+  const lines: DiffLine[] = []
+
+  for (let i = 0; i < oldLines.length; i++) {
+    lines.push({ lineNum: startLine + i, type: 'old', content: oldLines[i] })
+  }
+  for (let i = 0; i < newLines.length; i++) {
+    lines.push({ lineNum: startLine + i, type: 'new', content: newLines[i] })
+  }
+
+  return lines
+}
+
+/** Terminal renderer */
+export function renderDiffTerminal(lines: DiffLine[]): string {
+  if (lines.length === 0) return ''
+
+  const maxLineNum = Math.max(...lines.map(l => l.lineNum))
+  const lineNumWidth = String(maxLineNum).length
+  const fmtLineNum = (n: number) => String(n).padStart(lineNumWidth, ' ')
+
+  const output: string[] = []
+  for (const line of lines) {
+    const color = line.type === 'old' ? DIFF_RED : DIFF_GREEN
+    const reset = DIFF_RESET
+    output.push(`  ${fmtLineNum(line.lineNum)} ${color}${line.content}${reset}`)
   }
-  for (const line of newLines) {
-    lines.push(`  ${DIFF_GREEN}+ ${line}${DIFF_RESET}`)
+  return output.join('\n')
+}
+
+/** HTML renderer for web output */
+export function renderDiffHtml(lines: DiffLine[]): string {
+  if (lines.length === 0) return ''
+
+  const maxLineNum = Math.max(...lines.map(l => l.lineNum))
+  const lineNumWidth = String(maxLineNum).length
+  const fmtLineNum = (n: number) => String(n).padStart(lineNumWidth, ' ')
+
+  const output: string[] = []
+  for (const line of lines) {
+    const color = line.type === 'old' ? HTML_RED : HTML_GREEN
+    const style = `color: ${color};`
+    output.push(
+      `  <span style="${style}">${fmtLineNum(line.lineNum)} ${escapeHtml(line.content)}</span>`,
+    )
   }
-  return lines.join('\n')
+  return output.join('\n')
+}
+
+/** Escape HTML special characters */
+function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+}
+
+/**
+ * Generate diff output (backward compatible).
+ * Delegates to terminal renderer by default.
+ */
+export function generateDiff(oldStr: string, newStr: string, startLine = 0): string {
+  const lines = computeDiff(oldStr, newStr, startLine)
+  return renderDiffTerminal(lines)
 }
 
 /**
@@ -128,6 +207,7 @@ EXAMPLES:
       parameters: {
         edits: {
           type: 'array',
+          minItems: 1,
           description:
             'REQUIRED. Array of complete find-replace pairs. Each edit MUST have BOTH old_string AND new_string. Example: [{ file_path: "src/file.ts", old_string: "old", new_string: "new" }]',
           required: true,
@@ -153,7 +233,13 @@ EXAMPLES:
     async execute(input): Promise<ToolResult> {
       // ── Auto-correction: detect common misuse patterns ────────────────
       // ── Debug: log raw input for diagnosing failures ─────────────
-      const rawInput = JSON.parse(JSON.stringify(input))
+      let rawInput: unknown = input
+      try {
+        rawInput = structuredClone(input)
+      } catch {
+        console.error('[edit] Failed to clone input:', input)
+        rawInput = input
+      }
 
       // Pattern 0: input is an array (edits passed directly instead of wrapped)
       if (Array.isArray(input)) {
@@ -215,7 +301,7 @@ EXAMPLES:
       const edits = input.edits as SingleEdit[]
       if (edits.length === 0) {
         // Build a diagnostic: show what the AI received vs expected
-        const receivedKeys = Object.keys(rawInput)
+        const receivedKeys = Object.keys(rawInput as Record<string, unknown>)
         const hint =
           receivedKeys.length === 1 && receivedKeys[0] === 'edits'
             ? 'The edits array exists but is empty — include at least one edit object with file_path, old_string, and new_string.'
@@ -288,11 +374,7 @@ Do NOT split old_string (text to find) and new_string (replacement) across diffe
 
           if (e.old_string === '') {
             if (content !== null) {
-              const diag = JSON.stringify({
-                file_path: e.file_path,
-                old_string: '',
-                new_string: e.new_string,
-              })
+              const diag = buildDiag({ ...e, old_string: '' })
               const suggestion = `  → Use edit with old_string to replace existing content, or choose a different path.`
               results.push(`  FAIL ${relPath}: File already exists — Raw input: ${JSON.stringify(rawInput)}
   Edit: ${diag}
@@ -312,11 +394,7 @@ ${suggestion}`)
           }
 
           if (content === null) {
-            const diag = JSON.stringify({
-              file_path: e.file_path,
-              old_string: e.old_string,
-              new_string: e.new_string,
-            })
+            const diag = buildDiag(e)
             const suggestion = `  → Check the file path, or create it first with old_string: "" (empty string).`
             results.push(`  FAIL ${relPath}: File not found — Raw input: ${JSON.stringify(rawInput)}
   Edit: ${diag}
@@ -338,11 +416,7 @@ ${suggestion}`)
             // Exact match found — check for duplicates
             const lastIdx = content.lastIndexOf(e.old_string)
             if (exactIdx !== lastIdx) {
-              const diag = JSON.stringify({
-                file_path: e.file_path,
-                old_string: e.old_string,
-                new_string: e.new_string,
-              })
+              const diag = buildDiag(e)
               const suggestion = `  → Include more surrounding context lines (2-3 lines before and after) in old_string to make the match unique.`
               results.push(`  FAIL ${relPath}: old_string appears MULTIPLE times — Raw input: ${JSON.stringify(rawInput)}
   Edit: ${diag}
@@ -380,11 +454,7 @@ ${suggestion}`)
                 const lines = contentLines.slice(0, Math.min(contentLines.length, 5))
                 hint = `\n  File content (first ${lines.length} lines):\n  """\n${lines.join('\n')}\n  """`
               }
-              const diag = JSON.stringify({
-                file_path: e.file_path,
-                old_string: e.old_string,
-                new_string: e.new_string,
-              })
+              const diag = buildDiag(e)
               const readHint = readWarning ? `\n  ${readWarning}` : ''
               const suggestion = `  → Read the file again with read({ paths: ["${e.file_path}"] }) to get current content, then retry with exact matching text. Include 2-3 lines of surrounding context for uniqueness.${readHint}`
               results.push(`  FAIL ${relPath}: old_string not found — Raw input: ${JSON.stringify(rawInput)}
@@ -397,11 +467,7 @@ ${suggestion}`)
               break
             }
             if (tolerant.length > 1) {
-              const diag = JSON.stringify({
-                file_path: e.file_path,
-                old_string: e.old_string,
-                new_string: e.new_string,
-              })
+              const diag = buildDiag(e)
               const suggestion = `  → Include more surrounding context lines (2-3 lines before and after) in old_string to make the match unique.`
               results.push(
                 `  FAIL ${relPath}: old_string appears MULTIPLE times (whitespace-normalized) — Raw input: ${JSON.stringify(rawInput)}\n  Edit: ${diag}\n${suggestion}`,
@@ -420,7 +486,8 @@ ${suggestion}`)
           }
 
           const strategyLabel = matchInfo.strategy === 'tolerant' ? ' (whitespace-normalized)' : ''
-          const diff = generateDiff(e.old_string, e.new_string)
+          const matchLineNum = content.substring(0, matchInfo.index).split('\n').length
+          const diff = generateDiff(e.old_string, e.new_string, matchLineNum - 1)
           results.push(`  Edited ${relPath}${strategyLabel}:\n${diff}`)
           content =
             content.slice(0, matchInfo.index) +

package/src/tools/read.ts

@@ -4,14 +4,23 @@ import type { FileReadTracker } from '../diff/apply.js'
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
-function formatWithLineNumbers(content: string): string {
+// ── Configuration ─────────────────────────────────────────────────────────
+const MAX_FILE_SIZE = 1_000_000 // 1MB
+const DEFAULT_MAX_LINES = 500 // Default pagination limit
+
+/**
+ * Format content with line numbers.
+ * Handles trailing newline correctly.
+ * Exported for testing and reuse.
+ */
+export function formatWithLineNumbers(content: string, startLine = 1): string {
   const lines = content.split('\n')
   // Drop trailing empty element produced by a final \n so the displayed
   // line count matches the actual line count of the file.
   const hasTrailingNewline = lines.length > 0 && lines[lines.length - 1] === ''
   const body = hasTrailingNewline ? lines.slice(0, -1) : lines
-  const pad = String(body.length).length
-  return body.map((l, i) => `${String(i + 1).padStart(pad, ' ')}: ${l}`).join('\n')
+  const pad = String(startLine + body.length - 1).length
+  return body.map((l, i) => `${String(startLine + i).padStart(pad, ' ')}: ${l}`).join('\n')
 }
 
 export function createReadTool(applier: FileReadTracker, cwd: string): Tool {
@@ -19,9 +28,15 @@ export function createReadTool(applier: FileReadTracker, cwd: string): Tool {
     definition: {
       name: 'read',
       description:
-        'Read the contents of one or more files. Always read a file before editing it. Each line is prefixed with "<lineNumber>: " for accurate line references; the prefix is a display aid only — do NOT include it in batch_edit patch content.',
+        'Read the contents of one or more files. Always read a file before editing it. Each line is prefixed with "<lineNumber>: " for accurate line references; the prefix is a display aid only — do NOT include it in batch_edit patch content. Supports pagination via startLine and maxLines for large files.',
       parameters: {
         paths: { type: 'array', description: 'File paths to read', required: true },
+        startLine: { type: 'number', description: 'Start line number (1-based)', required: false },
+        maxLines: {
+          type: 'number',
+          description: 'Maximum number of lines to read',
+          required: false,
+        },
       },
     },
     async execute(input): Promise<ToolResult> {
@@ -30,28 +45,49 @@ export function createReadTool(applier: FileReadTracker, cwd: string): Tool {
         return { success: false, output: '', error: 'paths must be a non-empty array' }
       }
 
-      const results: string[] = []
-      for (const filePath of paths) {
-        try {
-          const resolved = path.resolve(cwd, filePath)
-          const stat = await fs.stat(resolved)
-          if (!stat.isFile()) {
-            results.push(`=== ${filePath} ===\n(error: not a file)`)
-            continue
-          }
-          if (stat.size > 1_000_000) {
-            results.push(
-              `=== ${filePath} ===\n(error: file too large (>1MB), use bash to read it selectively)`,
-            )
-            continue
+      const startLine = typeof input.startLine === 'number' ? Math.max(1, input.startLine) : 1
+      const maxLines =
+        typeof input.maxLines === 'number' ? Math.max(1, input.maxLines) : DEFAULT_MAX_LINES
+
+      // Read files in parallel
+      const results = await Promise.all(
+        paths.map(async (filePath): Promise<string> => {
+          try {
+            const resolved = path.resolve(cwd, filePath)
+            const stat = await fs.stat(resolved)
+            if (!stat.isFile()) {
+              return `=== ${filePath} ===\n(error: not a file)`
+            }
+            if (stat.size > MAX_FILE_SIZE) {
+              return `=== ${filePath} ===\n(error: file too large (>1MB), use bash to read it selectively)`
+            }
+            let content = await fs.readFile(resolved, 'utf-8')
+
+            // Handle pagination
+            const allLines = content.split('\n')
+            const hasTrailingNewline = allLines.length > 0 && allLines[allLines.length - 1] === ''
+            const totalLines = hasTrailingNewline ? allLines.length - 1 : allLines.length
+
+            if (startLine > totalLines) {
+              return `=== ${filePath} ===\n(error: startLine ${startLine} exceeds file length ${totalLines})`
+            }
+
+            const endLine = Math.min(startLine + maxLines - 1, totalLines)
+            const selectedLines = allLines.slice(startLine - 1, endLine)
+            content = selectedLines.join('\n') + (hasTrailingNewline ? '\n' : '')
+
+            const displayStart = startLine
+            const displayEnd = endLine
+            const truncated =
+              endLine < totalLines ? ` (lines ${displayStart}-${displayEnd} of ${totalLines})` : ''
+
+            applier.markRead(resolved)
+            return `=== ${filePath} ===${truncated}\n${formatWithLineNumbers(content, startLine)}`
+          } catch (err) {
+            return `=== ${filePath} ===\n(error: ${fmtErr(err)})`
           }
-          const content = await fs.readFile(resolved, 'utf-8')
-          applier.markRead(resolved)
-          results.push(`=== ${filePath} ===\n${formatWithLineNumbers(content)}`)
-        } catch (err) {
-          results.push(`=== ${filePath} ===\n(error: ${fmtErr(err)})`)
-        }
-      }
+        }),
+      )
 
       return { success: true, output: results.join('\n\n') }
     },