morpheus-cli 0.2.7 → 0.3.1

package/dist/runtime/memory/sati/system-prompts.js

@@ -22,6 +22,7 @@ Classify any new memory into one of these types:
 - **professional_profile**: Job title, industry, skills.
 
 ### CRITICAL RULES
+0. **SAVE ON SUMMARY and REASONING IN ENGLISH AND NATIVE LANGUAGE**: Always generate a concise summary in English and, if the original information is in another language, also provide a summary in the original language. This ensures the memory is accessible and useful for future interactions, regardless of the language used.
 1. **NO SECRETS**: NEVER store API keys, passwords, credit cards, or private tokens. If found, ignore them explicitly.
 2. **NO DUPLICATES**: If the information is already covered by the \`existing_memory_summaries\`, DO NOT store it again.
 3. **NO CHIT-CHAT**: Do not store trivial conversation like "Hello", "Thanks", "How are you?".
@@ -31,12 +32,22 @@ Classify any new memory into one of these types:
 5. **OBEY THE USER**: If the user explicitly states something should be remembered, it must be stored with at least 'medium' importance.
 
 ### OUTPUT FORMAT
-You MUST respond with a valid JSON object matching the \`ISatiEvaluationOutput\` interface:
-{
-  "should_store": boolean,
-  "category": "category_name" | null,
-  "importance": "low" | "medium" | "high" | null,
-  "summary": "Concise factual statement" | null,
-  "reason": "Why you decided to store or not store"
-}
+You MUST respond with a valid JSON object ARRAY matching the \`ISatiEvaluationOutputArray\` interface:
+[
+  {
+    "should_store": boolean,
+    "category": "category_name" | null,
+    "importance": "low" | "medium" | "high" | null,
+    "summary": "Concise factual statement | Summary in native language" | null,
+    "reason": "Why you decided to store or not store | Reason in native language"
+  },
+  {
+    "should_store": boolean,
+    "category": "category_name" | null,
+    "importance": "low" | "medium" | "high" | null,
+    "summary": "Concise factual statement | Summary in native language" | null,
+    "reason": "Why you decided to store or not store | Reason in native language"
+  },
+]
+
 `;

package/dist/runtime/memory/session-embedding-worker.js

