lonny-agent 0.2.6 → 0.2.7

package/src/tools/install/skill-content.ts

@@ -0,0 +1,108 @@
+import { CLAWHUB_SITE } from './constants.js'
+
+/** Sanitize a package name to a valid skill name (lowercase, digits, hyphens) */
+export function sanitizeSkillName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/@/g, '')
+    .replace(/\//g, '-')
+    .replace(/[^a-z0-9-]/g, '')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+}
+
+/** Generate a usage guide snippet from the readme */
+export function extractUsageGuide(readme: string): string {
+  // Try to extract code examples from the readme
+  const codeBlocks: string[] = []
+  const blockRegex = /```(?:js|javascript|ts|typescript|bash)\n([\s\S]*?)```/g
+  let match: RegExpExecArray | null = blockRegex.exec(readme)
+  while (match !== null) {
+    const block = match[1].trim()
+    if (block.length > 0 && block.length < 1000) {
+      codeBlocks.push(block)
+    }
+    match = blockRegex.exec(readme)
+  }
+  return codeBlocks.slice(0, 3).join('\n\n')
+}
+
+/** Generate the skill markdown content (npm package) */
+export function generateSkillContent(
+  packageName: string,
+  description: string,
+  usageGuide: string,
+): string {
+  const installCmd = `npm install ${packageName}`
+
+  let content = `---
+name: ${sanitizeSkillName(packageName)}
+description: ${description}
+---
+
+# ${packageName}
+
+${description}
+
+## Installation
+
+This package is already installed in the project via \`${installCmd}\`.
+
+## Usage
+
+You can import and use this package in your code:
+
+\`\`\`typescript
+import ${packageName.replace(/@/, '').replace(/[/-]/g, '_')} from '${packageName}'
+\`\`\`
+`
+
+  if (usageGuide) {
+    content += `\n## Examples\n\n${usageGuide}\n`
+  }
+
+  content += `
+## Notes
+
+- This skill was automatically installed. The package is available as a project dependency.
+- Refer to the package's npm page or repository for full documentation.
+`
+
+  return content
+}
+
+/** Generate the skill markdown content (ClawHub skill) */
+export function generateClawHubSkillContent(
+  slug: string,
+  displayName: string,
+  summary: string,
+  clawhubContent: string,
+): string {
+  // If the ZIP contains a SKILL.md, use it directly
+  // Otherwise, generate a wrapper skill file
+  let content = `---
+name: ${sanitizeSkillName(slug)}
+description: ${summary || displayName}
+clawhub: ${slug}
+---
+
+# ${displayName}
+
+${summary || `ClawHub skill: ${slug}`}
+
+`
+
+  if (clawhubContent) {
+    content += `${clawhubContent}\n`
+  }
+
+  content += `
+## Notes
+
+- This skill was installed from [ClawHub](${CLAWHUB_SITE}/${slug}).
+- Source: ${CLAWHUB_SITE}/${slug}
+- The skill instructions are loaded automatically on the next turn.
+`
+
+  return content
+}

package/src/tools/memory/delete_memory.ts

@@ -0,0 +1,46 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { fmtErr } from '../errors.js'
+import type { Tool, ToolResult } from '../types.js'
+
+export function createDeleteMemoryTool(cwd: string): Tool {
+  return {
+    definition: {
+      name: 'delete_memory',
+      category: 'Memory',
+      group: 'Manage',
+      description:
+        'Delete a memory entry by id or filename under .lonny/memory (id or file parameter)',
+      parameters: {
+        id: {
+          type: 'string',
+          description: 'Memory id (filename without .json) or relative filename',
+          required: true,
+        },
+      },
+    },
+    async execute(input): Promise<ToolResult> {
+      try {
+        const id = (input as any).id || input
+        if (typeof id !== 'string' || !id)
+          return { success: false, output: '', error: 'id is required (string)' }
+        const dir = path.resolve(cwd, '.lonny', 'memory')
+        const candidates = [id, `${id}.json`]
+        for (const c of candidates) {
+          const p = path.join(dir, c)
+          try {
+            if (fs.existsSync(p)) {
+              fs.unlinkSync(p)
+              return { success: true, output: `Deleted memory ${c}` }
+            }
+          } catch (e) {
+            return { success: false, output: '', error: fmtErr(e) }
+          }
+        }
+        return { success: false, output: '', error: `Memory not found: ${id}` }
+      } catch (err) {
+        return { success: false, output: '', error: fmtErr(err) }
+      }
+    },
+  }
+}

