lonny-agent 0.2.4 → 0.2.7

package/src/tools/registry.ts

@@ -1,23 +1,33 @@
 import type { FileReadTracker } from '../diff/apply.js'
-import { bashTool } from './bash.js'
-import { createEditTool } from './edit.js'
+import { createAstTools } from './codebase/ast/tools.js'
+import { createFindTool } from './codebase/find.js'
+import { globTool } from './codebase/glob.js'
+import { createGrepTool } from './codebase/grep.js'
+import { createLsTool } from './codebase/ls.js'
+import { createReadTool } from './codebase/read.js'
+import { createEditTool } from './edit/edit.js'
+import { createWritePlanTool } from './edit/write_plan.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'
-import { globTool } from './glob.js'
-import { createGrepTool } from './grep.js'
-import { createInstallSkillTool } from './install_skill.js'
-import { createLsTool } from './ls.js'
-import { createReadTool } from './read.js'
-import { searchTool } from './search.js'
+import { bashTool } from './execute/bash/index.js'
+import { createGitTool } from './execute/git.js'
+import { taskCompleteTool } from './execute/task_complete.js'
+import { createInstallSkillTool } from './install/install_skill.js'
+import { createDeleteMemoryTool } from './memory/delete_memory.js'
+import { createListMemoryTool } from './memory/list_memory.js'
+import { createSaveMemoryTool } from './memory/save_memory.js'
 import type { Tool, ToolCall, ToolDefinition, ToolResult } from './types.js'
