orquesta-cli 0.1.12

package/src/core/session/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Session module barrel export
+ */
+
+export * from './session-manager.js';

package/src/core/session/session-manager.ts

@@ -0,0 +1,464 @@
+/**
+ * Session Manager
+ *
+ * Save and restore conversation sessions to/from files
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { Message } from '../../types/index.js';
+import { configManager } from '../config/config-manager.js';
+import { PROJECTS_DIR } from '../../constants.js';
+import { initializeJsonStreamLogger } from '../../utils/json-stream-logger.js';
+import { logger } from '../../utils/logger.js';
+
+/**
+ * Session metadata interface
+ */
+export interface SessionMetadata {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  messageCount: number;
+  model: string;
+  endpoint: string;
+}
+
+/**
+ * Log entry for session restoration (matches PlanExecuteApp.tsx LogEntry)
+ */
+export interface SessionLogEntry {
+  id: string;
+  type: string;
+  content: string;
+  details?: string;
+  toolArgs?: Record<string, unknown>;
+  success?: boolean;
+  items?: string[];
+  diff?: string[];
+}
+
+/**
+ * TODO item for session restoration
+ */
+export interface SessionTodoItem {
+  id: string;
+  title: string;
+  description?: string;
+  status: 'pending' | 'in_progress' | 'completed' | 'failed';
+  result?: string;
+  error?: string;
+  requiresDocsSearch?: boolean;
+  dependencies?: string[];
+}
+
+/**
+ * Session data interface
+ */
+export interface SessionData {
+  metadata: SessionMetadata;
+  messages: Message[];
+  logEntries?: SessionLogEntry[];  // Optional for backward compatibility
+  todos?: SessionTodoItem[];       // Only in-progress todos are saved
+}
+
+/**
+ * Session summary interface (for list display)
+ */
+export interface SessionSummary {
+  id: string;
+  name: string;
+  createdAt: string;
+  updatedAt: string;
+  messageCount: number;
+  model: string;
+  firstMessage?: string;
+}
+
+/**
+ * Session Manager class
+ */
+export class SessionManager {
+  private currentSessionId: string | null = null;
+  private currentSessionCreatedAt: string | null = null;
+  private isSaving: boolean = false;
+
+  constructor() {
+    // Generate a new session ID for this runtime instance
+    this.currentSessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    this.currentSessionCreatedAt = new Date().toISOString();
+  }
+
+  /**
+   * Get project-specific sessions directory based on current working directory
+   */
+  private getSessionsDir(): string {
+    // Get current working directory and sanitize it for use in path
+    // Replace '/' with '-' and remove leading '-' if present (for absolute paths)
+    const cwd = process.cwd().replace(/\//g, '-').replace(/^-/, '');
+    return path.join(PROJECTS_DIR, cwd);
+  }
+
+  /**
+   * Normalize messages for saving: include tool_calls, tool_call_id, name fields
+   */
+  private normalizeMessages(messages: Message[]): Message[] {
+    return messages.map(msg => {
+      const normalized: Message = {
+        role: msg.role,
+        content: msg.content,
+      };
+      // Include tool_calls if present (assistant message)
+      if (msg.tool_calls && msg.tool_calls.length > 0) {
+        normalized.tool_calls = msg.tool_calls;
+      }
+      // Include tool_call_id if present (tool message)
+      if (msg.tool_call_id) {
+        normalized.tool_call_id = msg.tool_call_id;
+      }
+      // Include name if present (tool message)
+      if (msg.name) {
+        normalized.name = msg.name;
+      }
+      return normalized;
+    });
+  }
+
+  /**
+   * Validate tool messages: remove orphaned tool messages that have no matching tool_calls
+   * This fixes sessions saved before tool_calls were properly persisted
+   */
+  private validateToolMessages(messages: Message[]): Message[] {
+    // Collect all valid tool_call_ids from assistant messages with tool_calls
+    const validToolCallIds = new Set<string>();
+    for (const msg of messages) {
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          validToolCallIds.add(tc.id);
+        }
+      }
+    }
+
+    // Filter out tool messages with invalid tool_call_ids
+    const validated = messages.filter(msg => {
+      // Keep non-tool messages
+      if (msg.role !== 'tool') {
+        return true;
+      }
+      // For tool messages, check if tool_call_id exists and is valid
+      if (msg.tool_call_id && validToolCallIds.has(msg.tool_call_id)) {
+        return true;
+      }
+      // Remove orphaned tool messages
+      logger.warn('Removing orphaned tool message', { tool_call_id: msg.tool_call_id });
+      return false;
+    });
+
+    return validated;
+  }
+
+  /**
+   * Initialize session directory
+   */
+  async ensureSessionsDir(): Promise<void> {
+    const sessionsDir = this.getSessionsDir();
+    try {
+      await fs.access(sessionsDir);
+    } catch {
+      await fs.mkdir(sessionsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Save session
+   */
+  async saveSession(name: string, messages: Message[]): Promise<string> {
+    logger.enter('saveSession', { name, messageCount: messages.length });
+    await this.ensureSessionsDir();
+
+    // Generate session ID
+    const sessionId = `session-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+
+    // Get current model info
+    const endpoint = configManager.getCurrentEndpoint();
+    const model = configManager.getCurrentModel();
+
+    // Normalize messages (include tool_calls, tool_call_id)
+    const normalizedMessages = this.normalizeMessages(messages);
+
+    // Create session data
+    const sessionData: SessionData = {
+      metadata: {
+        id: sessionId,
+        name: name,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        messageCount: messages.length,
+        model: model?.id || 'unknown',
+        endpoint: endpoint?.baseUrl || 'unknown',
+      },
+      messages: normalizedMessages,
+    };
+
+    // Save to file
+    const sessionsDir = this.getSessionsDir();
+    const filePath = path.join(sessionsDir, `${sessionId}.json`);
+    await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), 'utf-8');
+
+    logger.exit('saveSession', { sessionId, filePath });
+    return sessionId;
+  }
+
+  /**
+   * Load session
+   */
+  async loadSession(sessionId: string): Promise<SessionData | null> {
+    logger.enter('loadSession', { sessionId });
+    await this.ensureSessionsDir();
+
+    const sessionsDir = this.getSessionsDir();
+    const filePath = path.join(sessionsDir, `${sessionId}.json`);
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      const sessionData = JSON.parse(content) as SessionData;
+
+      // Validate and clean messages: remove orphaned tool messages (tool_call_id without matching tool_calls)
+      const validatedMessages = this.validateToolMessages(sessionData.messages);
+      sessionData.messages = validatedMessages;
+      sessionData.metadata.messageCount = validatedMessages.length;
+
+      // Update updatedAt timestamp
+      sessionData.metadata.updatedAt = new Date().toISOString();
+      await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), 'utf-8');
+
+      // Set current session ID to loaded session (so future conversation is saved to this session)
+      this.currentSessionId = sessionData.metadata.id;
+      this.currentSessionCreatedAt = sessionData.metadata.createdAt;
+
+      // Reinitialize logger to use this session's log file (append mode)
+      await initializeJsonStreamLogger(sessionData.metadata.id, true);
+
+      logger.exit('loadSession', { sessionId, messageCount: sessionData.messages.length });
+      return sessionData;
+    } catch (error) {
+      logger.error('Failed to load session', { sessionId, error });
+      return null;
+    }
+  }
+
+  /**
+   * Get list of all sessions
+   */
+  async listSessions(): Promise<SessionSummary[]> {
+    logger.enter('listSessions', { sessionsDir: this.getSessionsDir() });
+    await this.ensureSessionsDir();
+
+    try {
+      const sessionsDir = this.getSessionsDir();
+      const files = await fs.readdir(sessionsDir);
+      // Filter to session files only (exclude _log.json, _error.json)
+      const sessionFiles = files.filter((f) =>
+        f.endsWith('.json') &&
+        !f.endsWith('_log.json') &&
+        !f.endsWith('_error.json')
+      );
+
+      const sessions: SessionSummary[] = [];
+
+      for (const file of sessionFiles) {
+        try {
+          const filePath = path.join(sessionsDir, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const sessionData = JSON.parse(content) as SessionData;
+
+          // Find first user message
+          const firstUserMessage = sessionData.messages.find((m) => m.role === 'user');
+
+          sessions.push({
+            id: sessionData.metadata.id,
+            name: sessionData.metadata.name,
+            createdAt: sessionData.metadata.createdAt,
+            updatedAt: sessionData.metadata.updatedAt,
+            messageCount: sessionData.metadata.messageCount,
+            model: sessionData.metadata.model,
+            firstMessage: firstUserMessage?.content?.substring(0, 50),
+          });
+        } catch (parseError) {
+          // Skip invalid session files
+          logger.warn(`Failed to parse session file ${file}:`, parseError);
+        }
+      }
+
+      // Sort by most recent update
+      sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+
+      logger.exit('listSessions', { sessionCount: sessions.length });
+      return sessions;
+    } catch (error) {
+      logger.error('Failed to list sessions', { error });
+      return [];
+    }
+  }
+
+  /**
+   * Delete session
+   */
+  async deleteSession(sessionId: string): Promise<boolean> {
+    logger.enter('deleteSession', { sessionId });
+    await this.ensureSessionsDir();
+
+    const sessionsDir = this.getSessionsDir();
+    const filePath = path.join(sessionsDir, `${sessionId}.json`);
+
+    try {
+      await fs.unlink(filePath);
+      logger.exit('deleteSession', { sessionId, success: true });
+      return true;
+    } catch (error) {
+      logger.error('Failed to delete session', { sessionId, error });
+      return false;
+    }
+  }
+
+  /**
+   * Find session by name
+   */
+  async findSessionByName(name: string): Promise<SessionSummary | null> {
+    const sessions = await this.listSessions();
+    return sessions.find((s) => s.name === name) || null;
+  }
+
+  /**
+   * Update session (add messages)
+   */
+  async updateSession(sessionId: string, messages: Message[]): Promise<boolean> {
+    logger.enter('updateSession', { sessionId, messageCount: messages.length });
+    await this.ensureSessionsDir();
+
+    const sessionData = await this.loadSession(sessionId);
+    if (!sessionData) {
+      logger.warn('Session not found for update', { sessionId });
+      return false;
+    }
+
+    // Normalize messages (include tool_calls, tool_call_id)
+    const normalizedMessages = this.normalizeMessages(messages);
+
+    sessionData.messages = normalizedMessages;
+    sessionData.metadata.messageCount = messages.length;
+    sessionData.metadata.updatedAt = new Date().toISOString();
+
+    const sessionsDir = this.getSessionsDir();
+    const filePath = path.join(sessionsDir, `${sessionId}.json`);
+    await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), 'utf-8');
+
+    logger.exit('updateSession', { sessionId, messageCount: messages.length });
+    return true;
+  }
+
+  // Current log entries for auto-save (set by UI)
+  private currentLogEntries: SessionLogEntry[] = [];
+  // Current todos for auto-save (set by UI)
+  private currentTodos: SessionTodoItem[] = [];
+
+  /**
+   * Set current log entries for auto-save
+   */
+  setLogEntries(logEntries: SessionLogEntry[]): void {
+    this.currentLogEntries = logEntries;
+  }
+
+  /**
+   * Set current todos for auto-save (only saves in-progress/pending todos)
+   */
+  setTodos(todos: SessionTodoItem[]): void {
+    // Only save todos that are not completed (pending or in_progress)
+    this.currentTodos = todos.filter(t => t.status === 'pending' || t.status === 'in_progress');
+  }
+
+  /**
+   * Auto-save current session (called whenever messages are added)
+   * Fire-and-forget async save (non-blocking)
+   */
+  autoSaveCurrentSession(messages: Message[], logEntries?: SessionLogEntry[]): void {
+    // Skip if already saving or no messages
+    if (this.isSaving || !this.currentSessionId || messages.length === 0) {
+      return;
+    }
+
+    // Update log entries if provided
+    if (logEntries) {
+      this.currentLogEntries = logEntries;
+    }
+
+    // Fire-and-forget: execute async save in background
+    this.performAutoSave(messages).catch((err: unknown) => {
+      // Silently log errors without blocking
+      const error = err as Error;
+      logger.warn('Auto-save failed:', { error: error.message || 'Unknown error' });
+    });
+  }
+
+  /**
+   * Perform actual save operation (internal method)
+   */
+  private async performAutoSave(messages: Message[]): Promise<void> {
+    this.isSaving = true;
+    logger.flow('Auto-saving session', { sessionId: this.currentSessionId, messageCount: messages.length });
+
+    try {
+      await this.ensureSessionsDir();
+
+      // Get current model info
+      const endpoint = configManager.getCurrentEndpoint();
+      const model = configManager.getCurrentModel();
+
+      // Normalize messages (include tool_calls, tool_call_id)
+      const normalizedMessages = this.normalizeMessages(messages);
+
+      // Create/update session data
+      const sessionData: SessionData = {
+        metadata: {
+          id: this.currentSessionId!,
+          name: `${this.currentSessionId}`,
+          createdAt: this.currentSessionCreatedAt || new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          messageCount: messages.length,
+          model: model?.id || 'unknown',
+          endpoint: endpoint?.baseUrl || 'unknown',
+        },
+        messages: normalizedMessages,
+        logEntries: this.currentLogEntries,  // Include log entries
+        todos: this.currentTodos.length > 0 ? this.currentTodos : undefined,  // Only include if there are pending/in-progress todos
+      };
+
+      // Save to file (overwrite)
+      const sessionsDir = this.getSessionsDir();
+      const filePath = path.join(sessionsDir, `${this.currentSessionId!}.json`);
+      await fs.writeFile(filePath, JSON.stringify(sessionData, null, 2), 'utf-8');
+    } finally {
+      this.isSaving = false;
+    }
+  }
+
+  /**
+   * Get current session ID
+   */
+  getCurrentSessionId(): string | null {
+    return this.currentSessionId;
+  }
+
+  /**
+   * Set current session ID
+   */
+  setCurrentSessionId(sessionId: string): void {
+    this.currentSessionId = sessionId;
+  }
+}
+
+/**
+ * SessionManager singleton instance
+ */
+export const sessionManager = new SessionManager();