package/src/tools/memory/list_memory.ts

@@ -0,0 +1,53 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { fmtErr } from '../errors.js'
+import type { Tool, ToolResult } from '../types.js'
+
+export function createListMemoryTool(cwd: string): Tool {
+  return {
+    definition: {
+      name: 'list_memory',
+      category: 'Memory',
+      group: 'Query',
+      description: 'List memory entries stored under .lonny/memory (optional limit param)',
+      parameters: {
+        limit: {
+          type: 'number',
+          description: 'Maximum number of entries to return',
+          required: false,
+        },
+      },
+    },
+    async execute(input): Promise<ToolResult> {
+      try {
+        const limit = typeof (input as any).limit === 'number' ? (input as any).limit : undefined
+        const dir = path.resolve(cwd, '.lonny', 'memory')
+        if (!fs.existsSync(dir)) return { success: true, output: 'No memories found' }
+        const files = fs.readdirSync(dir).filter(f => f.endsWith('.json'))
+        const entries: { id: string; createdAt: string; preview: string; tags?: string[] }[] = []
+        for (const f of files) {
+          try {
+            const data = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'))
+            entries.push({
+              id: data.id || f.replace(/\.json$/, ''),
+              createdAt: data.createdAt || '',
+              preview: (data.content || '').replace(/\n/g, ' ').slice(0, 200),
+              tags: Array.isArray(data.tags) ? data.tags : undefined,
+            })
+          } catch {
+            // ignore corrupted
+          }
+        }
+        // sort by createdAt desc
+        entries.sort((a, b) => (a.createdAt < b.createdAt ? 1 : -1))
+        const out = entries.slice(0, limit || entries.length).map(e => {
+          const tagStr = e.tags ? ` [tags: ${e.tags.join(',')}]` : ''
+          return `${e.id}  ${e.createdAt}  ${e.preview}${tagStr}`
+        })
+        return { success: true, output: out.join('\n') }
+      } catch (err) {
+        return { success: false, output: '', error: fmtErr(err) }
+      }
+    },
+  }
+}

package/src/tools/memory/save_memory.ts

@@ -0,0 +1,45 @@
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import { fmtErr } from '../errors.js'
+import type { Tool, ToolResult } from '../types.js'
+
+export function createSaveMemoryTool(cwd: string): Tool {
+  return {
+    definition: {
+      name: 'save_memory',
+      category: 'Memory',
+      group: 'Write',
+      description:
+        'Save a memory entry to .lonny/memory as a JSON file (content: string, tags?: string[])',
+      parameters: {
+        content: { type: 'string', description: 'Memory text', required: true },
+        tags: { type: 'array', description: 'Optional tags', required: false },
+      },
+    },
+    async execute(input): Promise<ToolResult> {
+      try {
+        const content = (input as any).content || input
+        const tags = (input as any).tags
+        if (typeof content !== 'string' || !content) {
+          return { success: false, output: '', error: 'content is required (string)' }
+        }
+        const id = String(Date.now()) + '-' + Math.random().toString(36).slice(2, 8)
+        const entry = {
+          id,
+          createdAt: new Date().toISOString(),
+          content,
+          tags: Array.isArray(tags) ? tags : undefined,
+        }
+        const dir = path.resolve(cwd, '.lonny', 'memory')
+        try {
+          fs.mkdirSync(dir, { recursive: true })
+        } catch {}
+        const file = path.join(dir, `${id}.json`)
+        fs.writeFileSync(file, JSON.stringify(entry, null, 2), 'utf-8')
+        return { success: true, output: `Saved memory ${id}` }
+      } catch (err) {
+        return { success: false, output: '', error: fmtErr(err) }
+      }
+    },
+  }
+}

package/src/tools/registry.ts

@@ -1,22 +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 { 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:
@@ -75,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
 }
 
@@ -93,14 +104,66 @@ export class ToolRegistry {
   private tools: Map<string, Tool> = new Map()
   private context: ToolContext
   private plugins: Map<string, ToolPlugin> = new Map()
+  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 {
+    // 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)
@@ -116,26 +179,43 @@ 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))
+      // 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))
     }
   }
 
-  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.registerBuiltins()
     } else if (mode === 'plan') {
@@ -199,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: {