lonny-agent 0.1.9 → 0.2.2

package/src/tools/registry.ts

@@ -1,265 +1,265 @@
-import type { FileReadTracker } from '../diff/apply.js'
-import { bashTool } from './bash.js'
-import { createEditTool } from './edit.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 type { Tool, ToolCall, ToolDefinition, ToolResult } from './types.js'
-import { createWritePlanTool } from './write_plan.js'
-
-/**
- * Normalize tool input to prevent common LLM call misuses.
- * The LLM sometimes passes parameters in the wrong format — this function
- * auto-corrects those patterns so tools work reliably.
- *
- * Common misuses handled:
- * 1. Passed as a string instead of { ... } object wrapper
- * 2. Passed top-level params directly instead of nested in the expected key
- * 3. Array passed directly (for tools that expect { items: [...] })
- */
-function normalizeToolInput(
-  toolName: string,
-  _definition: ToolDefinition,
-  input: Record<string, unknown>,
-): Record<string, unknown> {
-  // If input is a string (e.g. install_skill("package-name") or bash("ls -la"))
-  // wrap it into the appropriate key
-  if (typeof input === 'string') {
-    if (toolName === 'bash' || toolName === 'git') {
-      return { command: input }
-    }
-    if (
-      toolName === 'install_skill' ||
-      toolName === 'find' ||
-      toolName === 'glob' ||
-      toolName === 'grep'
-    ) {
-      return { pattern: input }
-    }
-    if (toolName === 'search' || toolName === 'fetch') {
-      return { query: input, url: input }
-    }
-    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) {
-      return { [params[0]]: input }
-    }
-    return input
-  }
-
-  // If input is an array (e.g. read called with ["file.ts"] directly)
-  if (Array.isArray(input)) {
-    if (toolName === 'read' || toolName === 'ls') {
-      return { paths: input, path: (input as string[])[0] }
-    }
-    if (toolName === 'edit') {
-      return { edits: input }
-    }
-    return input
-  }
-
-  // If edit tool gets an empty object, some models hallucinate the call
-  if (toolName === 'edit' && Object.keys(input).length === 0) {
-    return { edits: [] }
-  }
-
-  return input
-}
-
-export interface ToolContext {
-  cwd: string
-  autoApprove: boolean
-  applier: FileReadTracker
-  mode: 'code' | 'plan' | 'ask'
-  onPlanWritten?: (display: string) => void
-}
-
-export interface ToolPlugin {
-  name: string
-  description: string
-  create: (context: ToolContext) => Tool
-}
-
-/**
- * Extensible ToolRegistry with plugin support.
- * Inspired by pi's extension system for dynamic tool registration.
- */
-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
-
-  constructor(context: ToolContext) {
-    this.context = context
-    this.registerBuiltins()
-  }
-
-  /** Register all built-in tools */
-  private registerBuiltins(): void {
-    // ask mode: only fetch and search + exec (exec works with any toolset)
-    if (this.context.mode === 'ask') {
-      this.register(fetchTool)
-      this.register(searchTool)
-      return
-    }
-
-    this.register(createReadTool(this.context.applier, this.context.cwd))
-    this.register(globTool)
-    this.register(createGrepTool(this.context.cwd))
-    this.register(createLsTool(this.context.cwd))
-    this.register(createFindTool(this.context.cwd))
-    this.register(fetchTool)
-    this.register(searchTool)
-
-    if (this.context.mode === 'code') {
-      // Code 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()
-    } 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 {
-    // 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
-      this.tools.clear()
-      this.execTool = null
-      this.registerBuiltins()
-    } else if (mode === 'plan') {
-      // Keep existing tools but swap edit/write_plan, remove exec
-      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)
-    }
-  }
-
-  /** 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) */
-  registerPlugin(plugin: ToolPlugin): void {
-    this.plugins.set(plugin.name, plugin)
-    // Activate immediately
-    try {
-      const tool = plugin.create(this.context)
-      this.register(tool)
-    } catch (err) {
-      console.error(`Failed to activate plugin "${plugin.name}": ${err}`)
-    }
-  }
-
-  /** Unregister a tool by name */
-  unregister(name: string): boolean {
-    return this.tools.delete(name)
-  }
-
-  /** Check if a tool is registered */
-  has(name: string): boolean {
-    return this.tools.has(name)
-  }
-
-  /** Re-register write_plan tool with an updated callback */
-  reRegisterWritePlan(cwd: string, cb?: (display: string) => void): void {
-    this.tools.delete('write_plan')
-    this.tools.set('write_plan', createWritePlanTool(cwd, cb))
-  }
-
-  /** Partially update the context (used by session.onPlanWritten setter) */
-  updateContext(partial: Partial<ToolContext>): void {
-    Object.assign(this.context, partial)
-  }
-
-  /** List all registered tool names */
-  listTools(): string[] {
-    return Array.from(this.tools.keys())
-  }
-
-  getDefinitions(): ToolDefinition[] {
-    return Array.from(this.tools.values()).map(t => t.definition)
-  }
-
-  async dispatch(call: ToolCall): Promise<ToolResult> {
-    const tool = this.tools.get(call.name)
-    if (!tool) {
-      return {
-        success: false,
-        output: '',
-        error: `Unknown tool: "${call.name}". Available: ${Array.from(this.tools.keys()).join(', ')}`,
-      }
-    }
-
-    // ── Universal input normalization ──────────────────────────────────
-    // Auto-correct common LLM call misuses before they reach tool execute()
-    let input = call.input
-    try {
-      input = normalizeToolInput(call.name, tool.definition, input)
-    } catch {
-      // If normalization throws, let the tool handle it (or fail naturally)
-    }
-
-    try {
-      return await tool.execute(input)
-    } catch (err) {
-      return {
-        success: false,
-        output: '',
-        error: `Tool "${call.name}" threw: ${fmtErr(err)}`,
-      }
-    }
-  }
-}
+import type { FileReadTracker } from '../diff/apply.js'
+import { bashTool } from './bash.js'
+import { createEditTool } from './edit.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 type { Tool, ToolCall, ToolDefinition, ToolResult } from './types.js'
+import { createWritePlanTool } from './write_plan.js'
+
+/**
+ * Normalize tool input to prevent common LLM call misuses.
+ * The LLM sometimes passes parameters in the wrong format — this function
+ * auto-corrects those patterns so tools work reliably.
+ *
+ * Common misuses handled:
+ * 1. Passed as a string instead of { ... } object wrapper
+ * 2. Passed top-level params directly instead of nested in the expected key
+ * 3. Array passed directly (for tools that expect { items: [...] })
+ */
+function normalizeToolInput(
+  toolName: string,
+  _definition: ToolDefinition,
+  input: Record<string, unknown>,
+): Record<string, unknown> {
+  // If input is a string (e.g. install_skill("package-name") or bash("ls -la"))
+  // wrap it into the appropriate key
+  if (typeof input === 'string') {
+    if (toolName === 'bash' || toolName === 'git') {
+      return { command: input }
+    }
+    if (
+      toolName === 'install_skill' ||
+      toolName === 'find' ||
+      toolName === 'glob' ||
+      toolName === 'grep'
+    ) {
+      return { pattern: input }
+    }
+    if (toolName === 'search' || toolName === 'fetch') {
+      return { query: input, url: input }
+    }
+    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) {
+      return { [params[0]]: input }
+    }
+    return input
+  }
+
+  // If input is an array (e.g. read called with ["file.ts"] directly)
+  if (Array.isArray(input)) {
+    if (toolName === 'read' || toolName === 'ls') {
+      return { paths: input, path: (input as string[])[0] }
+    }
+    if (toolName === 'edit') {
+      return { edits: input }
+    }
+    return input
+  }
+
+  // If edit tool gets an empty object, some models hallucinate the call
+  if (toolName === 'edit' && Object.keys(input).length === 0) {
+    return { edits: [] }
+  }
+
+  return input
+}
+
+export interface ToolContext {
+  cwd: string
+  autoApprove: boolean
+  applier: FileReadTracker
+  mode: 'code' | 'plan' | 'ask'
+  onPlanWritten?: (display: string) => void
+}
+
+export interface ToolPlugin {
+  name: string
+  description: string
+  create: (context: ToolContext) => Tool
+}
+
+/**
+ * Extensible ToolRegistry with plugin support.
+ * Inspired by pi's extension system for dynamic tool registration.
+ */
+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
+
+  constructor(context: ToolContext) {
+    this.context = context
+    this.registerBuiltins()
+  }
+
+  /** Register all built-in tools */
+  private registerBuiltins(): void {
+    // ask mode: only fetch and search + exec (exec works with any toolset)
+    if (this.context.mode === 'ask') {
+      this.register(fetchTool)
+      this.register(searchTool)
+      return
+    }
+
+    this.register(createReadTool(this.context.applier, this.context.cwd))
+    this.register(globTool)
+    this.register(createGrepTool(this.context.cwd))
+    this.register(createLsTool(this.context.cwd))
+    this.register(createFindTool(this.context.cwd))
+    this.register(fetchTool)
+    this.register(searchTool)
+
+    if (this.context.mode === 'code') {
+      // Code 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()
+    } 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 {
+    // 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
+      this.tools.clear()
+      this.execTool = null
+      this.registerBuiltins()
+    } else if (mode === 'plan') {
+      // Keep existing tools but swap edit/write_plan, remove exec
+      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)
+    }
+  }
+
+  /** 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) */
+  registerPlugin(plugin: ToolPlugin): void {
+    this.plugins.set(plugin.name, plugin)
+    // Activate immediately
+    try {
+      const tool = plugin.create(this.context)
+      this.register(tool)
+    } catch (err) {
+      console.error(`Failed to activate plugin "${plugin.name}": ${err}`)
+    }
+  }
+
+  /** Unregister a tool by name */
+  unregister(name: string): boolean {
+    return this.tools.delete(name)
+  }
+
+  /** Check if a tool is registered */
+  has(name: string): boolean {
+    return this.tools.has(name)
+  }
+
+  /** Re-register write_plan tool with an updated callback */
+  reRegisterWritePlan(cwd: string, cb?: (display: string) => void): void {
+    this.tools.delete('write_plan')
+    this.tools.set('write_plan', createWritePlanTool(cwd, cb))
+  }
+
+  /** Partially update the context (used by session.onPlanWritten setter) */
+  updateContext(partial: Partial<ToolContext>): void {
+    Object.assign(this.context, partial)
+  }
+
+  /** List all registered tool names */
+  listTools(): string[] {
+    return Array.from(this.tools.keys())
+  }
+
+  getDefinitions(): ToolDefinition[] {
+    return Array.from(this.tools.values()).map(t => t.definition)
+  }
+
+  async dispatch(call: ToolCall): Promise<ToolResult> {
+    const tool = this.tools.get(call.name)
+    if (!tool) {
+      return {
+        success: false,
+        output: '',
+        error: `Unknown tool: "${call.name}". Available: ${Array.from(this.tools.keys()).join(', ')}`,
+      }
+    }
+
+    // ── Universal input normalization ──────────────────────────────────
+    // Auto-correct common LLM call misuses before they reach tool execute()
+    let input = call.input
+    try {
+      input = normalizeToolInput(call.name, tool.definition, input)
+    } catch {
+      // If normalization throws, let the tool handle it (or fail naturally)
+    }
+
+    try {
+      return await tool.execute(input)
+    } catch (err) {
+      return {
+        success: false,
+        output: '',
+        error: `Tool "${call.name}" threw: ${fmtErr(err)}`,
+      }
+    }
+  }
+}

