lonny-agent 0.2.3 → 0.2.6

package/src/tools/git.ts

@@ -1,76 +1,76 @@
-import { execSync } from 'node:child_process'
-import type { Tool, ToolDefinition } from './types.js'
-
-export const createGitTool = (cwd: string): Tool => {
-  const definition: ToolDefinition = {
-    name: 'git',
-    description:
-      'Run git commands for repository operations. Supports status, diff, log, show, branch, and other read-only git operations.',
-    parameters: {
-      command: {
-        type: 'string',
-        description: 'Git subcommand and arguments (e.g. "status", "diff", "log --oneline -5")',
-        required: true,
-      },
-      path: { type: 'string', description: 'Repository path (default: cwd)', required: false },
-    },
-  }
-
-  const execute = async (
-    input: Record<string, unknown>,
-  ): Promise<{ success: boolean; output: string; error?: string }> => {
-    const gitCmd = String(input.command || '').trim()
-    const repoPath = String(input.path || cwd)
-
-    if (!gitCmd) {
-      return { success: false, output: '', error: 'command is required' }
-    }
-
-    // Safety: block destructive commands
-    const destructivePatterns = [
-      /^reset\s+(--hard|--soft|--mixed|--merge|--keep)/i,
-      /^push\s+.*(--force|-f)/i,
-      /^(rebase|merge|cherry-pick|revert)\b/i,
-      /^branch\s+-[dD]/i,
-      /^tag\s+-[dD]/i,
-      /^(clean|gc|prune)\b/i,
-      /^update-ref\b/i,
-      /^rm\b/i,
-      /^commit\s+--amend/i,
-      /^checkout\s+.*-B/i,
-    ]
-
-    for (const pattern of destructivePatterns) {
-      if (pattern.test(gitCmd)) {
-        return {
-          success: false,
-          output: '',
-          error: `Destructive git command not allowed: "${gitCmd}". Only read-only operations are permitted.`,
-        }
-      }
-    }
-
-    try {
-      const result = execSync(`git ${gitCmd}`, {
-        cwd: repoPath,
-        encoding: 'utf-8',
-        timeout: 30000,
-        maxBuffer: 10 * 1024 * 1024, // 10MB
-      })
-
-      return { success: true, output: result.trim() || '(empty output)' }
-    } catch (err) {
-      const error = err as { stderr?: string; stdout?: string; message?: string }
-      const stderr = error.stderr || ''
-      const stdout = error.stdout || ''
-      const msg = error.message || String(err)
-      return {
-        success: false,
-        output: stdout.trim(),
-        error: stderr.trim() || msg,
-      }
-    }
-  }
-
-  return { definition, execute }
-}
+import { execSync } from 'node:child_process'
+import type { Tool, ToolDefinition } from './types.js'
+
+export const createGitTool = (cwd: string): Tool => {
+  const definition: ToolDefinition = {
+    name: 'git',
+    description:
+      'Run git commands for repository operations. Supports status, diff, log, show, branch, and other read-only git operations.',
+    parameters: {
+      command: {
+        type: 'string',
+        description: 'Git subcommand and arguments (e.g. "status", "diff", "log --oneline -5")',
+        required: true,
+      },
+      path: { type: 'string', description: 'Repository path (default: cwd)', required: false },
+    },
+  }
+
+  const execute = async (
+    input: Record<string, unknown>,
+  ): Promise<{ success: boolean; output: string; error?: string }> => {
+    const gitCmd = String(input.command || '').trim()
+    const repoPath = String(input.path || cwd)
+
+    if (!gitCmd) {
+      return { success: false, output: '', error: 'command is required' }
+    }
+
+    // Safety: block destructive commands
+    const destructivePatterns = [
+      /^reset\s+(--hard|--soft|--mixed|--merge|--keep)/i,
+      /^push\s+.*(--force|-f)/i,
+      /^(rebase|merge|cherry-pick|revert)\b/i,
+      /^branch\s+-[dD]/i,
+      /^tag\s+-[dD]/i,
+      /^(clean|gc|prune)\b/i,
+      /^update-ref\b/i,
+      /^rm\b/i,
+      /^commit\s+--amend/i,
+      /^checkout\s+.*-B/i,
+    ]
+
+    for (const pattern of destructivePatterns) {
+      if (pattern.test(gitCmd)) {
+        return {
+          success: false,
+          output: '',
+          error: `Destructive git command not allowed: "${gitCmd}". Only read-only operations are permitted.`,
+        }
+      }
+    }
+
+    try {
+      const result = execSync(`git ${gitCmd}`, {
+        cwd: repoPath,
+        encoding: 'utf-8',
+        timeout: 30000,
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      })
+
+      return { success: true, output: result.trim() || '(empty output)' }
+    } catch (err) {
+      const error = err as { stderr?: string; stdout?: string; message?: string }
+      const stderr = error.stderr || ''
+      const stdout = error.stdout || ''
+      const msg = error.message || String(err)
+      return {
+        success: false,
+        output: stdout.trim(),
+        error: stderr.trim() || msg,
+      }
+    }
+  }
+
+  return { definition, execute }
+}

