lonny-agent 0.1.2 → 0.1.9

package/src/pi-tui/word-navigation.ts

@@ -0,0 +1,127 @@
+import { getWordSegmenter, isWhitespaceChar, PUNCTUATION_REGEX } from './utils.js'
+
+const wordSegmenter = getWordSegmenter()
+
+/**
+ * Options for word navigation functions.
+ * When omitted, uses the default Intl.Segmenter word segmentation.
+ */
+export interface WordNavigationOptions {
+  /** Custom segmenter returning word segments for the given text. */
+  segment?: (text: string) => Iterable<Intl.SegmentData>
+  /** Predicate identifying atomic segments that should be treated as single units (e.g. paste markers). */
+  isAtomicSegment?: (segment: string) => boolean
+}
+
+/**
+ * Find the cursor position after moving one word backward from `cursor` in `text`.
+ * Skips trailing whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordBackward(
+  text: string,
+  cursor: number,
+  options?: WordNavigationOptions,
+): number {
+  if (cursor <= 0) return 0
+
+  const textBeforeCursor = text.slice(0, cursor)
+  const segmentFn = options?.segment
+  const isAtomic = options?.isAtomicSegment
+  const segments = segmentFn
+    ? [...segmentFn(textBeforeCursor)]
+    : [...wordSegmenter.segment(textBeforeCursor)]
+  let newCursor = cursor
+
+  // Skip trailing whitespace
+  while (
+    segments.length > 0 &&
+    !isAtomic?.(segments[segments.length - 1]?.segment || '') &&
+    isWhitespaceChar(segments[segments.length - 1]?.segment || '')
+  ) {
+    newCursor -= segments.pop()?.segment.length || 0
+  }
+
+  if (segments.length === 0) return newCursor
+
+  const last = segments[segments.length - 1]!
+
+  if (isAtomic?.(last.segment)) {
+    // Skip one atomic segment.
+    newCursor -= last.segment.length
+  } else if (last.isWordLike) {
+    // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+    const segment = last.segment
+    const matches = [...segment.matchAll(new RegExp(PUNCTUATION_REGEX, 'g'))]
+    if (matches.length <= 0) {
+      newCursor -= segment.length
+    } else {
+      const lastMatch = matches[matches.length - 1]!
+      newCursor -= segment.length - (lastMatch.index + lastMatch[0].length)
+    }
+  } else {
+    // Skip non-word non-whitespace run (punctuation)
+    while (
+      segments.length > 0 &&
+      !isAtomic?.(segments[segments.length - 1]?.segment || '') &&
+      !segments[segments.length - 1]?.isWordLike &&
+      !isWhitespaceChar(segments[segments.length - 1]?.segment || '')
+    ) {
+      newCursor -= segments.pop()?.segment.length || 0
+    }
+  }
+
+  return newCursor
+}
+
+/**
+ * Find the cursor position after moving one word forward from `cursor` in `text`.
+ * Skips leading whitespace, then stops at the next word/punctuation boundary.
+ *
+ * Pure function - does not mutate any state.
+ */
+export function findWordForward(
+  text: string,
+  cursor: number,
+  options?: WordNavigationOptions,
+): number {
+  if (cursor >= text.length) return text.length
+
+  const textAfterCursor = text.slice(cursor)
+  const segmentFn = options?.segment
+  const isAtomic = options?.isAtomicSegment
+  const segments = segmentFn ? segmentFn(textAfterCursor) : wordSegmenter.segment(textAfterCursor)
+  const iterator = segments[Symbol.iterator]()
+  let next = iterator.next()
+  let newCursor = cursor
+
+  // Skip leading whitespace
+  while (!next.done && !isAtomic?.(next.value.segment) && isWhitespaceChar(next.value.segment)) {
+    newCursor += next.value.segment.length
+    next = iterator.next()
+  }
+
+  if (next.done) return newCursor
+
+  if (isAtomic?.(next.value.segment)) {
+    // Skip one atomic segment.
+    newCursor += next.value.segment.length
+  } else if (next.value.isWordLike) {
+    // Skip inside one word-like segment, preserving ASCII punctuation boundaries.
+    newCursor += PUNCTUATION_REGEX.exec(next.value.segment)?.index ?? next.value.segment.length
+  } else {
+    // Skip non-word non-whitespace run (punctuation)
+    while (
+      !next.done &&
+      !isAtomic?.(next.value.segment) &&
+      !next.value.isWordLike &&
+      !isWhitespaceChar(next.value.segment)
+    ) {
+      newCursor += next.value.segment.length
+      next = iterator.next()
+    }
+  }
+
+  return newCursor
+}

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