package/src/tui/index.ts

@@ -39,6 +39,19 @@ import {
 } from './components.js'
 import { highlightLine } from './highlight.js'
 
+/**
+ * Invisible spacer that renders N empty lines.
+ * Used to reserve space at the bottom of the chat area so the editor
+ * overlay doesn't cover the last lines of command output.
+ */
+class Spacer {
+  constructor(private height: number) {}
+  render(_width: number): string[] {
+    return Array.from({ length: this.height }, () => '')
+  }
+  invalidate(): void {}
+}
+
 export async function startTui(config: Config): Promise<void> {
   let chatContent = ''
   let isRunning = false
@@ -95,7 +108,13 @@ export async function startTui(config: Config): Promise<void> {
     const filtered = data.replace(/\x1b\[\?1049[hl]/g, '')
     if (filtered) origWrite(filtered)
   }
-  const tui = new TUI(terminal, false)
+  // Show hardware cursor by default so IME (Chinese input method) can
+  // position its candidate window at the correct cursor location.
+  // The cursor is hidden during agent execution via setShowHardwareCursor(false).
+  // Note: on some terminals (Windows Terminal), showing the hardware cursor
+  // can interfere with editor rendering layout. If you see editor border gap,
+  // set this to false and use PI_HARDWARE_CURSOR=1 env var to enable.
+  const tui = new TUI(terminal, true)
   tui.setClearOnShrink(true)
   terminal.setTitle(`lonny ${config.model} ${config.provider}`)
 
@@ -106,6 +125,9 @@ export async function startTui(config: Config): Promise<void> {
   const chatMarkdown = new Markdown('', 1, 0, markdownTheme)
   const chatBox = new Box(1, 0)
   chatBox.addChild(chatMarkdown)
+  // Reserve space at the bottom so the editor overlay doesn't cover
+  // the last lines of command output. 13 = maxHeight(12) + offsetY(1).
+  chatBox.addChild(new Spacer(13))
 
   // Chat input — Editor with multi-line support, history, and autocomplete
   const slashCommands: SlashCommand[] = [

package/src/web/index.ts

@@ -4,7 +4,9 @@ import * as path from 'node:path'
 import * as url from 'node:url'
 import { type WebSocket, WebSocketServer } from 'ws'
 import { resetGlobalEventBus } from '../agent/event-bus.js'
+import { ensurePromptsDir, loadPromptTemplates } from '../agent/prompt-templates.js'
 import { Session, type SessionOutput } from '../agent/session.js'
+import { ensureSkillsDir, loadSkills } from '../agent/skills.js'
 import type { Config } from '../config/index.js'
 import { fmtErr } from '../tools/errors.js'
 import { fetchDeepSeekBalance, isDeepSeekOfficial } from '../tui/balance.js'
@@ -255,6 +257,70 @@ export async function startWebUi(config: Config, port: number): Promise<void> {
               return
             }
 
+            if (cmd === 'stop') {
+              sessionWithOutput.stop()
+              ws.send(JSON.stringify({ type: 'chunk', text: '\nStopped.\n' }))
+              ws.send(JSON.stringify({ type: 'done', reason: 'stop' }))
+              return
+            }
+
+            if (cmd === 'skills') {
+              const skills = loadSkills(config.cwd)
+              if (skills.length === 0) {
+                ws.send(
+                  JSON.stringify({
+                    type: 'chunk',
+                    text: 'No skills loaded. Create .md files in .lonny/skills/ or run install_superpowers.',
+                  }),
+                )
+              } else {
+                let msg = `Active Skills (${skills.length}):\n`
+                for (const s of skills) {
+                  msg += `  \u2022 ${s.name}`
+                  if (s.description) msg += ` - ${s.description}`
+                  msg += '\n'
+                }
+                ws.send(JSON.stringify({ type: 'chunk', text: msg }))
+              }
+              ws.send(JSON.stringify({ type: 'done', reason: 'stop' }))
+              return
+            }
+
+            if (cmd === 'prompts') {
+              const templates = loadPromptTemplates(config.cwd)
+              if (templates.length === 0) {
+                ws.send(
+                  JSON.stringify({
+                    type: 'chunk',
+                    text: 'No prompt templates found. Create .md files in .lonny/prompts/.',
+                  }),
+                )
+              } else {
+                let msg = `Prompt Templates (${templates.length}):\n`
+                for (const t of templates) {
+                  msg += `  \u2022 ${t.name}`
+                  if (t.description) msg += ` - ${t.description}`
+                  msg += '\n'
+                }
+                ws.send(JSON.stringify({ type: 'chunk', text: msg }))
+              }
+              ws.send(JSON.stringify({ type: 'done', reason: 'stop' }))
+              return
+            }
+
+            if (cmd === 'init') {
+              ensureSkillsDir(config.cwd)
+              ensurePromptsDir(config.cwd)
+              ws.send(
+                JSON.stringify({
+                  type: 'chunk',
+                  text: 'Initialized .lonny/skills/ and .lonny/prompts/.',
+                }),
+              )
+              ws.send(JSON.stringify({ type: 'done', reason: 'stop' }))
+              return
+            }
+
             if (cmd === 'help') {
               ws.send(
                 JSON.stringify({
@@ -263,6 +329,10 @@ export async function startWebUi(config: Config, port: number): Promise<void> {
                     '/mode code|plan|ask - Switch mode',
                     '/model <name> - Switch model',
                     '/new - Start a new session',
+                    '/stop - Stop the running agent',
+                    '/skills - List active skills',
+                    '/prompts - List prompt templates',
+                    '/init - Create .lonny/skills/ & prompts/',
                     '/help - Show this help',
                   ],
                 }),
@@ -344,6 +414,7 @@ export async function startWebUi(config: Config, port: number): Promise<void> {
         JSON.stringify({
           type: 'hello',
           version: 1,
+          cwd: config.cwd,
           mode: config.mode,
           model: config.model,
           provider: config.provider,