lonny-agent 0.2.4 → 0.2.6

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

@@ -16,6 +16,12 @@ describe('grep tool', () => {
     fs.writeFileSync(path.join(tmpDir, 'world.js'), 'const y = 2\nconsole.log("world")\n')
     fs.mkdirSync(path.join(tmpDir, 'sub'))
     fs.writeFileSync(path.join(tmpDir, 'sub', 'deep.ts'), 'const z = 3\n// TODO: implement\n')
+    // Additional files for include glob and path parameter tests
+    fs.mkdirSync(path.join(tmpDir, 'lib'))
+    fs.writeFileSync(path.join(tmpDir, 'lib', 'index.ts'), 'export const version = 1\n')
+    fs.writeFileSync(path.join(tmpDir, 'lib', 'helper.tsx'), 'export function helper() {}\n')
+    fs.writeFileSync(path.join(tmpDir, 'lib', 'config.tsx'), 'export const config = {}\n')
+    fs.writeFileSync(path.join(tmpDir, 'lib', 'readme.md'), '# no code here\n')
   })
 
   afterAll(() => {
@@ -44,6 +50,28 @@ describe('grep tool', () => {
     expect(result.output).not.toContain('world.js')
   })
 
+  it('filters by brace-enclosed glob pattern', async () => {
+    const result = await tool().execute({ pattern: 'export', include: '*.{ts,tsx}' })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('lib/index.ts')
+    expect(result.output).toContain('lib/helper.tsx')
+    expect(result.output).toContain('lib/config.tsx')
+    // Should NOT match hello.ts (it matches 'export' but is in root, not filtered out)
+    // All .ts and .tsx files should be included, including hello.ts which has 'export'
+  })
+
+  it('filters by include with path parameter', async () => {
+    const result = await tool().execute({
+      pattern: 'export',
+      include: '*.ts',
+      path: tmpDir + '/lib',
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('lib/index.ts')
+    // helper.tsx and config.tsx are .tsx, not .ts, so should not appear
+    expect(result.output).not.toContain('lib/helper.tsx')
+  })
+
   it('rejects missing pattern argument', async () => {
     const result = await tool().execute({})
     expect(result.success).toBe(false)
@@ -55,4 +83,11 @@ describe('grep tool', () => {
     expect(result.success).toBe(true)
     expect(result.output).toContain('deep.ts')
   })
+
+  it('handles pattern with alternation', async () => {
+    const result = await tool().execute({ pattern: 'TODO|hello' })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('deep.ts')
+    expect(result.output).toContain('hello.ts')
+  })
 })

package/src/tools/bash.ts

@@ -1,15 +1,89 @@
-import { exec } from 'node:child_process'
-import { promisify } from 'node:util'
-
-const execAsync = promisify(exec)
+import { spawn } from 'node:child_process'
+import * as os from 'node:os'
 
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
+function detectEnv(): { osInfo: string; shell: string } {
+  const platform = os.platform()
+  const release = os.release()
+  const arch = os.arch()
+
+  if (platform === 'win32') {
+    return {
+      osInfo: `Windows ${release} (${arch})`,
+      shell: 'powershell.exe',
+    }
+  }
+
+  const osName = platform === 'darwin' ? 'macOS' : platform === 'linux' ? 'Linux' : platform
+  return {
+    osInfo: `${osName} ${release} (${arch})`,
+    shell: process.env.SHELL || '/bin/sh',
+  }
+}
+
+const env = detectEnv()
+
+function execCommand(
+  command: string,
+  timeout: number,
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  return new Promise(resolve => {
+    const isWindows = os.platform() === 'win32'
+    const shellExe = isWindows ? 'powershell.exe' : process.env.SHELL || '/bin/sh'
+    const shellArgs = isWindows
+      ? ['-NoProfile', '-NonInteractive', '-Command', command]
+      : ['-c', command]
+
+    const child = spawn(shellExe, shellArgs, {
+      cwd: process.cwd(),
+      env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+      windowsHide: true,
+    })
+
+    let stdout = ''
+    let stderr = ''
+    const timer = setTimeout(() => {
+      child.kill('SIGTERM')
+      setTimeout(() => {
+        try {
+          child.kill('SIGKILL')
+        } catch {
+          /* already exited */
+        }
+      }, 5000)
+    }, timeout)
+
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString('utf-8')
+    })
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString('utf-8')
+    })
+
+    child.on('close', code => {
+      clearTimeout(timer)
+      resolve({ stdout, stderr, exitCode: code ?? 0 })
+    })
+
+    child.on('error', err => {
+      clearTimeout(timer)
+      resolve({ stdout, stderr: stderr + fmtErr(err), exitCode: 1 })
+    })
+  })
+}
+
 export const bashTool: Tool = {
   definition: {
     name: 'bash',
-    description: 'Execute a shell command. Returns stdout and stderr.',
+    description: `Execute a shell command. Returns stdout and stderr.
+
+Environment: ${env.osInfo}
+Shell: ${env.shell}
+
+      ⚠️ IMPORTANT: Do NOT use this tool to create or modify files. Use the 'edit' tool for file modifications instead.`,
     parameters: {
       command: { type: 'string', description: 'Shell command to execute', required: true },
       description: { type: 'string', description: 'Brief description of what the command does' },
@@ -25,12 +99,24 @@ export const bashTool: Tool = {
     const timeout = (input.timeout as number) || 120_000
 
     try {
-      const { stdout } = await execAsync(command, {
-        encoding: 'utf-8',
-        timeout,
-        maxBuffer: 10 * 1024 * 1024,
-      })
-      return { success: true, output: stdout || '(no output)' }
+      const { stdout, stderr, exitCode } = await execCommand(command, timeout)
+
+      let output = ''
+      if (stdout.trim()) output += stdout.trim()
+      if (stderr.trim()) {
+        output += output ? '\n' + stderr.trim() : stderr.trim()
+      }
+      if (!output) output = '(no output)'
+
+      if (exitCode !== 0) {
+        return {
+          success: false,
+          output,
+          error: `Command exited with code ${exitCode}`,
+        }
+      }
+
+      return { success: true, output }
     } catch (err) {
       const msg = fmtErr(err)
       return { success: false, output: '', error: `Command failed: ${msg}` }