lonny-agent 0.2.4 → 0.2.7

package/src/tools/codebase/ast/__tests__/tree-sitter.test.ts

@@ -0,0 +1,466 @@
+import { describe, expect, it } from 'vitest'
+import { detectLanguage } from '../adapter.js'
+import { createTreeSitterAdapter } from '../tree-sitter-adapter.js'
+
+const adapter = createTreeSitterAdapter()
+
+describe('detectLanguage', () => {
+  it('detects TypeScript', () => {
+    expect(detectLanguage('file.ts')).toBe('typescript')
+    expect(detectLanguage('file.tsx')).toBe('typescript')
+    expect(detectLanguage('file.mts')).toBe('typescript')
+    expect(detectLanguage('file.cts')).toBe('typescript')
+  })
+
+  it('detects JavaScript', () => {
+    expect(detectLanguage('file.js')).toBe('javascript')
+    expect(detectLanguage('file.jsx')).toBe('javascript')
+    expect(detectLanguage('file.mjs')).toBe('javascript')
+    expect(detectLanguage('file.cjs')).toBe('javascript')
+  })
+
+  it('detects Python', () => {
+    expect(detectLanguage('file.py')).toBe('python')
+  })
+
+  it('throws for unsupported files', () => {
+    expect(() => detectLanguage('file.rs')).toThrow('Unsupported file type')
+  })
+})
+
+describe('TreeSitterAdapter - TypeScript/JavaScript', () => {
+  it('parses a simple TypeScript function', async () => {
+    const source = `
+function greet(name: string): string {
+  return "Hello, " + name
+}
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.type).toBe('Module')
+    expect(module.language).toBe('typescript')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].name).toBe('greet')
+    expect(funcs[0].parameters).toHaveLength(1)
+    expect(funcs[0].parameters[0].name).toBe('name')
+    expect(funcs[0].isAsync).toBe(false)
+    expect(funcs[0].isGenerator).toBe(false)
+    expect(funcs[0].startLine).toBe(2)
+  })
+
+  it('parses arrow functions', async () => {
+    const source = `const add = (a: number, b: number): number => a + b`
+    const module = await adapter.parse(source, 'test.ts')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].name).toBeNull()
+    expect(funcs[0].parameters).toHaveLength(2)
+  })
+
+  it('parses async functions', async () => {
+    const source = `
+async function fetchData(url: string): Promise<unknown> {
+  const response = await fetch(url)
+  return response.json()
+}
+`
+    const module = await adapter.parse(source, 'test.ts')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].isAsync).toBe(true)
+    expect(funcs[0].name).toBe('fetchData')
+  })
+
+  it('parses classes with methods', async () => {
+    const source = `class Animal {
+  name: string
+  constructor(name: string) {
+    this.name = name
+  }
+  speak(): string {
+    return this.name
+  }
+}`
+    const module = await adapter.parse(source, 'test.ts')
+    const classes = adapter.findClasses(module)
+    expect(classes).toHaveLength(1)
+    expect(classes[0].name).toBe('Animal')
+    expect(classes[0].members).toHaveLength(3)
+    expect(classes[0].members[0].type).toBe('Property')
+    expect(classes[0].members[0].name).toBe('name')
+    expect(classes[0].members[1].kind).toBe('constructor')
+    expect(classes[0].members[2].kind).toBe('method')
+  })
+
+  it('parses imports', async () => {
+    const source = `
+import { foo, bar as baz } from './utils'
+import fs from 'fs'
+import * as path from 'path'
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.imports).toHaveLength(3)
+    expect(module.imports[0].source).toBe("'./utils'")
+    expect(module.imports[0].specifiers).toHaveLength(2)
+    expect(module.imports[0].specifiers[0].localName).toBe('foo')
+    expect(module.imports[0].specifiers[1].localName).toBe('baz')
+    expect(module.imports[0].specifiers[1].importedName).toBe('bar')
+    expect(module.imports[1].specifiers[0].localName).toBe('fs')
+    expect(module.imports[2].specifiers[0].localName).toBe('path')
+  })
+
+  it('parses exports', async () => {
+    const source = `export const value = 42`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.exports).toContain('value')
+  })
+  it('parses export interface and export type', async () => {
+    const source = `
+export interface Foo {
+  name: string
+}
+export type Bar = string
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.exports).toContain('Foo')
+    expect(module.exports).toContain('Bar')
+  })
+
+  it('parses named export clauses', async () => {
+    const source = `
+const a = 1
+const b = 2
+export { a, b }
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.exports).toContain('a')
+    expect(module.exports).toContain('b')
+  })
+
+  it('parses export with alias', async () => {
+    const source = `
+const x = 1
+export { x as y }
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.exports).toContain('y')
+    expect(module.exports).not.toContain('x')
+  })
+
+  it('detects import type syntax', async () => {
+    const source = "import type { Foo } from './types'"
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.imports).toHaveLength(1)
+    expect(module.imports[0].source).toBe("'./types'")
+    expect(module.imports[0].specifiers[0].localName).toBe('Foo')
+    expect(module.imports[0].isTypeOnly).toBe(true)
+  })
+
+  it('parses class with getter and setter', async () => {
+    const source = `class Foo {
+  get bar(): string {
+    return "hello"
+  }
+  set bar(v: string) {}
+  method(): void {}
+}`
+    const module = await adapter.parse(source, 'test.ts')
+    const cls = adapter.findClasses(module)
+    expect(cls).toHaveLength(1)
+    expect(cls[0].members).toHaveLength(3)
+    expect(cls[0].members[0].kind).toBe('getter')
+    expect(cls[0].members[1].kind).toBe('setter')
+    expect(cls[0].members[2].kind).toBe('method')
+    expect(cls[0].members[0].name).toBe('bar')
+    expect(cls[0].members[1].name).toBe('bar')
+  })
+
+  it('parses export default function and class', async () => {
+    const source = `
+export default function myFunc() {
+  return 1
+}
+export default class MyClass {}
+`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.exports).toContain('myFunc')
+    expect(module.exports).toContain('MyClass')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].name).toBe('myFunc')
+    const classes = adapter.findClasses(module)
+    expect(classes).toHaveLength(1)
+    expect(classes[0].name).toBe('MyClass')
+  })
+
+  it('parses generator and async generator functions', async () => {
+    const source = `
+function* gen() {
+  yield 1
+}
+async function* asyncGen() {
+  yield await Promise.resolve(1)
+}
+`
+    const module = await adapter.parse(source, 'test.ts')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(2)
+    expect(funcs[0].name).toBe('gen')
+    expect(funcs[0].isGenerator).toBe(true)
+    expect(funcs[0].isAsync).toBe(false)
+    expect(funcs[1].name).toBe('asyncGen')
+    expect(funcs[1].isGenerator).toBe(true)
+    expect(funcs[1].isAsync).toBe(true)
+  })
+
+  it('parses variables', async () => {
+    const source = `
+const a = 1
+let b = 2
+var c = 3
+`
+    const module = await adapter.parse(source, 'test.ts')
+    const vars = adapter.findVariables(module)
+    expect(vars).toHaveLength(3)
+    expect(vars[0].name).toBe('a')
+    expect(vars[0].kind).toBe('const')
+  })
+
+  it('gets structure overview', async () => {
+    const source = `
+import { z } from 'zod'
+
+function add(a: number, b: number): number {
+  return a + b
+}
+
+class Calculator {
+  result = 0
+  add(n: number): number {
+    return this.result + n
+  }
+}
+
+const PI = 3.14
+`
+    const module = await adapter.parse(source, 'test.ts')
+    const structure = adapter.getStructure(module)
+    expect(structure.imports).toHaveLength(1)
+    expect(structure.imports[0].source).toBe("'zod'")
+    expect(structure.imports[0].names).toContain('z')
+    expect(structure.functions).toHaveLength(1)
+    expect(structure.functions[0].name).toBe('add')
+    expect(structure.classes).toHaveLength(1)
+    expect(structure.classes[0].name).toBe('Calculator')
+    expect(structure.classes[0].methods).toContain('add')
+    expect(structure.variables).toHaveLength(1)
+    expect(structure.variables[0].name).toBe('PI')
+  })
+})
+
+describe('TreeSitterAdapter - Python', () => {
+  it('parses a Python function', async () => {
+    const source = `
+def greet(name: str) -> str:
+    return f"Hello, {name}"
+`
+    const module = await adapter.parse(source, 'test.py')
+    expect(module.language).toBe('python')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].name).toBe('greet')
+    expect(funcs[0].startLine).toBe(2)
+  })
+
+  it('parses Python class with methods', async () => {
+    const source = `
+class Animal:
+    def __init__(self, name: str):
+        self.name = name
+
+    def speak(self) -> str:
+        return self.name
+`
+    const module = await adapter.parse(source, 'test.py')
+    const classes = adapter.findClasses(module)
+    expect(classes).toHaveLength(1)
+    expect(classes[0].name).toBe('Animal')
+    expect(classes[0].members).toHaveLength(2)
+  })
+
+  it('parses Python imports', async () => {
+    const source = `
+import os, sys
+from pathlib import Path
+import numpy as np
+`
+    const module = await adapter.parse(source, 'test.py')
+    expect(module.imports).toHaveLength(3)
+    expect(module.imports[2].specifiers[0].localName).toBe('np')
+    expect(module.imports[2].specifiers[0].importedName).toBe('np')
+  })
+
+  it('parses Python async functions', async () => {
+    const source = `
+async def fetch_data(url: str):
+    return await some_async_fn(url)
+`
+    const module = await adapter.parse(source, 'test.py')
+    const funcs = adapter.findFunctions(module)
+    expect(funcs).toHaveLength(1)
+    expect(funcs[0].isAsync).toBe(true)
+  })
+})
+
+describe('TreeSitterAdapter - editing', () => {
+  it('replaces a node at a given line', async () => {
+    const source = `function oldFunc() {
+  return 1
+}
+
+function other() {
+  return 2
+}`
+    const result = await adapter.replaceNode(
+      source,
+      'test.ts',
+      1,
+      'function newFunc() {\n  return 42\n}',
+    )
+    expect(result.success).toBe(true)
+    expect(result.source).toContain('newFunc')
+    expect(result.source).toContain('other')
+    expect(result.source).not.toContain('oldFunc')
+  })
+
+  it('errors on non-existent line', async () => {
+    const source = `const x = 1`
+    const result = await adapter.replaceNode(source, 'test.ts', 100, 'should not appear')
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('No node found at line 100')
+  })
+
+  it('applies multiple byte-offset edits', async () => {
+    const source = `function a() { return 1 }
+function b() { return 2 }`
+    const result = await adapter.applyEdits(source, 'test.ts', [
+      { type: 'replace', startOffset: 0, endOffset: 26, text: 'function a() { return 10 }' },
+    ])
+    expect(result.success).toBe(true)
+    expect(result.source).toContain('return 10')
+    expect(result.source).toContain('function b')
+  })
+})
+
+describe('TreeSitterAdapter - error handling', () => {
+  it('handles empty source', async () => {
+    const module = await adapter.parse('', 'test.ts')
+    expect(module.body).toHaveLength(0)
+    expect(module.imports).toHaveLength(0)
+  })
+
+  it('handles source with only comments', async () => {
+    const source = `// this is a comment
+/* another comment */`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module.body).toHaveLength(0)
+  })
+
+  it('handles syntax errors gracefully', async () => {
+    const source = `function ( {`
+    const module = await adapter.parse(source, 'test.ts')
+    expect(module).toBeDefined()
+  })
+
+  it('returns empty structure for unsupported language fallback', async () => {
+    const result = await adapter.replaceNode('x = 1', 'unknown.xyz', 1, 'y = 2')
+    expect(result.success).toBe(false)
+  })
+})
+
+describe('TreeSitterAdapter - insertMethodIntoClass', () => {
+  it('inserts a method into an empty class', async () => {
+    const source = `class MyClass {\n}`
+    const result = await adapter.insertMethodIntoClass(
+      source,
+      'test.ts',
+      'MyClass',
+      'myMethod() { return 42 }',
+    )
+    expect(result.success).toBe(true)
+    expect(result.source).toContain('myMethod()')
+    expect(result.source).toContain('return 42')
+  })
+
+  it('inserts a method into a class with existing members', async () => {
+    const source = `class MyClass {
+  existing() { return 1 }
+}`
+    const result = await adapter.insertMethodIntoClass(
+      source,
+      'test.ts',
+      'MyClass',
+      'newMethod() { return 2 }',
+    )
+    expect(result.success).toBe(true)
+    expect(result.source).toContain('existing()')
+    expect(result.source).toContain('newMethod()')
+    expect(result.source.indexOf('newMethod')).toBeGreaterThan(result.source.indexOf('existing'))
+  })
+
+  it('returns error for non-existent class', async () => {
+    const source = `class A {}`
+    const result = await adapter.insertMethodIntoClass(source, 'test.ts', 'NonExistent', 'm() {}')
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('not found')
+  })
+
+  it('returns error for missing class in Python file', async () => {
+    const result = await adapter.insertMethodIntoClass('x = 1', 'file.py', 'X', 'def m(): pass')
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('not found')
+  })
+})
+
+describe('TreeSitterAdapter - findReferences', () => {
+  it('finds direct function calls', async () => {
+    const source = `
+function foo() { return 1 }
+function bar() {
+  const x = foo()
+  const y = foo(42)
+  return x + y
+}
+`
+    const refs = await adapter.findReferences(source, 'test.ts', 'foo')
+    expect(refs).toHaveLength(2)
+    expect(refs[0].line).toBe(4)
+    expect(refs[0].context).toContain('foo()')
+    expect(refs[1].line).toBe(5)
+    expect(refs[1].context).toContain('foo(42)')
+  })
+
+  it('finds method calls on objects', async () => {
+    const source = `
+const obj = { doStuff() { return 1 } }
+obj.doStuff()
+obj.doStuff(1, 2, 3)
+`
+    const refs = await adapter.findReferences(source, 'test.ts', 'doStuff')
+    expect(refs).toHaveLength(2)
+    expect(refs[0].context).toContain('obj.doStuff()')
+    expect(refs[1].context).toContain('obj.doStuff(1, 2, 3)')
+  })
+
+  it('returns empty array when no matches', async () => {
+    const source = `const x = 1\n`
+    const refs = await adapter.findReferences(source, 'test.ts', 'nonexistent')
+    expect(refs).toHaveLength(0)
+  })
+
+  it('works via nameFilter', async () => {
+    const source = `const x = foo()\n`
+    const refs = await adapter.findReferences(source, 'test.ts', 'foo')
+    expect(refs).toHaveLength(1)
+  })
+})

package/src/tools/codebase/ast/adapter.ts

@@ -0,0 +1,44 @@
+import type {
+  AstEdit,
+  Class,
+  FuncDecl,
+  Module,
+  Reference,
+  StructureOverview,
+  TextEditResult,
+  Variable,
+} from './types.js'
+
+export type { AstEdit, TextEditResult }
+
+export function detectLanguage(filePath: string): 'typescript' | 'javascript' | 'python' {
+  const ext = filePath.toLowerCase().split('.').pop() || ''
+  if (ext === 'ts' || ext === 'tsx' || ext === 'mts' || ext === 'cts') return 'typescript'
+  if (ext === 'js' || ext === 'jsx' || ext === 'mjs' || ext === 'cjs') return 'javascript'
+  if (ext === 'py') return 'python'
+  throw new Error(`Unsupported file type for AST: ${filePath}`)
+}
+
+export interface AstAdapter {
+  init(): Promise<void>
+  supportedLanguages(): string[]
+  parse(source: string, filePath: string): Promise<Module>
+  findFunctions(node: Module, query?: { name?: string }): FuncDecl[]
+  findClasses(node: Module, query?: { name?: string }): Class[]
+  findVariables(node: Module, query?: { name?: string }): Variable[]
+  findReferences(source: string, filePath: string, name: string): Promise<Reference[]>
+  getStructure(node: Module): StructureOverview
+  applyEdits(source: string, filePath: string, edits: AstEdit[]): Promise<TextEditResult>
+  replaceNode(
+    source: string,
+    filePath: string,
+    targetLine: number,
+    newCode: string,
+  ): Promise<TextEditResult>
+  insertMethodIntoClass(
+    source: string,
+    filePath: string,
+    className: string,
+    methodCode: string,
+  ): Promise<TextEditResult>
+}