@exreve/exk 1.0.74 → 1.0.76

package/dist/cli/agentSession.js

@@ -588,23 +588,43 @@ export class AgentSessionManager {
                         finalPrompt = `${skillContent}\n\n${effectivePrompt}`;
                     }
                 }
-                // Inject DB history if context was lost in a previous prompt (resume failed)
+                // Inject compacted summary or raw DB history if context was lost
                 if (session.contextLost) {
-                    console.log(`[agentSession] Context was lost previously, fetching DB history for session ${sessionId}`);
-                    try {
-                        const history = await this.fetchSessionHistory(sessionId);
-                        if (history.length > 0) {
-                            const historyPrefix = this.formatHistoryForPrompt(history);
-                            finalPrompt = historyPrefix + finalPrompt;
-                            console.log(`[agentSession] Injected ${history.length} history entries into prompt for session ${sessionId}`);
+                    if (session.compactionSummary) {
+                        // Use AI-generated summary from compaction
+                        console.log(`[agentSession] Injecting AI compaction summary for session ${sessionId}`);
+                        const summaryPrefix = [
+                            '[Compacted Session Context]',
+                            'The following is an AI-generated summary of the previous conversation in this session.',
+                            'Use it as context to continue where you left off.',
+                            '',
+                            session.compactionSummary,
+                            '',
+                            '[End of Compacted Context]',
+                            '',
+                            '',
+                        ].join('\n');
+                        finalPrompt = summaryPrefix + finalPrompt;
+                        session.compactionSummary = undefined; // Only inject once
+                    }
+                    else {
+                        // Fallback: inject raw DB history
+                        console.log(`[agentSession] No compaction summary, fetching DB history for session ${sessionId}`);
+                        try {
+                            const history = await this.fetchSessionHistory(sessionId);
+                            if (history.length > 0) {
+                                const historyPrefix = this.formatHistoryForPrompt(history);
+                                finalPrompt = historyPrefix + finalPrompt;
+                                console.log(`[agentSession] Injected ${history.length} history entries into prompt for session ${sessionId}`);
+                            }
+                            else {
+                                console.log(`[agentSession] No DB history available for session ${sessionId}`);
+                            }
                         }
-                        else {
-                            console.log(`[agentSession] No DB history available for session ${sessionId}`);
+                        catch (err) {
+                            console.error(`[agentSession] Failed to fetch/format history:`, err);
                         }
                     }
-                    catch (err) {
-                        console.error(`[agentSession] Failed to fetch/format history:`, err);
-                    }
                     session.contextLost = false; // Reset after injection attempt
                 }
                 // Add user message to history
@@ -1087,6 +1107,130 @@ export class AgentSessionManager {
             session.claudeProcessGroupId = undefined;
         }
     }
+    /**
+     * AI-powered session compaction.
+     *
+     * 1. Fetches full conversation history from the backend DB
+     * 2. Writes it to a temp file
+     * 3. Spawns a real prompt asking the model to summarize the conversation
+     * 4. Captures the model's summary
+     * 5. Clears the SDK session and stores the summary for injection on next prompt
+     *
+     * Returns true if the compaction prompt was queued successfully.
+     * The `onCompactionComplete` callback fires when the model finishes summarizing.
+     */
+    async compactSession(sessionId, projectPath, onOutput, onCompactionComplete) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        // Don't compact while a prompt is actively running
+        if (session.isProcessingQueue && session.activeBackendStream)
+            return false;
+        // 1. Fetch conversation history from DB
+        const history = await this.fetchSessionHistory(sessionId);
+        if (history.length === 0) {
+            console.log(`[AgentSessionManager] No history to compact for session ${sessionId}`);
+            // Still allow compaction even without history — just clears context
+            session.sdkSessionId = undefined;
+            session.contextLost = true;
+            session.messages = [];
+            deleteSessionState(sessionId);
+            onCompactionComplete?.(true, 'Session context cleared (no history available)');
+            return true;
+        }
+        console.log(`[AgentSessionManager] Starting AI compaction for session ${sessionId} with ${history.length} history entries`);
+        // 2. Build the conversation text
+        const conversationLines = [];
+        for (const entry of history) {
+            const content = typeof entry.content === 'string' ? entry.content : JSON.stringify(entry.content);
+            conversationLines.push(`=== ${entry.role.toUpperCase()} ===\n${content}`);
+        }
+        const conversationText = conversationLines.join('\n\n');
+        // 3. Write conversation to a temp file
+        const attachmentDir = path.join(os.tmpdir(), 'talk-to-code', 'compaction', sessionId);
+        mkdirSync(attachmentDir, { recursive: true });
+        const conversationFilePath = path.join(attachmentDir, 'conversation.md');
+        writeFileSync(conversationFilePath, conversationText, 'utf-8');
+        // 4. Build the compaction prompt
+        const compactionPrompt = [
+            'You are performing a CONTEXT COMPACTION for an ongoing coding session.',
+            '',
+            'Read the full conversation history in the attached file `conversation.md`.',
+            '',
+            'Your task: Create a comprehensive summary that captures:',
+            '1. What the user is working on (project, goals, current task)',
+            '2. All decisions made and their reasoning',
+            '3. The current state of the codebase (what was changed, added, removed)',
+            '4. Any open issues, bugs, or TODOs discussed',
+            '5. Important technical details (file paths, configurations, API designs)',
+            '6. The last thing the user was doing or about to do',
+            '',
+            'Be thorough but concise. Include specific file paths, code snippets, and technical details.',
+            'This summary will be the ONLY context carried forward — everything else is lost.',
+            '',
+            'Format the summary as a structured document with clear sections.',
+            'Write the summary directly — no preamble or meta-commentary.',
+        ].join('\n');
+        // 5. Create a synthetic attachment for the conversation file
+        const attachment = {
+            filename: 'conversation.md',
+            mimeType: 'text/markdown',
+            content: Buffer.from(conversationText).toString('base64'),
+        };
+        // 6. Spawn a compaction prompt through the normal pipeline
+        const compactionPromptId = `compact-${sessionId}-${Date.now()}`;
+        let summaryParts = [];
+        await this.sendPrompt(sessionId, compactionPrompt, [], {
+            sessionId,
+            projectPath,
+            promptId: compactionPromptId,
+            model: session.model,
+            attachments: [attachment],
+            onOutput: (output) => {
+                // Forward to caller for UI display (shows compacting progress)
+                onOutput?.(output);
+                // Capture assistant text for the summary
+                if (output.type === 'assistant' && output.data) {
+                    const d = output.data;
+                    const text = typeof output.data === 'string'
+                        ? output.data
+                        : (d?.content?.[0]?.text || d?.text || '');
+                    if (text)
+                        summaryParts.push(text);
+                }
+            },
+            onError: (error) => {
+                console.error(`[AgentSessionManager] Compaction prompt error: ${error}`);
+                onCompactionComplete?.(false, `Compaction failed: ${error}`);
+            },
+            onComplete: (exitCode) => {
+                const summary = summaryParts.join('\n').trim();
+                if (summary && exitCode === 0) {
+                    // Store summary and clear old context
+                    session.compactionSummary = summary;
+                    session.sdkSessionId = undefined;
+                    session.contextLost = true;
+                    session.messages = [];
+                    deleteSessionState(sessionId);
+                    console.log(`[AgentSessionManager] AI compaction complete for session ${sessionId} (${summary.length} chars summary)`);
+                    onCompactionComplete?.(true, 'Session context compacted with AI summary');
+                }
+                else {
+                    // Compaction prompt failed — fall back to simple clear
+                    session.sdkSessionId = undefined;
+                    session.contextLost = true;
+                    session.messages = [];
+                    deleteSessionState(sessionId);
+                    console.warn(`[AgentSessionManager] Compaction prompt failed (exit=${exitCode}), falling back to simple clear`);
+                    onCompactionComplete?.(true, 'Session context cleared (compaction prompt did not produce summary)');
+                }
+            },
+            onStatusUpdate: () => {
+                // Status updates from the compaction prompt — ignore
+            },
+        });
+        return true;
+    }
     /**
      * Emergency stop - immediately halt all activity in a session
      * This is a forceful stop that kills all processes and clears state

package/dist/cli/sessionHandlers.js

@@ -243,6 +243,67 @@ export function registerSessionHandlers(socket, foreground, activeSessions, getS
             callback?.({ success: false, error: error.message });
         }
     });
+    socket.on('session:compact', async (data, callback) => {
+        try {
+            const { sessionId } = data;
+            if (!sessionId) {
+                callback?.({ success: false, message: 'Missing sessionId' });
+                return;
+            }
+            const sessionInfo = activeSessions.get(sessionId);
+            if (!sessionInfo) {
+                callback?.({ success: false, message: 'Session not found' });
+                return;
+            }
+            if (foreground) {
+                console.log(`[CLI] Compacting session: ${sessionId}`);
+            }
+            // Respond immediately — compaction runs in the background
+            callback?.({ success: true, message: 'Compaction started' });
+            const compacted = await agentSessionManager.compactSession(sessionId, sessionInfo.projectPath, (output) => {
+                // Forward compaction prompt output to the backend for UI display
+                const compactPromptId = `compact-${sessionId}`;
+                getSocket().emit('prompt:output', {
+                    sessionId,
+                    promptId: compactPromptId,
+                    type: output.type,
+                    data: output.data,
+                    timestamp: output.timestamp,
+                    metadata: { ...output.metadata, isCompaction: true },
+                });
+            }, (success, message) => {
+                // Compaction finished — notify UI
+                getSocket().emit('session:compacted', {
+                    sessionId,
+                    timestamp: Date.now(),
+                    success,
+                    message,
+                });
+                if (foreground) {
+                    console.log(`[CLI] Compaction ${success ? 'complete' : 'failed'}: ${message}`);
+                }
+            });
+            if (!compacted) {
+                getSocket().emit('session:compacted', {
+                    sessionId,
+                    timestamp: Date.now(),
+                    success: false,
+                    message: 'Session not found or prompt is running',
+                });
+            }
+        }
+        catch (error) {
+            if (foreground) {
+                console.error(`✗ Error compacting session: ${error.message}`);
+            }
+            getSocket().emit('session:compacted', {
+                sessionId: data.sessionId,
+                timestamp: Date.now(),
+                success: false,
+                message: error.message,
+            });
+        }
+    });
     socket.on('emergency:stop', async (data, callback) => {
         try {
             const { sessionId } = data;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exreve/exk",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "exk - Control Claude CLI with voice and programmable interfaces",
   "type": "module",
   "bin": {