@@ -0,0 +1,94 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { homedir } from 'os';
+import loadVecExtension from './sqlite-vec.js';
+import { EmbeddingService } from './embedding.service.js';
+import { DisplayManager } from '../display.js';
+const SHORT_DB_PATH = path.join(homedir(), '.morpheus', 'memory', 'short-memory.db');
+const SATI_DB_PATH = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
+const EMBEDDING_DIM = 384;
+const BATCH_LIMIT = 5;
+export async function runSessionEmbeddingWorker() {
+    const display = DisplayManager.getInstance();
+    display.log('🚀 Iniciando worker de embeddings de sessões...', { source: 'SessionEmbeddingWorker' });
+    const shortDb = new Database(SHORT_DB_PATH);
+    const satiDb = new Database(SATI_DB_PATH);
+    shortDb.pragma('journal_mode = WAL');
+    satiDb.pragma('journal_mode = WAL');
+    // 🔥 importante: carregar vec0 no DB onde existe a tabela vetorial
+    loadVecExtension(satiDb);
+    const embeddingService = await EmbeddingService.getInstance();
+    while (true) {
+        const sessions = shortDb.prepare(`
+      SELECT id
+      FROM sessions
+      WHERE ended_at IS NOT NULL
+        AND embedding_status = 'pending'
+      LIMIT ?
+    `).all(BATCH_LIMIT);
+        if (sessions.length === 0) {
+            display.log('✅ Nenhuma sessão pendente.', { level: 'debug', source: 'SessionEmbeddingWorker' });
+            break;
+        }
+        for (const session of sessions) {
+            const sessionId = session.id;
+            display.log(`🧠 Processando sessão ${sessionId}...`, { source: 'SessionEmbeddingWorker' });
+            try {
+                // Skip setting 'processing' as it violates CHECK constraint
+                // active_processing.add(sessionId); // If we needed concurrency control
+                const chunks = satiDb.prepare(`
+          SELECT id, content
+          FROM session_chunks
+          WHERE session_id = ?
+          ORDER BY chunk_index
+        `).all(sessionId);
+                if (chunks.length === 0) {
+                    display.log(`⚠️ Sessão ${sessionId} não possui chunks.`, { source: 'SessionEmbeddingWorker' });
+                    shortDb.prepare(`
+            UPDATE sessions
+            SET embedding_status = 'embedded',
+                embedded = 1
+            WHERE id = ?
+          `).run(sessionId);
+                    continue;
+                }
+                const insertVec = satiDb.prepare(`
+          INSERT INTO session_vec (embedding)
+          VALUES (?)
+        `);
+                const insertMap = satiDb.prepare(`
+          INSERT OR REPLACE INTO session_embedding_map
+          (session_chunk_id, vec_rowid)
+          VALUES (?, ?)
+        `);
+                for (const chunk of chunks) {
+                    display.log(`   ↳ Embedding chunk ${chunk.id}`, { source: 'SessionEmbeddingWorker' });
+                    const embedding = await embeddingService.generate(chunk.content);
+                    if (!embedding || embedding.length !== EMBEDDING_DIM) {
+                        throw new Error(`Embedding inválido. Esperado ${EMBEDDING_DIM}, recebido ${embedding?.length}`);
+                    }
+                    const result = insertVec.run(new Float32Array(embedding));
+                    const vecRowId = result.lastInsertRowid;
+                    insertMap.run(chunk.id, vecRowId);
+                }
+                // ✅ finalizar sessão
+                shortDb.prepare(`
+          UPDATE sessions
+          SET embedding_status = 'embedded',
+              embedded = 1
+          WHERE id = ?
+        `).run(sessionId);
+                display.log(`✅ Sessão ${sessionId} embedada com sucesso.`, { source: 'SessionEmbeddingWorker' });
+            }
+            catch (err) {
+                display.log(`❌ Erro na sessão ${sessionId}: ${err}`, { source: 'SessionEmbeddingWorker' });
+                shortDb.prepare(`
+          UPDATE sessions
+          SET embedding_status = 'failed'
+          WHERE id = ?
+        `).run(sessionId);
+            }
+        }
+    }
+    display.log('🏁 Worker finalizado.', { source: 'SessionEmbeddingWorker' });
+}

package/dist/runtime/memory/sqlite-vec.js

@@ -0,0 +1,6 @@
+import * as sqliteVec from "sqlite-vec";
+export default function loadVecExtension(db) {
+    if (!db)
+        throw new Error("DB not initialized");
+    sqliteVec.load(db);
+}

package/dist/runtime/memory/sqlite.js

@@ -1,29 +1,38 @@
 import { BaseListChatMessageHistory } from "@langchain/core/chat_history";
 import { HumanMessage, AIMessage, SystemMessage, ToolMessage } from "@langchain/core/messages";
 import Database from "better-sqlite3";
-import * as fs from "fs-extra";
+import fs from "fs-extra";
 import * as path from "path";
 import { homedir } from "os";
+import { randomUUID } from 'crypto';
+import { DisplayManager } from "../display.js";
 export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
     lc_namespace = ["langchain", "stores", "message", "sqlite"];
+    display = DisplayManager.getInstance();
     db;