-import { createWritePlanTool } from './write_plan.js'
+import { fetchTool } from './web/fetch.js'
+import { searchTool } from './web/search.js'
+
+/**
+ * Tools in this set are passed directly to the LLM API's `tools` parameter.
+ * All other tools must be invoked via the `tool()` gateway.
+ */
+const CORE_TOOL_NAMES = new Set(['read', 'edit', 'bash', 'glob', 'grep', 'task_complete'])
 
 /**
  * Normalize tool input to prevent common LLM call misuses.
- * The LLM sometimes passes parameters in the wrong format — this function
+ * The LLM sometimes passes parameters in the wrong format �?this function
  * auto-corrects those patterns so tools work reliably.
  *
  * Common misuses handled:
@@ -50,9 +60,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) {
@@ -79,7 +86,7 @@ export interface ToolContext {
   cwd: string
   autoApprove: boolean
   applier: FileReadTracker
-  mode: 'code' | 'plan' | 'ask'
+  mode: 'code' | 'plan' | 'ask' | 'loop'
   onPlanWritten?: (display: string) => void
 }
 
@@ -97,17 +104,67 @@ 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
+  private gatewayTool: Tool
 
   constructor(context: ToolContext) {
     this.context = context
+    this.gatewayTool = this.createGatewayTool()
     this.registerBuiltins()
   }
 
+  /** Create the `tool()` gateway that proxies calls to extended (non-core) tools */
+  private createGatewayTool(): Tool {
+    const dispatch = this.dispatch.bind(this)
+    return {
+      definition: {
+        name: 'tool',
+        description: `Invoke an extended tool. Use this for tools not in the direct-access core set.
+
+The core tools are: read, edit, bash, glob, grep �?use them directly.
+For everything else, call tool() with the tool name and its parameters.
+
+Examples:
+  tool({ name: "git", params: { command: "status" } })
+  tool({ name: "ls", params: { path: "src" } })
+  tool({ name: "find", params: { pattern: "*.ts" } })
+  tool({ name: "fetch", params: { url: "https://example.com" } })`,
+        parameters: {
+          name: {
+            type: 'string',
+            description: 'The extended tool name to invoke',
+            required: true,
+          },
+          params: {
+            type: 'object',
+            description: 'Tool-specific parameters as a JSON object',
+            required: true,
+          },
+        },
+      },
+      async execute(input) {
+        const name = input.name as string | undefined
+        if (!name || typeof name !== 'string') {
+          return { success: false, output: '', error: 'tool() requires a "name" field (string)' }
+        }
+        if (name === 'tool') {
+          return { success: false, output: '', error: 'Cannot call tool() recursively' }
+        }
+        const call: ToolCall = {
+          id: `gateway-${Date.now()}`,
+          name,
+          input: (input.params || {}) as Record<string, unknown>,
+        }
+        return dispatch(call)
+      },
+    }
+  }
+
   /** Register all built-in tools */
   private registerBuiltins(): void {
-    // ask mode: only fetch and search + exec (exec works with any toolset)
+    // Register the gateway tool first so it's always available
+    this.register(this.gatewayTool)
+
+    // ask mode: only fetch and search
     if (this.context.mode === 'ask') {
       this.register(fetchTool)
       this.register(searchTool)
@@ -122,56 +179,54 @@ export class ToolRegistry {
     this.register(fetchTool)
     this.register(searchTool)
 
-    if (this.context.mode === 'code') {
-      // Code mode: full toolset including write operations
+    if (this.context.mode === 'code' || this.context.mode === 'loop') {
+      // Code/Loop mode: full toolset including write operations
       this.register(bashTool)
       this.register(createGitTool(this.context.cwd))
       this.register(createInstallSkillTool(this.context.cwd))
       this.register(createEditTool(this.context.applier, this.context.cwd))
-      this.registerExecTool()
+      // Register save_memory tool (simple on-disk writer)
+      try {
+        this.register(createSaveMemoryTool(this.context.cwd))
+        this.register(createListMemoryTool(this.context.cwd))
+        this.register(createDeleteMemoryTool(this.context.cwd))
+      } catch (err) {
+        // If for some reason the tool can't be created, ignore — not critical
+        console.error('[ToolRegistry] Failed to register memory tools:', err)
+      }
+      // Register AST tools (ast_query, ast_edit)
+      for (const tool of createAstTools()) {
+        this.register(tool)
+      }
+
+      // Register task_complete tool so the model can explicitly signal completion
+      // (most useful in loop mode, but available in code mode too)
+      this.register(taskCompleteTool)
     } 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 {
+  setMode(mode: 'code' | 'plan' | 'ask' | 'loop'): void {
     // Update context.mode FIRST so registerBuiltins() and mode-based logic
     // use the NEW mode, not the stale one (fixes bug when switching from
     // ask→code or plan→code where all tools would be missing)
     this.context.mode = mode
 
-    if (mode === 'code') {
-      // Re-register all built-in tools for code mode
+    if (mode === 'code' || mode === 'loop') {
+      // Code/Loop mode: Re-register all built-in tools for full toolset
       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 +235,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) */
@@ -228,6 +279,26 @@ export class ToolRegistry {
     return Array.from(this.tools.values()).map(t => t.definition)
   }
 
+  /** Get definitions for the core tool set + gateway (for LLM API's tools parameter) */
+  getCoreDefinitions(): ToolDefinition[] {
+    // Ask mode has only 2 tools �?pass them directly, no gateway needed
+    if (this.context.mode === 'ask') {
+      return Array.from(this.tools.values())
+        .filter(t => t.definition.name !== 'tool')
+        .map(t => t.definition)
+    }
+
+    const core: ToolDefinition[] = []
+    for (const [name, tool] of this.tools) {
+      if (CORE_TOOL_NAMES.has(name)) {
+        core.push(tool.definition)
+      }
+    }
+    // Always include the gateway tool so the model can reach extended tools
+    core.push(this.gatewayTool.definition)
+    return core
+  }
+
   async dispatch(call: ToolCall): Promise<ToolResult> {
     const tool = this.tools.get(call.name)
     if (!tool) {

package/src/tools/tree.ts

@@ -0,0 +1,103 @@
+import type { ToolDefinition, ToolTreeNode } from './types.js'
+
+function normalizeLabel(value: string | undefined, fallback: string): string {
+  const trimmed = value?.trim()
+  return trimmed && trimmed !== 'Unclassified' ? trimmed : fallback
+}
+
+function createToolNode(def: ToolDefinition, depth: number): ToolTreeNode {
+  return {
+    type: 'tool',
+    name: def.name,
+    description: def.description,
+    toolName: def.name,
+    depth,
+  }
+}
+
+export function buildToolTree(definitions: ToolDefinition[]): ToolTreeNode[] {
+  const root: ToolTreeNode[] = []
+  const groups = new Map<string, ToolTreeNode>()
+
+  function getOrCreate(parts: string[], depth: number): ToolTreeNode {
+    const key = parts.join('/')
+    let node = groups.get(key)
+    if (!node) {
+      node = {
+        type: 'group',
+        name: parts[parts.length - 1] || 'Other',
+        children: [],
+        depth,
+      }
+      groups.set(key, node)
+
+      if (parts.length === 1) {
+        root.push(node)
+      } else {
+        const parent = groups.get(parts.slice(0, -1).join('/'))
+        parent?.children?.push(node)
+      }
+    }
+    return node
+  }
+
+  for (const def of definitions) {
+    const category = normalizeLabel(def.category, 'Other')
+    const rawGroup = normalizeLabel(def.group, 'Unclassified')
+
+    // Build path: category first, then split group by '/' for multi-level nesting
+    const parts = [category]
+    if (rawGroup && rawGroup !== 'Unclassified') {
+      parts.push(
+        ...rawGroup
+          .split('/')
+          .map(p => p.trim())
+          .filter(Boolean),
+      )
+    }
+
+    // Create all intermediate group nodes (parents before children)
+    for (let i = 1; i <= parts.length; i++) {
+      const node = getOrCreate(parts.slice(0, i), i - 1)
+      if (i === parts.length) {
+        node.children?.push(createToolNode(def, i))
+      }
+    }
+  }
+
+  return root
+}
+
+/**
+ * Format the tool tree for inclusion in the system prompt.
+ *
+ * @param definitions - All tool definitions (for building the full tree)
+ * @param coreNames - Optional set of core tool names. When provided, tools NOT
+ *   in this set are annotated with "(via tool)" to indicate they require the
+ *   `tool()` gateway.
+ */
+export function formatToolTreeForPrompt(
+  definitions: ToolDefinition[],
+  coreNames?: Set<string>,
+): string {
+  const lines: string[] = []
+
+  function render(node: ToolTreeNode, level: number): void {
+    const indent = '  '.repeat(level)
+    if (node.type === 'group') {
+      lines.push(`${indent}- ${node.name}`)
+    } else {
+      const suffix = coreNames && !coreNames.has(node.name) ? ' (via tool gateway)' : ''
+      lines.push(`${indent}- \`${node.name}\`: ${node.description || ''}${suffix}`)
+    }
+    for (const child of node.children || []) {
+      render(child, level + 1)
+    }
+  }
+
+  for (const node of buildToolTree(definitions)) {
+    render(node, 0)
+  }
+
+  return lines.join('\n')
+}

package/src/tools/types.ts

@@ -9,6 +9,10 @@ export interface ToolDefinition {
   name: string
   description: string
   parameters: Record<string, ToolParameter>
+  /** Top-level category used for hierarchical tool trees, e.g. "File I/O". */
+  category?: string
+  /** Second-level group used for hierarchical tool trees, e.g. "Read". */
+  group?: string
 }
 
 export interface ToolCall {
@@ -27,3 +31,12 @@ export interface Tool {
   definition: ToolDefinition
   execute(input: Record<string, unknown>): Promise<ToolResult>
 }
+
+export interface ToolTreeNode {
+  type: 'group' | 'tool'
+  name: string
+  description?: string
+  children?: ToolTreeNode[]
+  toolName?: string
+  depth: number
+}

package/src/tools/{fetch.ts → web/fetch.ts}

@@ -1,9 +1,11 @@
-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 const fetchTool: Tool = {
   definition: {
     name: 'fetch',
+    category: 'Web',
+    group: 'Fetch',
     description: 'Fetch content from a URL. Returns the response body as text.',
     parameters: {
       url: { type: 'string', description: 'URL to fetch', required: true },

package/src/tools/{search.ts → web/search.ts}

@@ -1,8 +1,8 @@
 import * as fs from 'node:fs'
 import * as os from 'node:os'
 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'
 
 interface TavilyConfig {
   tavilyApiKey?: string
@@ -30,6 +30,8 @@ const TAVILY_API_URL = 'https://api.tavily.com/search'
 export const searchTool: Tool = {
   definition: {
     name: 'search',
+    category: 'Web',
+    group: 'Search Engine',
     description:
       'Search the web using the Tavily search engine. Returns a summary answer and a list of relevant results with titles, URLs, and content snippets.',
     parameters: {

package/src/tui/commands.ts

@@ -0,0 +1,135 @@
+import type { CommandUI } from '../agent/commands.js'
+import { dispatchCommand } from '../agent/commands.js'
+import { fmtErr } from '../tools/errors.js'
+import { colors } from './components/index.js'
+import type { TuiContext } from './overlays.js'
+import {
+  refreshBalance,
+  refreshPlans,
+  showHelpOverlay,
+  showPlansOverlay,
+  updateFooter,
+} from './overlays.js'
+
+export function handleConfirmInput(ctx: TuiContext, data: string): boolean {
+  if (!ctx.pendingConfirmResolve) return false
+  const key = data.trim().toLowerCase()
+  if (key === 'y' || key === 'yes') {
+    ctx.pendingConfirmResolve(true)
+    ctx.pendingConfirmResolve = null
+    ctx.chatContent += 'y\n'
+    ctx.chatMarkdown.setText(ctx.chatContent)
+    ctx.tui.requestRender(true)
+    return true
+  } else if (key === 'n' || key === 'no' || key === '\r' || key === '') {
+    ctx.pendingConfirmResolve(false)
+    ctx.pendingConfirmResolve = null
+    ctx.chatContent += 'N\n'
+    ctx.chatMarkdown.setText(ctx.chatContent)
+    ctx.tui.requestRender(true)
+    return true
+  }
+  return false
+}
+
+function makeCommandUI(ctx: TuiContext): CommandUI {
+  return {
+    write: (text: string) => {
+      ctx.chatContent += '\n' + text + '\n'
+      ctx.chatMarkdown.setText(ctx.chatContent)
+    },
+    replaceContent: (text: string) => {
+      ctx.chatContent = text
+      ctx.chatMarkdown.setText(text)
+    },
+    onStateChange: () => {
+      updateFooter(ctx)
+    },
+    onNewSession: (session: any) => {
+      ctx.session = session
+      ctx.session.onPlanWritten = ctx.planCb
+      ctx.plansList.clearFilter()
+      ;(ctx.editor as any).undoStack.clear()
+      ;(ctx.editor as any).history = []
+      ;(ctx.editor as any).killRing.ring = []
+    },
+  }
+}
+
+export async function sendMessage(ctx: TuiContext, text: string): Promise<void> {
+  const trimmed = text.trim()
+  if (!trimmed) return
+  ctx.editor.setText('')
+  ctx.editor.addToHistory(trimmed)
+
+  if (trimmed.startsWith('/')) {
+    const parts = trimmed.slice(1).split(/\s+/)
+    const cmd = parts[0]
+    const arg = parts.slice(1).join(' ')
+
+    // TUI-specific commands
+    if (cmd === 'exit' || cmd === 'quit') {
+      ctx.chatContent += `\n${colors.dim('Goodbye!')}\n`
+      ctx.chatMarkdown.setText(ctx.chatContent)
+      ctx.tui.stop()
+      process.exit(0)
+      return
+    }
+    if (cmd === 'plans') {
+      showPlansOverlay(ctx)
+      return
+    }
+    if (cmd === 'filter') {
+      ctx.plansList.setFilter(arg)
+      ctx.tui.requestRender(true)
+      return
+    }
+    if (cmd === 'help' || cmd === '?') {
+      showHelpOverlay(ctx)
+      return
+    }
+
+    // Shared commands
+    const ui = makeCommandUI(ctx)
+    const handled = await dispatchCommand(
+      { session: ctx.session, config: ctx.config, ui, isRunning: ctx.isRunning },
+      cmd,
+      arg,
+    )
+    if (handled) {
+      ctx.tui.requestRender(true)
+      return
+    }
+
+    ctx.chatContent += `\n${colors.error('\u2716')} Unknown command: /${cmd}. ${colors.dim('Type /help for available commands.')}\n`
+    ctx.chatMarkdown.setText(ctx.chatContent)
+    return
+  }
+
+  if (ctx.isRunning) return
+
+  ctx.isRunning = true
+  ctx.loader.setMessage('thinking...')
+  ctx.tui.setShowHardwareCursor(false)
+  updateFooter(ctx)
+
+  ctx.session
+    .chat(trimmed)
+    .then(() => {
+      ctx.isRunning = false
+      ctx.loader.setMessage('')
+      refreshPlans(ctx)
+      ctx.tui.setShowHardwareCursor(true)
+      updateFooter(ctx)
+      refreshBalance(ctx)
+    })
+    .catch((err: unknown) => {
+      ctx.isRunning = false
+      ctx.loader.setMessage('')
+      const errMsg = fmtErr(err)
+      ctx.chatContent += `\n${colors.error('\u2716 Error:')} ${errMsg}\n`
+      ctx.chatMarkdown.setText(ctx.chatContent)
+      ctx.tui.setShowHardwareCursor(true)
+      updateFooter(ctx)
+    })
+}

package/src/tui/components/colors.ts

@@ -0,0 +1,52 @@
+import * as fs from 'node:fs'
+
+function safeBg(text: string, bg: string): string {
+  return `\x1b[${bg}m${text.replace(/\x1b\[0m/g, `\x1b[0m\x1b[${bg}m`)}\x1b[0m`
+}
+
+export { safeBg }
+
+export const colors = {
+  bgDark: (text: string) => safeBg(text, '48;2;30;30;30'),
+  bgDim: (text: string) => safeBg(text, '48;2;25;25;25'),
+  headerBg: (text: string) => safeBg(text, '48;2;170;170;170'),
+  separator: (text: string) => `\x1b[38;2;60;60;60m${text}\x1b[0m`,
+  statusBg: (text: string) => safeBg(text, '48;2;25;25;35'),
+  running: (text: string) => `\x1b[38;2;0;255;100m${text}\x1b[0m`,
+  idle: (text: string) => `\x1b[38;2;150;150;150m${text}\x1b[0m`,
+  doneTodo: (text: string) => `\x1b[38;2;100;200;100m${text}\x1b[0m`,
+  todo: (text: string) => `\x1b[38;2;150;150;150m${text}\x1b[0m`,
+  accent: (text: string) => `\x1b[38;2;0;170;255m${text}\x1b[0m`,
+  dim: (text: string) => `\x1b[38;2;90;90;90m${text}\x1b[0m`,
+  userLabel: (text: string) => `\x1b[38;2;255;200;50m${text}\x1b[0m`,
+  assistantLabel: (text: string) => `\x1b[38;2;0;255;150m${text}\x1b[0m`,
+  error: (text: string) => `\x1b[38;2;255;80;80m${text}\x1b[0m`,
+  success: (text: string) => `\x1b[38;2;0;200;100m${text}\x1b[0m`,
+  inputPrompt: (text: string) => `\x1b[38;2;0;170;255m${text}\x1b[0m`,
+  warn: (text: string) => `\x1b[38;2;255;200;50m${text}\x1b[0m`,
+}
+
+const APP_VERSION: string = (() => {
+  try {
+    const pkgPath = new URL('../../package.json', import.meta.url)
+    const raw = fs.readFileSync(pkgPath, 'utf-8')
+    return JSON.parse(raw).version || '0.1.0'
+  } catch {
+    return '0.1.0'
+  }
+})()
+
+export { APP_VERSION }
+
+export const landingColors = {
+  inputBg: '\x1b[48;2;35;35;35m',
+  inputBorder: '\x1b[38;2;60;60;60m',
+  cyanBar: '\x1b[38;2;0;200;255m',
+  placeholderDim: '\x1b[38;2;130;130;130m',
+  placeholderQuote: '\x1b[38;2;160;160;160m',
+  inputText: '\x1b[38;2;220;220;220m',
+  statusBg: '\x1b[48;2;18;18;18m',
+  statusText: '\x1b[38;2;110;110;110m',
+  statusAccent: '\x1b[38;2;0;170;255m',
+  reset: '\x1b[0m',
+}