@@ -155,6 +155,97 @@ describe('edit tool', () => {
     })
   })
 
+  describe('diff output', () => {
+    beforeAll(() => {
+      fs.writeFileSync(path.join(tmpDir, 'diff-test.txt'), 'line one\nline two\nline three\n')
+    })
+
+    it('shows green + for new file creation (no red - lines)', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'diff-new.txt', old_string: '', new_string: 'hello\nworld' }],
+      })
+      expect(r.success).toBe(true)
+      // Should contain green ANSI code for added lines
+      expect(r.output).toContain('\x1b[38;2;0;200;100m') // green
+      expect(r.output).toContain('+ hello')
+      expect(r.output).toContain('+ world')
+      // Should NOT contain red ANSI code (no removed lines)
+      expect(r.output).not.toContain('\x1b[38;2;255;80;80m')
+      expect(r.output).toContain('Created')
+    })
+
+    it('shows red - for removed lines and green + for added lines on replacement', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'diff-test.txt',
+            old_string: 'line two',
+            new_string: 'line TWO',
+          },
+        ],
+      })
+      expect(r.success).toBe(true)
+      // Should contain red ANSI code for removed content
+      expect(r.output).toContain('\x1b[38;2;255;80;80m')
+      expect(r.output).toContain('- line two')
+      // Should contain green ANSI code for added content
+      expect(r.output).toContain('\x1b[38;2;0;200;100m')
+      expect(r.output).toContain('+ line TWO')
+      expect(r.output).toContain('Edited')
+    })
+
+    it('shows multi-line diff correctly', async () => {
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'diff-test.txt',
+            old_string: 'line one\nline TWO',
+            new_string: 'line 1\nline 2',
+          },
+        ],
+      })
+      expect(r.success).toBe(true)
+      // Removed lines
+      expect(r.output).toContain('- line one')
+      expect(r.output).toContain('- line TWO')
+      // Added lines
+      expect(r.output).toContain('+ line 1')
+      expect(r.output).toContain('+ line 2')
+    })
+
+    it('handles CRLF in old_string (Windows compatibility)', async () => {
+      fs.writeFileSync(path.join(tmpDir, 'crlf-test.txt'), 'a\\r\\nb\\r\\nc\\r\\n')
+      const r = await tool().execute({
+        edits: [
+          {
+            file_path: 'crlf-test.txt',
+            // Simulate AI sending old_string with \\r\\n (CRLF) on Windows
+            old_string: 'b\\r\\n',
+            new_string: 'B\\r\\n',
+          },
+        ],
+      })
+      expect(r.success).toBe(true)
+      const content = fs.readFileSync(path.join(tmpDir, 'crlf-test.txt'), 'utf8')
+      expect(content).toContain('B')
+      // Should show the normalized diff (with \\n, not \\r\\n)
+      expect(r.output).toContain('- b')
+      expect(r.output).toContain('+ B')
+    })
+
+    it('does not show empty red line when old_string is empty', async () => {
+      const r = await tool().execute({
+        edits: [{ file_path: 'empty-old.txt', old_string: '', new_string: 'only added' }],
+      })
+      expect(r.success).toBe(true)
+      // Should have green + lines
+      expect(r.output).toContain('+ only added')
+      // Count red-start markers — should be 0 (no removed content)
+      const redCount = (r.output.match(/\x1b\[38;2;255;80;80m/g) || []).length
+      expect(redCount).toBe(0)
+    })
+  })
+
   describe('create mode', () => {
     const createdDir = () => path.join(tmpDir, 'created-test')
 

package/src/tools/edit.ts

@@ -4,6 +4,24 @@ import type { FileReadTracker } from '../diff/apply.js'
 import { fmtErr } from './errors.js'
 import type { Tool, ToolResult } from './types.js'
 
+// ── ANSI colors for diff output ─────────────────────────────────────────
+const DIFF_RED = '\x1b[38;2;255;80;80m'
+const DIFF_GREEN = '\x1b[38;2;0;200;100m'
+const DIFF_RESET = '\x1b[0m'
+
+function generateDiff(oldStr: string, newStr: string): string {
+  const oldLines = oldStr === '' ? [] : oldStr.split('\n')
+  const newLines = newStr.split('\n')
+  const lines: string[] = []
+  for (const line of oldLines) {
+    lines.push(`  ${DIFF_RED}- ${line}${DIFF_RESET}`)
+  }
+  for (const line of newLines) {
+    lines.push(`  ${DIFF_GREEN}+ ${line}${DIFF_RESET}`)
+  }
+  return lines.join('\n')
+}
+
 interface SingleEdit {
   file_path: string
   old_string: string
@@ -155,6 +173,9 @@ EXAMPLES:
 
         for (let i = group.edits.length - 1; i >= 0; i--) {
           const e = group.edits[i]
+          // Normalize CRLF → LF in AI-provided strings (critical on Windows)
+          e.old_string = e.old_string.replace(/\r\n/g, '\n')
+          e.new_string = e.new_string.replace(/\r\n/g, '\n')
 
           if (e.old_string === '') {
             if (content !== null) {
@@ -170,8 +191,11 @@ EXAMPLES:
               }
               break
             }
+            const newLines = e.new_string.split('\n').length
             content = e.new_string
-            results.push(`  Created ${relPath} (${e.new_string.split('\n').length} lines)`)
+            results.push(
+              `  Created ${relPath} (${newLines} lines):\n${generateDiff('', e.new_string)}`,
+            )
             continue
           }
 
@@ -218,6 +242,8 @@ EXAMPLES:
             break
           }
 
+          const diff = generateDiff(e.old_string, e.new_string)
+          results.push(`  Edited ${relPath}:\n${diff}`)
           content = content.slice(0, idx) + e.new_string + content.slice(idx + e.old_string.length)
         }
 

package/src/tui/components.ts

@@ -1,7 +1,7 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
-import type { Component, SelectItem, SelectListTheme } from '@earendil-works/pi-tui'
-import { SelectList } from '@earendil-works/pi-tui'
+import type { Component, SelectItem, SelectListTheme } from '../pi-tui/index.js'
+import { SelectList } from '../pi-tui/index.js'
 import { PLAN_DIR } from '../tools/write_plan.js'
 import { visibleLen } from './utils.js'
 

package/src/tui/index.ts

@@ -1,5 +1,11 @@
 import * as fs from 'node:fs'
 import * as path from 'node:path'
+import { resetGlobalEventBus } from '../agent/event-bus.js'
+import { ensurePromptsDir, loadPromptTemplates } from '../agent/prompt-templates.js'
+import { formatToolInput, Session, type SessionOutput } from '../agent/session.js'
+import { ensureSkillsDir, loadSkills } from '../agent/skills.js'
+import type { Config } from '../config/index.js'
+import { loadTokenUsage, resetTokenUsage } from '../config/tokens.js'
 import type {
   EditorTheme,
   MarkdownTheme,
@@ -7,7 +13,7 @@ import type {
   SelectItem,
   SelectListTheme,
   SlashCommand,
-} from '@earendil-works/pi-tui'
+} from '../pi-tui/index.js'
 import {
   Box,
   CombinedAutocompleteProvider,
@@ -18,13 +24,7 @@ import {
   ProcessTerminal,
   Text,
   TUI,
-} from '@earendil-works/pi-tui'
-import { resetGlobalEventBus } from '../agent/event-bus.js'
-import { ensurePromptsDir, loadPromptTemplates } from '../agent/prompt-templates.js'
-import { formatToolInput, Session, type SessionOutput } from '../agent/session.js'
-import { ensureSkillsDir, loadSkills } from '../agent/skills.js'
-import type { Config } from '../config/index.js'
-import { loadTokenUsage, resetTokenUsage } from '../config/tokens.js'
+} from '../pi-tui/index.js'
 import { fmtErr } from '../tools/errors.js'
 import { fetchDeepSeekBalance, isDeepSeekOfficial } from './balance.js'
 import {
@@ -38,6 +38,7 @@ import {
   TodoPanel,
 } from './components.js'
 import { highlightLine } from './highlight.js'
+
 export async function startTui(config: Config): Promise<void> {
   let chatContent = ''
   let isRunning = false
@@ -293,7 +294,7 @@ export async function startTui(config: Config): Promise<void> {
       anchor: 'bottom-left',
       width: terminal.columns ?? process.stdout.columns ?? 120,
       offsetY: -1,
-      maxHeight: 6,
+      maxHeight: 12,
       nonCapturing: false,
     })
     showTodoPanel()
@@ -482,6 +483,15 @@ export async function startTui(config: Config): Promise<void> {
       }
 
       if (cmd === 'new') {
+        // If the agent is running, stop the old session gracefully first.
+        // Without this, the pending chat() promise would continue consuming
+        // tokens and write stale output into the freshly cleared chat display.
+        if (isRunning) {
+          session.stop()
+          isRunning = false
+          loader.setMessage('')
+          tui.setShowHardwareCursor(true)
+        }
         Session.clearSavedSession(config.cwd)
         resetTokenUsage(config.cwd)
         resetGlobalEventBus()
@@ -490,6 +500,10 @@ export async function startTui(config: Config): Promise<void> {
         chatContent = ''
         chatMarkdown.setText('')
         plansList.clearFilter()
+        // Reset editor internal state that setText('') doesn't clear
+        ;(editor as any).undoStack.clear()
+        ;(editor as any).history = []
+        ;(editor as any).killRing.ring = []
         updateFooter()
         return
       }
@@ -652,7 +666,7 @@ export async function startTui(config: Config): Promise<void> {
       anchor: 'bottom-left',
       width: terminal.columns ?? process.stdout.columns ?? 120,
       offsetY: -1,
-      maxHeight: 6,
+      maxHeight: 12,
       nonCapturing: false,
     })
 

package/src/web/index.ts

@@ -357,8 +357,15 @@ export async function startWebUi(config: Config, port: number): Promise<void> {
       sendPlanData()
     })()
 
-    // Send full session history (exclude system prompt)
-    const historyMessages = sessionWithOutput.messages.filter(m => m.role !== 'system')
+    // Send full session history (exclude system prompt, strip ANSI from tool results)
+    const historyMessages = sessionWithOutput.messages
+      .filter(m => m.role !== 'system')
+      .map(m => {
+        if (m.role === 'tool' && typeof m.content === 'string') {
+          return { ...m, content: stripAnsi(m.content) }
+        }
+        return m
+      })
     if (historyMessages.length > 0) {
       ws.send(
         JSON.stringify({

package/src/web/public/app.js

@@ -257,8 +257,21 @@
     const div = document.createElement('div')
     div.className = id ? 'tool-call executing' : 'tool-call'
     div.dataset.toolId = id || ''
-    const inputStr = typeof input === 'object' ? JSON.stringify(input).slice(0, 120) : String(input)
-    div.innerHTML = `<span class="tool-name">${escapeHtml(name)}</span> <span class="tool-input">${escapeHtml(inputStr)}</span>`
+
+    if (name === 'edit') {
+      // Special display for edit tool: show file paths being edited
+      const edits = input && input.edits
+      const paths = Array.isArray(edits) ? edits.map(e => e.file_path).filter(Boolean) : []
+      const uniquePaths = [...new Set(paths)]
+      const pathsStr =
+        uniquePaths.length > 0 ? uniquePaths.map(p => escapeHtml(p)).join(', ') : '(no files)'
+      div.innerHTML = `<span class="tool-name tool-name-edit">✏ edit</span> <span class="tool-input tool-input-edit">${pathsStr}</span>`
+    } else {
+      const inputStr =
+        typeof input === 'object' ? JSON.stringify(input).slice(0, 120) : String(input)
+      div.innerHTML = `<span class="tool-name">${escapeHtml(name)}</span> <span class="tool-input">${escapeHtml(inputStr)}</span>`
+    }
+
     if (container && container.matches('.message')) {
       container.appendChild(div)
     } else {
@@ -268,6 +281,21 @@
     scrollToBottom()
   }
 
+  function renderDiffContent(text) {
+    const lines = text.split('\n')
+    return lines
+      .map(line => {
+        const trimmed = line.trim()
+        if (trimmed.startsWith('+ ')) {
+          return `<span class="diff-added">${escapeHtml(line)}\n</span>`
+        } else if (trimmed.startsWith('- ')) {
+          return `<span class="diff-removed">${escapeHtml(line)}\n</span>`
+        }
+        return escapeHtml(line) + '\n'
+      })
+      .join('')
+  }
+
   function addToolResult(name, success, outputOrError, id) {
     // Remove from pending tracking and clear executing state
     if (id) {
@@ -275,6 +303,10 @@
       if (pendingEl) {
         pendingEl.classList.remove('executing')
         pendingToolCalls.delete(id)
+        // For edit tool, update the tool-call element to show completion summary
+        if (name === 'edit' && success) {
+          pendingEl.classList.add('completed')
+        }
       }
     }
     const container = streamingMsgEl || messagesEl.querySelector('.message:last-child')
@@ -283,8 +315,37 @@
     if (success) {
       let display = outputOrError
       if (display === '(no output)') display = ''
-      const summary = typeof display === 'string' ? display.slice(0, 80) : ''
-      div.innerHTML = `<span class="tool-result-success">✔ ${escapeHtml(name)}</span>${summary ? ' ' + escapeHtml(summary) : ''}`
+      // Special display for edit tool success — show rich diff content
+      if (name === 'edit' && display) {
+        const lines = display.split('\n')
+        const summaryLines = []
+        const diffLines = []
+        for (const line of lines) {
+          const trimmed = line.trim()
+          if (
+            trimmed.startsWith('Edited ') ||
+            trimmed.startsWith('Created ') ||
+            trimmed.startsWith('Deleted ')
+          ) {
+            summaryLines.push(trimmed)
+          } else if (trimmed.startsWith('- ') || trimmed.startsWith('+ ')) {
+            diffLines.push(line)
+          }
+        }
+        let html = `<span class="tool-result-success">✔ ${escapeHtml(name)}</span>`
+        if (summaryLines.length > 0) {
+          html += `<span class="tool-result-summary">${summaryLines.map(s => escapeHtml(s)).join('<br>')}</span>`
+        }
+        if (diffLines.length > 0) {
+          html += `<span class="tool-result-diff"><pre><code>${renderDiffContent(diffLines.join('\n'))}</code></pre></span>`
+        } else if (display.includes(' FAIL ')) {
+          html += `<span class="tool-result-diff"><pre>${escapeHtml(display)}</pre></span>`
+        }
+        div.innerHTML = html
+      } else {
+        const summary = typeof display === 'string' ? display.slice(0, 80) : ''
+        div.innerHTML = `<span class="tool-result-success">✔ ${escapeHtml(name)}</span>${summary ? ' ' + escapeHtml(summary) : ''}`
+      }
     } else {
       div.innerHTML = `<span class="tool-result-error">✖ ${escapeHtml(name)}</span> ${escapeHtml(outputOrError)}`
     }

package/src/web/public/style.css

@@ -347,10 +347,59 @@ body {
 }
 
 .tool-call .tool-name { color: var(--accent-dim); }
+.tool-call .tool-name.tool-name-edit { color: var(--warning); }
 .tool-call .tool-input { color: var(--text-dim); }
+.tool-call .tool-input.tool-input-edit { font-family: var(--font-mono); font-size: 0.85em; }
+.tool-call.completed { opacity: 0.6; }
+.tool-call.completed .tool-name::before { display: none; }
 
 .tool-result .tool-result-success { color: var(--success); }
 .tool-result .tool-result-error { color: var(--error); }
+.tool-result .tool-result-summary {
+  display: block;
+  color: var(--text-secondary);
+  font-size: 0.85em;
+  margin-top: 2px;
+  line-height: 1.3;
+}
+
+/* ── Edit Diff Display ─────────────────────────────────────────── */
+.tool-result .tool-result-diff {
+  display: block;
+  margin-top: 2px;
+}
+
+.tool-result .tool-result-diff pre {
+  max-height: 300px;
+  max-width: 100%;
+  overflow-y: auto;
+  overflow-x: auto;
+  background: var(--input-bg);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  padding: 8px 12px;
+  margin: 4px 0;
+  font-size: 12px;
+  line-height: 1.4;
+  white-space: pre;
+  word-break: break-all;
+}
+
+.tool-result .tool-result-diff code {
+  font-family: var(--font-mono);
+  font-size: inherit;
+  color: inherit;
+  background: none;
+  padding: 0;
+}
+
+.tool-result .diff-added {
+  color: var(--success);
+}
+
+.tool-result .diff-removed {
+  color: var(--error);
+}
 
 /* ── Thinking Block ──────────────────────────────────────────── */
 .thinking-block {

package/src/web/session-bridge.ts

@@ -7,6 +7,11 @@ import type { Config } from '../config/index.js'
  * Listens to EventBus events and forwards them as JSON messages.
  */
 
+/** Strip ANSI escape codes from a string (terminal colors are meaningless in the browser) */
+function stripAnsi(text: string): string {
+  return text.replace(/\x1b\[[0-9;]*m/g, '')
+}
+
 export interface WsMessage {
   type: string
   [key: string]: unknown
@@ -49,12 +54,18 @@ export function startSessionBridge(
 
   const unsubToolResult = bus.on(EventChannels.TOOL_RESULT, data => {
     const d = data as { name: string; id: string; output: string }
-    send({ type: 'tool_result', name: d.name, id: d.id, success: true, output: d.output })
+    send({
+      type: 'tool_result',
+      name: d.name,
+      id: d.id,
+      success: true,
+      output: stripAnsi(d.output),
+    })
   })
 
   const unsubToolError = bus.on(EventChannels.TOOL_ERROR, data => {
     const d = data as { name: string; id: string; error: string }
-    send({ type: 'tool_result', name: d.name, id: d.id, success: false, error: d.error })
+    send({ type: 'tool_result', name: d.name, id: d.id, success: false, error: stripAnsi(d.error) })
   })
 
   const unsubTurnEnd = bus.on(EventChannels.TURN_END, data => {

package/tsconfig.json

@@ -1,9 +1,9 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
+    "target": "ES2024",
     "module": "ESNext",
     "moduleResolution": "bundler",
-    "lib": ["ES2022"],
+    "lib": ["ES2024"],
     "outDir": "dist",
     "rootDir": "src",
     "strict": true,