+    dbSati; // Optional separate DB for Sati memory, if needed in the future
     sessionId;
     limit;
     constructor(fields) {
         super();
-        this.sessionId = fields.sessionId;
+        this.sessionId = fields.sessionId && fields.sessionId !== '' ? fields.sessionId : '';
         this.limit = fields.limit ? fields.limit : 20;
         // Default path: ~/.morpheus/memory/short-memory.db
         const dbPath = fields.databasePath || path.join(homedir(), ".morpheus", "memory", "short-memory.db");
+        const dbSatiPath = path.join(homedir(), '.morpheus', 'memory', 'sati-memory.db');
         // Ensure the directory exists
         this.ensureDirectory(dbPath);
+        this.ensureDirectory(dbSatiPath);
         // Initialize database with retry logic for locked databases
         try {
             this.db = new Database(dbPath, {
                 ...fields.config,
                 timeout: 5000, // 5 second timeout for locks
             });
-            // Try to ensure table, if it fails due to corruption, backup and recreate
+            this.dbSati = new Database(dbSatiPath, {
+                ...fields.config,
+                timeout: 5000,
+            });
             try {
                 this.ensureTable();
             }
@@ -35,6 +44,16 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         catch (error) {
             throw new Error(`Failed to initialize SQLite database at ${dbPath}: ${error}`);
         }
+        this.initializeSession(); // Initialize session ID
+    }
+    /**
+     * Initializes the session ID after the database is ready.
+     * Must be called after the constructor completes.
+     */
+    async initializeSession() {
+        if (!this.sessionId || this.sessionId === '') {
+            this.sessionId = await this.getCurrentSessionOrCreate();
+        }
     }
     /**
      * Handles database corruption by backing up the corrupted file and creating a new one.
@@ -93,6 +112,20 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
         
         CREATE INDEX IF NOT EXISTS idx_messages_session_id 
         ON messages(session_id);
+
+        CREATE TABLE IF NOT EXISTS sessions (
+          id TEXT PRIMARY KEY,
+          title TEXT,
+          status TEXT CHECK (
+            status IN ('active', 'paused', 'archived', 'deleted')
+          ) NOT NULL DEFAULT 'paused',
+          started_at INTEGER NOT NULL,
+          ended_at INTEGER,
+          archived_at INTEGER,
+          deleted_at INTEGER,
+          embedding_status TEXT CHECK (embedding_status IN ('none', 'pending', 'embedded', 'failed')) NOT NULL DEFAULT 'none'
+        );
+
       `);
             this.migrateTable();
         }
@@ -105,6 +138,7 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
      */
     migrateTable() {
         try {
+            // Migrate messages table
             const tableInfo = this.db.pragma('table_info(messages)');
             const columns = new Set(tableInfo.map(c => c.name));
             const newColumns = [
@@ -282,6 +316,8 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             }
             const stmt = this.db.prepare("INSERT INTO messages (session_id, type, content, created_at, input_tokens, output_tokens, total_tokens, cache_read_tokens, provider, model) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
             stmt.run(this.sessionId, type, finalContent, Date.now(), inputTokens, outputTokens, totalTokens, cacheReadTokens, provider, model);
+            // Verificar se a sessão tem título e definir automaticamente se necessário
+            await this.setSessionTitleIfNeeded();
         }
         catch (error) {
             // Check for specific SQLite errors
@@ -299,6 +335,42 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to add message: ${error}`);
         }
     }
+    /**
+     * Verifies if the session has a title, and if not, sets it automatically
+     * using the first 50 characters of the oldest human message.
+     */
+    async setSessionTitleIfNeeded() {
+        // Verificar se a sessão já tem título
+        const session = this.db.prepare(`
+      SELECT title FROM sessions
+      WHERE id = ?
+    `).get(this.sessionId);
+        if (session && session.title) {
+            // A sessão já tem título, não precisa fazer nada
+            return;
+        }
+        // Obter a mensagem mais antiga do tipo "human" da sessão
+        const oldestHumanMessage = this.db.prepare(`
+      SELECT content
+      FROM messages
+      WHERE session_id = ? AND type = 'human'
+      ORDER BY created_at ASC
+      LIMIT 1
+    `).get(this.sessionId);
+        if (oldestHumanMessage) {
+            // Pegar os primeiros 50 caracteres como título
+            let title = oldestHumanMessage.content.substring(0, 50);
+            // Certificar-se de que o título não termine no meio de uma palavra
+            if (title.length === 50) {
+                const lastSpaceIndex = title.lastIndexOf(' ');
+                if (lastSpaceIndex > 0) {
+                    title = title.substring(0, lastSpaceIndex);
+                }
+            }
+            // Chamar a função renameSession para definir o título automaticamente
+            await this.renameSession(this.sessionId, title);
+        }
+    }
     /**
      * Retrieves aggregated usage statistics for all messages in the database.
      */
@@ -315,6 +387,26 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to get usage stats: ${error}`);
         }
     }
+    async getSessionStatus() {
+        try {
+            const stmt = this.db.prepare("SELECT embedding_status FROM sessions WHERE id = ?");
+            const row = stmt.get(this.sessionId);
+            //get messages where session_id = this.sessionId
+            const stmtMessages = this.db.prepare("SELECT COUNT(*) as messageCount FROM messages WHERE session_id = ?");
+            const msgRow = stmtMessages.get(this.sessionId);
+            if (row) {
+                return {
+                    id: this.sessionId,
+                    embedding_status: row.embedding_status,
+                    messageCount: msgRow.messageCount || 0,
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            throw new Error(`Failed to get session status: ${error}`);
+        }
+    }
     /**
      * Retrieves aggregated usage statistics grouped by provider and model.
      */
@@ -361,6 +453,343 @@ export class SQLiteChatMessageHistory extends BaseListChatMessageHistory {
             throw new Error(`Failed to clear messages: ${error}`);
         }
     }
+    /**
+     * Select the last session that time of no ended_at and return its ID, or create a new session if none found.
+     * This allows us to group messages into sessions for better organization and potential future features like session management.
+     */
+    async getSession() {
+        try {
+            // Try to find an active session
+            const selectStmt = this.db.prepare("SELECT id FROM sessions WHERE ended_at IS NULL AND status = 'active' ORDER BY started_at DESC LIMIT 1");
+            const row = selectStmt.get();
+            if (row) {
+                this.sessionId = row.id;
+            }
+            // If no active session, create a new one
+            if (!this.sessionId) {
+                const uuid = randomUUID();
+                this.sessionId = uuid;
+                const insertStmt = this.db.prepare("INSERT INTO sessions (id, started_at, status) VALUES (?, ?, 'active')");
+                const sessionCreated = insertStmt.run(this.sessionId, Date.now());
+                this.sessionId = sessionCreated.lastInsertRowid.toString();
+            }
+            const updateStmt = this.db.prepare("UPDATE messages SET session_id = ? WHERE session_id = 'default'");
+            updateStmt.run(this.sessionId);
+        }
+        catch (error) {
+            throw new Error(`Failed to get session: ${error}`);
+        }
+    }
+    async createNewSession() {
+        const now = Date.now();
+        // Transação para garantir consistência
+        const tx = this.db.transaction(() => {
+            // Pegar a sessão atualmente ativa
+            const activeSession = this.db.prepare(`
+        SELECT id FROM sessions
+        WHERE status = 'active'
+      `).get();
+            // Se houver uma sessão ativa, mudar seu status para 'paused'
+            if (activeSession) {
+                this.db.prepare(`
+          UPDATE sessions
+          SET status = 'paused'
+          WHERE id = ?
+        `).run(activeSession.id);
+            }
+            // Criar uma nova sessão ativa
+            const newId = randomUUID();
+            this.db.prepare(`
+        INSERT INTO sessions (
+          id,
+          started_at,
+          status
+        ) VALUES (?, ?, 'active')
+      `).run(newId, now);
+            // Atualizar o ID da sessão atual desta instância
+            this.sessionId = newId;
+        });
+        tx(); // Executar a transação
+        this.display.log('✅ Nova sessão iniciada e sessão anterior pausada', { source: 'Sati' });
+    }
+    /**
+     * Encerrar uma sessão e transformá-la em memória do Sati.
+     * Validar sessão existe e está em active ou paused.
+     * Marcar sessão como: status = 'archived', ended_at = now, archived_at = now, embedding_status = 'pending'.
+     * Exportar mensagens → texto e criar chunks (session_chunks).
+     * Remover mensagens da sessão após criar os chunks.
+     */
+    async archiveSession(sessionId) {
+        // Validar sessão existe e está em active ou paused
+        const session = this.db.prepare(`
+      SELECT id, status FROM sessions
+      WHERE id = ?
+    `).get(sessionId);
+        if (!session) {
+            throw new Error(`Sessão com ID ${sessionId} não encontrada.`);
+        }
+        if (session.status !== 'active' && session.status !== 'paused') {
+            throw new Error(`Sessão com ID ${sessionId} não está em estado ativo ou pausado. Status atual: ${session.status}`);
+        }
+        const now = Date.now();
+        // Transação para garantir consistência
+        const tx = this.db.transaction(() => {
+            // Marcar sessão como: status = 'archived', ended_at = now, archived_at = now, embedding_status = 'pending'
+            this.db.prepare(`
+        UPDATE sessions
+        SET status = 'archived',
+            ended_at = ?,
+            archived_at = ?,
+            embedding_status = 'pending'
+        WHERE id = ?
+      `).run(now, now, sessionId);
+            // Exportar mensagens → texto
+            const messages = this.db.prepare(`
+        SELECT type, content
+        FROM messages
+        WHERE session_id = ?
+        ORDER BY created_at ASC
+      `).all(sessionId);
+            if (messages.length > 0) {
+                const sessionText = messages
+                    .map(m => `[${m.type}] ${m.content}`)
+                    .join('\n\n');
+                // Criar chunks (session_chunks) usando dbSati
+                if (this.dbSati) {
+                    const chunks = this.chunkText(sessionText);
+                    for (let i = 0; i < chunks.length; i++) {
+                        this.dbSati.prepare(`
+              INSERT INTO session_chunks (
+                id,
+                session_id,
+                chunk_index,
+                content,
+                created_at
+              ) VALUES (?, ?, ?, ?, ?)
+            `).run(randomUUID(), sessionId, i, chunks[i], now);
+                    }
+                    this.display.log(`🧩 ${chunks.length} chunks criados para sessão ${sessionId}`, { source: 'Sati' });
+                }
+                // Remover mensagens da sessão após criar os chunks
+                this.db.prepare(`
+          DELETE FROM messages
+          WHERE session_id = ?
+        `).run(sessionId);
+            }
+        });
+        tx(); // Executar a transação
+    }
+    /**
+     * Descartar completamente uma sessão sem gerar memória.
+     * Validar sessão existe e status ≠ archived.
+     * Transação: deletar mensagens da sessão, marcar sessão como: status = 'deleted', deleted_at = now.
+     * Se a sessão era active, criar nova sessão ativa.
+     */
+    async deleteSession(sessionId) {
+        // Validar sessão existe
+        const session = this.db.prepare(`
+      SELECT id, status FROM sessions
+      WHERE id = ?
+    `).get(sessionId);
+        if (!session) {
+            throw new Error(`Sessão com ID ${sessionId} não encontrada.`);
+        }
+        // Validar status ≠ archived
+        if (session.status === 'archived') {
+            throw new Error(`Não é possível deletar uma sessão arquivada. Sessão ID: ${sessionId}`);
+        }
+        const now = Date.now();
+        // Transação: deletar mensagens da sessão, marcar sessão como: status = 'deleted', deleted_at = now
+        const tx = this.db.transaction(() => {
+            // Deletar mensagens da sessão
+            this.db.prepare(`
+        DELETE FROM messages
+        WHERE session_id = ?
+      `).run(sessionId);
+            // Marcar sessão como: status = 'deleted', deleted_at = now
+            this.db.prepare(`
+        UPDATE sessions
+        SET status = 'deleted',
+            deleted_at = ?
+        WHERE id = ?
+      `).run(now, sessionId);
+        });
+        tx(); // Executar a transação
+        // Se a sessão era active, verificar se há outra para ativar
+        if (session.status === 'active') {
+            const nextSession = this.db.prepare(`
+        SELECT id FROM sessions
+        WHERE status = 'paused'
+        ORDER BY started_at DESC
+        LIMIT 1
+      `).get();
+            if (nextSession) {
+                // Promover a próxima sessão a ativa
+                this.db.prepare(`
+          UPDATE sessions
+          SET status = 'active'
+          WHERE id = ?
+        `).run(nextSession.id);
+            }
+            else {
+                // Nenhuma outra sessão, criar nova
+                this.createFreshSession();
+            }
+        }
+    }
+    /**
+     * Renomear uma sessão ativa ou pausada.
+     * Validar sessão existe e status ∈ (paused, active).
+     * Atualizar o título da sessão.
+     */
+    async renameSession(sessionId, title) {
+        // Validar sessão existe e status ∈ (paused, active)
+        const session = this.db.prepare(`
+      SELECT id, status FROM sessions
+      WHERE id = ?
+    `).get(sessionId);
+        if (!session) {
+            throw new Error(`Sessão com ID ${sessionId} não encontrada.`);
+        }
+        if (session.status !== 'active' && session.status !== 'paused') {
+            throw new Error(`Sessão com ID ${sessionId} não está em estado ativo ou pausado. Status atual: ${session.status}`);
+        }
+        // Transação para garantir consistência
+        const tx = this.db.transaction(() => {
+            // Atualizar o título da sessão
+            this.db.prepare(`
+        UPDATE sessions
+        SET title = ?
+        WHERE id = ?
+      `).run(title, sessionId);
+        });
+        tx(); // Executar a transação
+    }
+    /**
+     * Trocar o contexto ativo entre sessões não finalizadas.
+     * Validar sessão alvo: existe e status ∈ (paused, active).
+     * Se já for active, não faz nada.
+     * Transação: sessão atual active → paused, sessão alvo → active.
+     */
+    async switchSession(targetSessionId) {
+        // Validar sessão alvo: existe e status ∈ (paused, active)
+        const targetSession = this.db.prepare(`
+      SELECT id, status FROM sessions
+      WHERE id = ?
+    `).get(targetSessionId);
+        if (!targetSession) {
+            throw new Error(`Sessão alvo com ID ${targetSessionId} não encontrada.`);
+        }
+        if (targetSession.status !== 'active' && targetSession.status !== 'paused') {
+            throw new Error(`Sessão alvo com ID ${targetSessionId} não está em estado ativo ou pausado. Status atual: ${targetSession.status}`);
+        }
+        // Se já for active, não faz nada
+        if (targetSession.status === 'active') {
+            return; // A sessão alvo já está ativa, não precisa fazer nada
+        }
+        // Transação: sessão atual active → paused, sessão alvo → active
+        const tx = this.db.transaction(() => {
+            // Pegar a sessão atualmente ativa
+            const currentActiveSession = this.db.prepare(`
+        SELECT id FROM sessions
+        WHERE status = 'active'
+      `).get();
+            // Se houver uma sessão ativa, mudar seu status para 'paused'
+            if (currentActiveSession) {
+                this.db.prepare(`
+          UPDATE sessions
+          SET status = 'paused'
+          WHERE id = ?
+        `).run(currentActiveSession.id);
+            }
+            // Mudar o status da sessão alvo para 'active'
+            this.db.prepare(`
+        UPDATE sessions
+        SET status = 'active'
+        WHERE id = ?
+      `).run(targetSessionId);
+        });
+        tx(); // Executar a transação
+    }
+    /**
+     * Garantir que sempre exista uma sessão ativa válida.
+     * Buscar sessão com status = 'active', retornar seu id se existir,
+     * ou criar nova sessão (createFreshSession) e retornar o novo id.
+     */
+    async getCurrentSessionOrCreate() {
+        // Buscar sessão com status = 'active'
+        const activeSession = this.db.prepare(`
+      SELECT id FROM sessions
+      WHERE status = 'active'
+    `).get();
+        if (activeSession) {
+            // Se existir, retornar seu id
+            return activeSession.id;
+        }
+        else {
+            // Se não existir, criar nova sessão (createFreshSession) e retornar o novo id
+            const newId = await this.createFreshSession();
+            return newId;
+        }
+    }
+    async createFreshSession() {
+        // Validar que não existe sessão 'active'
+        const activeSession = this.db.prepare(`
+      SELECT id FROM sessions
+      WHERE status = 'active'
+    `).get();
+        if (activeSession) {
+            throw new Error('Já existe uma sessão ativa. Não é possível criar uma nova sessão ativa.');
+        }
+        const now = Date.now();
+        const newId = randomUUID();
+        this.db.prepare(`
+    INSERT INTO sessions (
+      id,
+      started_at,
+      status
+    ) VALUES (?, ?, 'active')
+  `).run(newId, now);
+        return newId;
+    }
+    chunkText(text, chunkSize = 500, overlap = 50) {
+        if (!text || text.length === 0) {
+            return [];
+        }
+        const chunks = [];
+        let start = 0;
+        while (start < text.length) {
+            let end = start + chunkSize;
+            // Evita cortar no meio da palavra
+            if (end < text.length) {
+                const lastSpace = text.lastIndexOf(' ', end);
+                if (lastSpace > start) {
+                    end = lastSpace;
+                }
+            }
+            const chunk = text.slice(start, end).trim();
+            if (chunk.length > 0) {
+                chunks.push(chunk);
+            }
+            start = end - overlap;
+            if (start < 0)
+                start = 0;
+        }
+        return chunks;
+    }
+    /**
+     * Lists all active and paused sessions with their basic information.
+     * Returns an array of session objects containing id, title, status, and started_at.
+     */
+    async listSessions() {
+        const sessions = this.db.prepare(`
+      SELECT id, title, status, started_at
+      FROM sessions
+      WHERE status IN ('active', 'paused')
+      ORDER BY started_at DESC
+    `).all();
+        return sessions;
+    }
     /**
      * Closes the database connection.
      * Should be called when the history object is no longer needed.