lonny-agent 0.2.4 → 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/registry.ts

@@ -2,7 +2,6 @@ import type { FileReadTracker } from '../diff/apply.js'
 import { bashTool } from './bash.js'
 import { createEditTool } from './edit.js'
 import { fmtErr } from './errors.js'
-import { createExecTool, updateExecToolDefinition } from './exec.js'
 import { fetchTool } from './fetch.js'
 import { createFindTool } from './find.js'
 import { createGitTool } from './git.js'
@@ -50,9 +49,6 @@ function normalizeToolInput(
     if (toolName === 'write_plan') {
       return { filename: input, content: input }
     }
-    if (toolName === 'exec') {
-      return { code: input }
-    }
     // For tools that take a single string param, guess from the definition
     const params = Object.keys(_definition.parameters)
     if (params.length === 1) {
@@ -97,8 +93,6 @@ export class ToolRegistry {
   private tools: Map<string, Tool> = new Map()
   private context: ToolContext
   private plugins: Map<string, ToolPlugin> = new Map()
-  /** Reference to the exec tool for dynamic description updates */
-  private execTool: Tool | null = null
 
   constructor(context: ToolContext) {
     this.context = context
@@ -107,7 +101,7 @@ export class ToolRegistry {
 
   /** Register all built-in tools */
   private registerBuiltins(): void {
-    // ask mode: only fetch and search + exec (exec works with any toolset)
+    // ask mode: only fetch and search
     if (this.context.mode === 'ask') {
       this.register(fetchTool)
       this.register(searchTool)
@@ -128,27 +122,12 @@ export class ToolRegistry {
       this.register(createGitTool(this.context.cwd))
       this.register(createInstallSkillTool(this.context.cwd))
       this.register(createEditTool(this.context.applier, this.context.cwd))
-      this.registerExecTool()
     } else {
       // Plan mode: read-only investigation + write_plan
       this.register(createWritePlanTool(this.context.cwd, this.context.onPlanWritten))
     }
   }
 
-  /** Register the exec tool with dynamic type declarations for all registered tools */
-  private registerExecTool(): void {
-    const execTool = createExecTool(() => Array.from(this.tools.values()))
-    this.execTool = execTool
-    this.register(execTool)
-  }
-
-  /** Refresh the exec tool's description to include current tool type declarations */
-  private refreshExecDescription(): void {
-    if (this.execTool) {
-      updateExecToolDefinition(this.execTool, this.getDefinitions())
-    }
-  }
-
   setMode(mode: 'code' | 'plan' | 'ask'): void {
     // Update context.mode FIRST so registerBuiltins() and mode-based logic
     // use the NEW mode, not the stale one (fixes bug when switching from
@@ -158,20 +137,16 @@ export class ToolRegistry {
     if (mode === 'code') {
       // Re-register all built-in tools for code mode
       this.tools.clear()
-      this.execTool = null
       this.registerBuiltins()
     } else if (mode === 'plan') {
-      // Keep existing tools but swap edit/write_plan, remove exec
+      // Keep existing tools but swap edit/write_plan
       if (!this.tools.has('write_plan')) {
         this.register(createWritePlanTool(this.context.cwd, this.context.onPlanWritten))
       }
       this.tools.delete('edit')
-      this.tools.delete('exec')
-      this.execTool = null
     } else if (mode === 'ask') {
       // Ask mode: only fetch and search
       this.tools.clear()
-      this.execTool = null
       this.register(fetchTool)
       this.register(searchTool)
     }
@@ -180,10 +155,6 @@ export class ToolRegistry {
   /** Register a single tool */
   register(tool: Tool): void {
     this.tools.set(tool.definition.name, tool)
-    // Refresh exec tool description to include the new tool's type declarations
-    if (this.execTool && tool.definition.name !== 'exec') {
-      this.refreshExecDescription()
-    }
   }
 
   /** Register a tool plugin (lazy creation pattern) */