lonny-agent 0.2.4 → 0.2.7

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

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { fetchTool } from '../fetch.js'
+import { fetchTool } from '../web/fetch.js'
 
 describe('fetch tool', () => {
   it('rejects missing url', async () => {

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

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { globTool } from '../glob.js'
+import { globTool } from '../codebase/glob.js'
 import { makeTempDir } from './helpers.js'
 
 describe('glob tool', () => {

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

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { createGrepTool } from '../grep.js'
+import { createGrepTool } from '../codebase/grep.js'
 import { makeTempDir } from './helpers.js'
 
 describe('grep tool', () => {
@@ -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/__tests__/ls.test.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { createLsTool } from '../ls.js'
+import { createLsTool } from '../codebase/ls.js'
 import { makeTempDir } from './helpers.js'
 
 describe('ls tool', () => {

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

@@ -2,7 +2,7 @@ import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
 import { FileReadTracker } from '../../diff/apply.js'
-import { createReadTool } from '../read.js'
+import { createReadTool } from '../codebase/read.js'
 import { makeTempDir } from './helpers.js'
 
 describe('read tool', () => {

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

@@ -51,6 +51,44 @@ describe('ToolRegistry', () => {
     expect(names).toContain('fetch')
   })
 
+  it('registers all tools in loop mode (same as code)', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'loop',
+    })
+    const defs = reg.getDefinitions()
+    const names = defs.map(d => d.name)
+    expect(names).toContain('read')
+    expect(names).toContain('glob')
+    expect(names).toContain('grep')
+    expect(names).toContain('ls')
+    expect(names).toContain('bash')
+    expect(names).toContain('edit')
+    expect(names).toContain('fetch')
+    expect(names).toContain('search')
+    expect(names).toContain('find')
+    expect(names).toContain('git')
+    expect(names).toContain('install_skill')
+    expect(names).not.toContain('write_plan')
+  })
+
+  it('setMode handles loop mode correctly', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    reg.setMode('loop')
+    const names = reg.getDefinitions().map(d => d.name)
+    expect(names).toContain('edit')
+    expect(names).toContain('bash')
+    expect(names).toContain('read')
+    expect(names).not.toContain('write_plan')
+  })
+
   it('setMode adds edit when switching to code', () => {
     const reg = new ToolRegistry({
       cwd: tmpDir,
@@ -100,4 +138,298 @@ describe('ToolRegistry', () => {
     expect(result.success).toBe(false)
     expect(result.error).toContain('Unknown tool')
   })
+
+  // ── Tiered access tests ──────────────────────────────────────────────
+
+  it('getCoreDefinitions returns only core tools + gateway in code mode', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const core = reg.getCoreDefinitions()
+    const names = core.map(d => d.name)
+    // Core tools
+    expect(names).toContain('read')
+    expect(names).toContain('edit')
+    expect(names).toContain('bash')
+    expect(names).toContain('glob')
+    expect(names).toContain('grep')
+    expect(names).toContain('task_complete')
+    // Gateway tool
+    expect(names).toContain('tool')
+    // Extended tools should NOT be in core
+    expect(names).not.toContain('ls')
+    expect(names).not.toContain('find')
+    expect(names).not.toContain('git')
+    expect(names).not.toContain('fetch')
+    expect(names).not.toContain('search')
+    expect(names).not.toContain('install_skill')
+    expect(names).not.toContain('write_plan')
+    expect(names).not.toContain('save_memory')
+    expect(names).not.toContain('list_memory')
+    expect(names).not.toContain('delete_memory')
+    // Exactly 7 tools in core set (6 core + 1 gateway)
+    expect(names.length).toBe(7)
+  })
+
+  it('getDefinitions still returns all tools including extended ones', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const all = reg.getDefinitions()
+    const names = all.map(d => d.name)
+    expect(names).toContain('read')
+    expect(names).toContain('edit')
+    expect(names).toContain('ls')
+    expect(names).toContain('find')
+    expect(names).toContain('git')
+    expect(names).toContain('fetch')
+    expect(names).toContain('tool') // gateway is always in the registry
+    expect(names.length).toBeGreaterThan(6)
+  })
+
+  it('tool() gateway dispatches to an extended tool (ls)', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    // Simulate what the LLM would do: call tool({ name: "ls", params: { path: tmpDir } })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'ls', params: { path: tmpDir } },
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('a.txt')
+  })
+
+  it('tool() gateway rejects recursive call', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'tool', params: {} },
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('recursively')
+  })
+
+  it('tool() gateway rejects missing name', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { params: {} },
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('name')
+  })
+
+  it('getCoreDefinitions returns core-only in plan mode', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'plan',
+    })
+    const core = reg.getCoreDefinitions()
+    const names = core.map(d => d.name)
+    expect(names).toContain('read')
+    expect(names).toContain('glob')
+    expect(names).toContain('grep')
+    expect(names).toContain('tool')
+    // write_plan is extended → not in core
+    expect(names).not.toContain('write_plan')
+    // edit is not in plan mode at all
+    expect(names).not.toContain('edit')
+  })
+
+  it('getCoreDefinitions returns only fetch/search in ask mode', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'ask',
+    })
+    const core = reg.getCoreDefinitions()
+    const names = core.map(d => d.name)
+    expect(names).toContain('fetch')
+    expect(names).toContain('search')
+    expect(names).not.toContain('read')
+    expect(names).not.toContain('edit')
+    expect(names).not.toContain('tool') // ask mode doesn't need the gateway
+  })
+
+  // ── Gateway + core tool integration tests ────────────────────────────
+
+  it('tool() gateway dispatches edit with markdown format', async () => {
+    const file = path.join(tmpDir, 'gateway-edit.txt')
+    fs.writeFileSync(file, 'hello world\n')
+    const applier = new FileReadTracker()
+    applier.markRead(file)
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier,
+      mode: 'code',
+    })
+    const input = '```edit\nfile: gateway-edit.txt\nold: |\nhello world\nnew: |\nHELLO WORLD\n```'
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'edit', params: { content: input } },
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('HELLO WORLD')
+    expect(fs.readFileSync(file, 'utf8')).toBe('HELLO WORLD\n')
+  })
+
+  it('tool() gateway dispatches edit with legacy JSON format', async () => {
+    const file = path.join(tmpDir, 'gateway-edit-json.txt')
+    fs.writeFileSync(file, 'foo bar\n')
+    const applier = new FileReadTracker()
+    applier.markRead(file)
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier,
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: {
+        name: 'edit',
+        params: {
+          edits: [
+            { file_path: 'gateway-edit-json.txt', old_string: 'foo bar', new_string: 'FOO BAR' },
+          ],
+        },
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(fs.readFileSync(file, 'utf8')).toBe('FOO BAR\n')
+  })
+
+  it('tool() gateway dispatches bash with string param (normalization)', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    // When params is a bare string, normalizeToolInput wraps it into { command: <string> }
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'bash', params: 'echo gateway-test' },
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('gateway-test')
+  })
+
+  it('tool() gateway dispatches bash with object param', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'bash', params: { command: 'echo obj-param-test' } },
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('obj-param-test')
+  })
+
+  it('tool() gateway dispatches read with array params (normalization)', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    // Array params get normalized: ["a.txt"] → { paths: ["a.txt"], path: "a.txt" }
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: {
+        name: 'read',
+        params: { paths: [path.relative(tmpDir, path.join(tmpDir, 'a.txt'))] },
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(result.output).toContain('a.txt')
+  })
+
+  it('tool() gateway reports error for unknown extended tool', async () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'gateway-test',
+      name: 'tool',
+      input: { name: 'nonexistent_tool', params: {} },
+    })
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Unknown tool')
+  })
+
+  it('direct dispatch to edit still works (unchanged)', async () => {
+    const file = path.join(tmpDir, 'direct-edit.txt')
+    fs.writeFileSync(file, 'direct\n')
+    const applier = new FileReadTracker()
+    applier.markRead(file)
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier,
+      mode: 'code',
+    })
+    const result = await reg.dispatch({
+      id: 'direct',
+      name: 'edit',
+      input: {
+        edits: [{ file_path: 'direct-edit.txt', old_string: 'direct', new_string: 'EDITED' }],
+      },
+    })
+    expect(result.success).toBe(true)
+    expect(fs.readFileSync(file, 'utf8')).toBe('EDITED\n')
+  })
+
+  it('setMode retains gateway tool after mode switch', () => {
+    const reg = new ToolRegistry({
+      cwd: tmpDir,
+      autoApprove: true,
+      applier: new FileReadTracker(),
+      mode: 'code',
+    })
+    expect(reg.getCoreDefinitions().map(d => d.name)).toContain('tool')
+    reg.setMode('plan')
+    expect(reg.getCoreDefinitions().map(d => d.name)).toContain('tool')
+    reg.setMode('loop')
+    expect(reg.getCoreDefinitions().map(d => d.name)).toContain('tool')
+  })
 })

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

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
 import { afterAll, beforeAll, describe, expect, it } from 'vitest'
-import { createWritePlanTool } from '../write_plan.js'
+import { createWritePlanTool } from '../edit/write_plan.js'
 import { makeTempDir } from './helpers.js'
 
 describe('write_plan tool', () => {