package/src/tools/grep.ts

@@ -1,16 +1,20 @@
-import { execSync } from 'node:child_process'
+import { execFileSync } from 'node:child_process'
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
+let _hasRg: boolean | undefined
+
 function hasRg(): boolean {
+  if (_hasRg !== undefined) return _hasRg
   try {
-    execSync('rg --version', { stdio: 'pipe' })
-    return true
+    execFileSync('rg', ['--version'], { stdio: 'pipe' })
+    _hasRg = true
   } catch {
-    return false
+    _hasRg = false
   }
+  return _hasRg
 }
 
 /** Simple glob-to-regex for the `include` parameter (e.g. "*.ts", "*.{ts,tsx}"). */
@@ -25,9 +29,11 @@ function includeRe(include: string): RegExp {
       continue
     }
     if (ch === '*') {
+      // Handle ** (match across dirs) and * (match within a single dir segment)
       if (include[i + 1] === '*') {
         re += '.*'
-        i += 2
+        // Skip all consecutive asterisks so `***` doesn't leave a trailing literal `*`
+        while (i < include.length && include[i] === '*') i++
         continue
       }
       re += '[^/]*'
@@ -48,6 +54,12 @@ function includeRe(include: string): RegExp {
       i++
       continue
     }
+    // Escape special regex characters (except those we handle above)
+    if (/[.+^${}()|[\]\\]/.test(ch)) {
+      re += '\\' + ch
+      i++
+      continue
+    }
     re += ch
     i++
   }
@@ -64,32 +76,38 @@ async function nodeGrep(dir: string, re: RegExp, incRe: RegExp | null): Promise<
   const results: NodeGrepMatch[] = []
   try {
     const entries = await fs.readdir(dir, { withFileTypes: true })
-    const subResults: Promise<NodeGrepMatch[]>[] = []
+    const promises: Promise<void>[] = []
+
     for (const e of entries) {
       const full = path.join(dir, e.name)
       if (e.isDirectory()) {
         if (e.name === '.git' || e.name === 'node_modules') continue
-        subResults.push(nodeGrep(full, re, incRe))
+        promises.push(
+          nodeGrep(full, re, incRe).then(sub => {
+            for (const m of sub) results.push(m)
+          }),
+        )
       } else if (e.isFile()) {
         if (incRe && !incRe.test(e.name)) continue
-        try {
-          const content = await fs.readFile(full, 'utf-8')
-          const lines = content.split('\n')
-          for (let i = 0; i < lines.length; i++) {
-            if (re.test(lines[i])) {
-              results.push({ file: full, line: i + 1, text: lines[i] })
+        promises.push(
+          (async () => {
+            try {
+              const content = await fs.readFile(full, 'utf-8')
+              const lines = content.split('\n')
+              for (let i = 0; i < lines.length; i++) {
+                if (re.test(lines[i])) {
+                  results.push({ file: full, line: i + 1, text: lines[i] })
+                }
+              }
+            } catch {
+              /* permission denied etc */
             }
-          }
-        } catch {
-          /* permission denied etc */
-        }
+          })(),
+        )
       }
     }
-    // Await all subdirectory results concurrently
-    const subMatches = await Promise.all(subResults)
-    for (const sm of subMatches) {
-      results.push(...sm)
-    }
+
+    await Promise.all(promises)
   } catch {
     /* permission denied etc */
   }
@@ -120,11 +138,23 @@ export function createGrepTool(cwd: string): Tool {
 
       try {
         if (useRg) {
-          let cmd = `rg -n "${pattern.replace(/"/g, '\\"')}"`
-          if (include) cmd += ` -g "${include}"`
-          cmd += ` "${searchPath}"`
-          const output = execSync(cmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] })
-          return { success: true, output: output || 'No matches found.' }
+          const args = ['-n', '--no-heading', pattern]
+          if (include) args.push('-g', include)
+          args.push(searchPath)
+          try {
+            const output = execFileSync('rg', args, {
+              encoding: 'utf-8',
+              stdio: ['pipe', 'pipe', 'pipe'],
+            })
+            return { success: true, output: output || 'No matches found.' }
+          } catch (rgErr: unknown) {
+            const rgMsg = fmtErr(rgErr)
+            // ripgrep exit code 1 = no matches, exit code 2 = error
+            if (rgMsg.includes('exit code 1')) {
+              return { success: true, output: 'No matches found.' }
+            }
+            throw rgErr
+          }
         }
 
         const re = new RegExp(pattern)
@@ -141,9 +171,6 @@ export function createGrepTool(cwd: string): Tool {
         return { success: true, output }
       } catch (err) {
         const msg = fmtErr(err)
-        if (useRg && msg.includes('exit code 1')) {
-          return { success: true, output: 'No matches found.' }
-        }
         return { success: false, output: '', error: `Grep failed: ${msg}` }
       }
     },

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') }
     },