lonny-agent 0.2.4 → 0.2.7

package/src/agent/session-persistence.ts

@@ -0,0 +1,146 @@
+import { createHash, randomUUID } from 'node:crypto'
+import * as fs from 'node:fs'
+import * as os from 'node:os'
+import * as path from 'node:path'
+import type { ToolCall, ToolResult } from '../tools/types.js'
+import type { LLMMessage } from './llm.js'
+
+// ── Types ────────────────────────────────────────────────────────────────────
+
+export interface SessionInfo {
+  id: string
+  cwd: string
+  title: string
+  messageCount: number
+  mode: 'code' | 'plan' | 'ask' | 'loop'
+  model: string
+  provider: string
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalApiCalls: number
+  createdAt: string
+  updatedAt: string
+  fileName: string
+}
+
+export interface SessionData {
+  id: string
+  cwd: string
+  title?: string
+  messages: LLMMessage[]
+  totalInputTokens: number
+  totalOutputTokens: number
+  totalApiCalls: number
+  totalCacheHitTokens?: number
+  totalCacheMissTokens?: number
+  mode: 'code' | 'plan' | 'ask' | 'loop'
+  model: string
+  provider: string
+  createdAt: string
+  updatedAt: string
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+export function generateId(): string {
+  return randomUUID().slice(0, 8)
+}
+
+export function getSessionDir(): string {
+  return path.join(os.homedir(), '.lonny', 'sessions')
+}
+
+export function getLogDir(): string {
+  return path.join(os.homedir(), '.lonny', 'log')
+}
+
+export function logToolError(tc: ToolCall, result: ToolResult, sessionId: string): void {
+  const logDir = getLogDir()
+  ensureDir(logDir)
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const fileName = `tool-error-${sessionId}-${timestamp}.json`
+  const logEntry = {
+    timestamp: new Date().toISOString(),
+    sessionId,
+    toolName: tc.name,
+    toolInput: tc.input,
+    error: result.error || '',
+  }
+  try {
+    fs.writeFileSync(path.join(logDir, fileName), JSON.stringify(logEntry, null, 2), 'utf-8')
+  } catch {
+    // Silently ignore log write failures
+  }
+}
+
+/** Base name for session files (safe directory name + hash) */
+export function getSessionBaseName(cwd: string): string {
+  const absPath = path.resolve(cwd)
+  const hash = createHash('sha256').update(absPath, 'utf-8').digest('hex').slice(0, 12)
+  const dirName = path.basename(absPath)
+  const safeName = dirName.replace(/[<>:"/\\|?*]/g, '_')
+  return `${safeName}-${hash}`
+}
+
+/**
+ * Get the file path for a session.
+ * If sessionId is provided, uses multi-session naming: {base}-{id}.json
+ * Otherwise returns the legacy single-session path: {base}.json
+ */
+export function getSessionFilePath(cwd: string, sessionId?: string): string {
+  const base = getSessionBaseName(cwd)
+  if (sessionId) {
+    return path.join(getSessionDir(), `${base}-${sessionId}.json`)
+  }
+  return path.join(getSessionDir(), `${base}.json`)
+}
+
+/** List all session files for a given cwd, sorted by updatedAt (most recent first). */
+export function getSessionFilesForCwd(cwd: string): { fileName: string; data: SessionData }[] {
+  const dir = getSessionDir()
+  const base = getSessionBaseName(cwd)
+  try {
+    if (!fs.existsSync(dir)) return []
+    const files = fs.readdirSync(dir).filter(f => f.endsWith('.json') && f.startsWith(base))
+    const results: { fileName: string; data: SessionData }[] = []
+    for (const fileName of files) {
+      try {
+        const raw = JSON.parse(fs.readFileSync(path.join(dir, fileName), 'utf-8')) as Record<
+          string,
+          unknown
+        >
+        results.push({ fileName, data: migrateSessionData(raw) })
+      } catch {
+        // Skip corrupted files
+      }
+    }
+    results.sort((a, b) => b.data.updatedAt.localeCompare(a.data.updatedAt))
+    return results
+  } catch {
+    return []
+  }
+}
+
+/** Find the legacy single-session file for a cwd (backward compatibility). */
+export function findLegacySessionFile(cwd: string): string | null {
+  const legacyPath = getSessionFilePath(cwd) // {base}.json (no sessionId)
+  if (fs.existsSync(legacyPath)) return legacyPath
+  return null
+}
+
+// Migrate old-format session files (without id) to new format
+export function migrateSessionData(data: Record<string, unknown>): SessionData {
+  if (!data.id) {
+    data.id = generateId()
+  }
+  if (!data.createdAt) {
+    data.createdAt = (data.updatedAt as string) || new Date().toISOString()
+  }
+  return data as unknown as SessionData
+}
+
+export function ensureDir(dir: string): void {
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true })
+  }
+}

package/src/agent/session-utils.ts

@@ -0,0 +1,54 @@
+import type { LLMMessage } from './llm.js'
+
+export function isTaskCompleteMessage(text: string): boolean {
+  if (!text) return false
+  const lower = text.toLowerCase()
+  const patterns = [
+    'task complete',
+    'task_complete',
+    'task is complete',
+    'all tasks complete',
+    '任务完成',
+    '任务已完成',
+    '全部完成',
+    '没有更多任务',
+    '无需继续',
+  ]
+  return patterns.some(p => lower.includes(p))
+}
+
+export function getContinuationMessage(messages: LLMMessage[]): string {
+  const firstUserMsg = messages.find(m => m.role === 'user')
+  const taskHint =
+    firstUserMsg && typeof firstUserMsg.content === 'string'
+      ? firstUserMsg.content.slice(0, 200)
+      : 'the original task'
+  return `[auto-continuation] The previous turn completed. Continue working on the original task: ${taskHint}
+
+If you believe the task is complete, call the task_complete tool with a summary of what was accomplished to end the session. Otherwise, continue with the next steps.`
+}
+
+export function sanitizeMessages(messages: LLMMessage[]): LLMMessage[] {
+  const sanitized: LLMMessage[] = []
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i]
+    if (msg.role === 'assistant' && msg.tool_calls && msg.tool_calls.length > 0) {
+      const pendingIds = new Set(msg.tool_calls.map(tc => tc.id))
+      let j = i + 1
+      while (j < messages.length && messages[j].role === 'tool' && pendingIds.size > 0) {
+        const toolMsg = messages[j]
+        if (toolMsg.tool_call_id && pendingIds.has(toolMsg.tool_call_id)) {
+          pendingIds.delete(toolMsg.tool_call_id)
+        }
+        j++
+      }
+      if (pendingIds.size > 0) {
+        const dropped = msg.tool_calls.map(tc => `${tc.name}(${tc.id})`).join(', ')
+        console.warn(`[session] Dropping assistant message with unfulfilled tool_calls: ${dropped}`)
+        continue
+      }
+    }
+    sanitized.push(msg)
+  }
+  return sanitized
+}