lonny-agent 0.2.4 → 0.2.7

package/src/tools/{grep.ts → codebase/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'
+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 */
   }
@@ -102,6 +120,8 @@ export function createGrepTool(cwd: string): Tool {
   return {
     definition: {
       name: 'grep',
+      category: 'Codebase',
+      group: 'Search/By Content',
       description: 'Search file contents using a regular expression. Supports full regex syntax.',
       parameters: {
         pattern: { type: 'string', description: 'Regex pattern to search for', required: true },
@@ -120,11 +140,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 +173,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/{ls.ts → codebase/ls.ts}

@@ -1,12 +1,14 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import { fmtErr } from './errors.js'
-import type { Tool, ToolResult } from './types.js'
+import { fmtErr } from '../errors.js'
+import type { Tool, ToolResult } from '../types.js'
 
 export function createLsTool(cwd: string): Tool {
   return {
     definition: {
       name: 'ls',
+      category: 'Codebase',
+      group: 'List',
       description: 'List files and directories at a given path.',
       parameters: {
         path: { type: 'string', description: 'Directory path to list (default: cwd)' },

package/src/tools/{read.ts → codebase/read.ts}

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs/promises'
 import * as path from 'node:path'
-import type { FileReadTracker } from '../diff/apply.js'
-import { fmtErr } from './errors.js'
-import type { Tool, ToolResult } from './types.js'
+import type { FileReadTracker } from '../../diff/apply.js'
+import { fmtErr } from '../errors.js'
+import type { Tool, ToolResult } from '../types.js'
 
 // ── Configuration ─────────────────────────────────────────────────────────
 const MAX_FILE_SIZE = 1_000_000 // 1MB
@@ -27,6 +27,8 @@ export function createReadTool(applier: FileReadTracker, cwd: string): Tool {
   return {
     definition: {
       name: 'read',
+      category: 'Codebase',
+      group: '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. Supports pagination via startLine and maxLines for large files.',
       parameters: {

package/src/tools/edit/diff-compute.ts

@@ -0,0 +1,21 @@
+import { DIFF_DELETE, DIFF_INSERT, diffLinesRaw } from 'jest-diff'
+import type { DiffLine } from './types.js'
+
+/** Compute diff lines using jest-diff for proper line-level diffs */
+export function computeDiff(oldStr: string, newStr: string): DiffLine[] {
+  const oldLines = oldStr === '' ? [] : oldStr.split('\n')
+  const newLines = newStr === '' ? [] : newStr.split('\n')
+
+  if (oldLines.length === 0 && newLines.length === 0) return []
+
+  const rawDiff = diffLinesRaw(oldLines, newLines)
+  return rawDiff.map(d => ({
+    type:
+      d[0] === DIFF_DELETE
+        ? ('delete' as const)
+        : d[0] === DIFF_INSERT
+          ? ('insert' as const)
+          : ('equal' as const),
+    content: d[1],
+  }))
+}

package/src/tools/edit/diff-render.ts

@@ -0,0 +1,145 @@
+import { computeDiff } from './diff-compute.js'
+import type { DiffLine } from './types.js'
+
+// ── 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_DIM = '\x1b[38;2;100;100;100m'
+const DIFF_RESET = '\x1b[0m'
+
+// ── Colors for HTML output ────────────────────────────────────────────────
+const HTML_RED = '#ff5050'
+const HTML_GREEN = '#00c864'
+const HTML_DIM = '#888888'
+
+/** Terminal renderer — unified-diff format with color */
+export function renderDiffTerminal(lines: DiffLine[], startLineNum?: number): string {
+  if (lines.length === 0) return ''
+
+  const output: string[] = []
+  let oldLn = startLineNum ?? 1
+  let newLn = startLineNum ?? 1
+  for (const line of lines) {
+    if (line.type === 'delete') {
+      output.push(`  ${DIFF_RED}- ${oldLn}  ${line.content}${DIFF_RESET}`)
+      oldLn++
+    } else if (line.type === 'insert') {
+      output.push(`  ${DIFF_GREEN}+ ${newLn}  ${line.content}${DIFF_RESET}`)
+      newLn++
+    } else {
+      output.push(`  ${DIFF_DIM}  ${oldLn}  ${line.content}${DIFF_RESET}`)
+      oldLn++
+      newLn++
+    }
+  }
+  return output.join('\n')
+}
+
+/** HTML renderer for web output */
+export function renderDiffHtml(lines: DiffLine[]): string {
+  if (lines.length === 0) return ''
+
+  const output: string[] = []
+  for (const line of lines) {
+    if (line.type === 'delete') {
+      output.push(`  <span style="color: ${HTML_RED};">- ${escapeHtml(line.content)}</span>`)
+    } else if (line.type === 'insert') {
+      output.push(`  <span style="color: ${HTML_GREEN};">+ ${escapeHtml(line.content)}</span>`)
+    } else {
+      output.push(`  <span style="color: ${HTML_DIM};">  ${escapeHtml(line.content)}</span>`)
+    }
+  }
+  return output.join('\n')
+}
+
+/** Escape HTML special characters */
+export function escapeHtml(str: string): string {
+  return str
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+}
+
+/**
+ * Generate diff output using jest-diff.
+ * Returns terminal-colored unified-diff format with line numbers.
+ */
+export function generateDiff(oldStr: string, newStr: string, startLineNum?: number): string {
+  const lines = computeDiff(oldStr, newStr)
+  return renderDiffTerminal(lines, startLineNum)
+}
+
+/**
+ * Generate diff with surrounding context lines (1 before, 1 after)
+ * and line numbers. Context lines are extracted from the full file content.
+ */
+export function generateDiffWithContext(
+  fullContent: string,
+  oldStr: string,
+  newStr: string,
+  matchIndex: number,
+  matchLength: number,
+): string {
+  // Calculate 1-based line number of the first matched line
+  const firstLineNum = fullContent.slice(0, matchIndex).split('\n').length
+
+  const contentLines = fullContent.split('\n')
+
+  // Find 0-based line index where matchIndex falls
+  let charPos = 0
+  let matchStartLineIdx = 0
+  for (let i = 0; i < contentLines.length; i++) {
+    if (charPos <= matchIndex && matchIndex < charPos + contentLines[i].length + 1) {
+      matchStartLineIdx = i
+      break
+    }
+    charPos += contentLines[i].length + 1 // +1 for \n
+  }
+
+  // How many lines does oldStr span in the original content?
+  const oldLines = oldStr === '' ? [] : oldStr.split('\n')
+  const oldLineCount = oldLines.length
+  const matchEndLineIdx = matchStartLineIdx + oldLineCount - 1
+
+  // Context before (1 line) and after (1 line)
+  const beforeLineIdx = matchStartLineIdx > 0 ? matchStartLineIdx - 1 : -1
+  const afterLineIdx = matchEndLineIdx < contentLines.length - 1 ? matchEndLineIdx + 1 : -1
+
+  // Compute diff between oldStr and newStr
+  const diffLines = computeDiff(oldStr, newStr)
+
+  const output: string[] = []
+
+  // Context before
+  if (beforeLineIdx !== -1) {
+    const lineNum = beforeLineIdx + 1
+    output.push(`  ${DIFF_DIM}  ${lineNum}  ${contentLines[beforeLineIdx]}${DIFF_RESET}`)
+  }
+
+  // Diff lines with line numbers
+  let oldLn = firstLineNum
+  let newLn = firstLineNum
+  for (const line of diffLines) {
+    if (line.type === 'delete') {
+      output.push(`  ${DIFF_RED}- ${oldLn}  ${line.content}${DIFF_RESET}`)
+      oldLn++
+    } else if (line.type === 'insert') {
+      output.push(`  ${DIFF_GREEN}+ ${newLn}  ${line.content}${DIFF_RESET}`)
+      newLn++
+    } else {
+      output.push(`  ${DIFF_DIM}  ${oldLn}  ${line.content}${DIFF_RESET}`)
+      oldLn++
+      newLn++
+    }
+  }
+
+  // Context after
+  if (afterLineIdx !== -1) {
+    const lineNum = afterLineIdx + 1
+    output.push(`  ${DIFF_DIM}  ${lineNum}  ${contentLines[afterLineIdx]}${DIFF_RESET}`)
+  }
+
+  return output.join('\n')
+}