salmon-loop 0.2.3

package/dist/core/session/manager.js

@@ -0,0 +1,313 @@
+import { randomBytes } from 'crypto';
+import { join } from 'path';
+import { FileAdapter } from '../adapters/fs/index.js';
+import { SessionCompressor, CompressedSessionStore } from './compression.js';
+import { SessionPruningEngine } from './pruning-strategy.js';
+/**
+ * Manages chat session persistence and lifecycle.
+ * Storage: .salmonloop/chat-sessions/<id>.json
+ * Features: Auto-pruning, compression, intelligent cleanup
+ */
+export class ChatSessionManager {
+    storageDir;
+    currentSession = null;
+    fileAdapter = new FileAdapter();
+    pruningEngine;
+    compressor;
+    compressedStore;
+    constructor(repoPath, pruningStrategy) {
+        this.storageDir = join(repoPath, '.salmonloop', 'chat-sessions');
+        this.pruningEngine = new SessionPruningEngine(pruningStrategy);
+        this.compressor = new SessionCompressor();
+        this.compressedStore = new CompressedSessionStore(repoPath);
+    }
+    /**
+     * Initialize storage directory
+     */
+    async init() {
+        await this.fileAdapter.mkdir(this.storageDir);
+    }
+    /**
+     * Create new chat session
+     */
+    async create(name) {
+        const id = randomBytes(8).toString('hex');
+        const now = Date.now();
+        const session = {
+            meta: {
+                id,
+                name: name || `Chat ${new Date().toLocaleString()}`,
+                repoPath: this.storageDir.replace(/\.salmonloop.*/, ''),
+                createdAt: now,
+                updatedAt: now,
+                totalIterations: 0,
+                successfulIterations: 0,
+                totalTokens: { input: 0, output: 0 },
+                snapshots: [],
+            },
+            messages: [],
+            iterations: [],
+        };
+        this.currentSession = session;
+        await this.save();
+        return session;
+    }
+    /**
+     * Load most recent session (by modification time)
+     */
+    async loadLast() {
+        const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        if (jsonFiles.length === 0)
+            return null;
+        // Sort by modification time (descending)
+        const fileStats = await Promise.all(jsonFiles.map(async (f) => {
+            const filePath = join(this.storageDir, f);
+            const stats = await this.fileAdapter.stat(filePath);
+            return { name: f, mtime: stats.mtime.getTime() };
+        }));
+        fileStats.sort((a, b) => b.mtime - a.mtime);
+        const latestFile = fileStats[0].name;
+        return this.load(latestFile.replace('.json', ''));
+    }
+    /**
+     * Load session by ID (supports short ID prefix)
+     */
+    async load(id) {
+        let targetId = id;
+        // Support short ID matching
+        if (id.length < 16) {
+            const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+            const match = files.find((f) => f.startsWith(id) && f.endsWith('.json'));
+            if (match) {
+                targetId = match.replace('.json', '');
+            }
+        }
+        const filePath = join(this.storageDir, `${targetId}.json`);
+        try {
+            const data = await this.fileAdapter.readFile(filePath);
+            this.currentSession = JSON.parse(data);
+            return this.currentSession;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Resume a session (alias for load, with explicit name)
+     */
+    async resumeSession(id) {
+        const session = await this.load(id);
+        if (!session) {
+            throw new Error(`Session ${id} not found`);
+        }
+        return session;
+    }
+    /**
+     * Save current session to disk
+     */
+    async save() {
+        if (!this.currentSession)
+            return;
+        this.currentSession.meta.updatedAt = Date.now();
+        const filePath = join(this.storageDir, `${this.currentSession.meta.id}.json`);
+        await this.fileAdapter.writeFile(filePath, JSON.stringify(this.currentSession, null, 2));
+    }
+    /**
+     * Add message to current session
+     */
+    addMessage(message) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.messages.push(message);
+    }
+    /**
+     * Add execution iteration to current session
+     */
+    addIteration(iteration, snapshotHash) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        const id = randomBytes(4).toString('hex');
+        this.currentSession.iterations.push({ ...iteration, id });
+        this.currentSession.meta.totalIterations++;
+        if (snapshotHash) {
+            this.currentSession.meta.snapshots.push({
+                id: snapshotHash,
+                iterationId: id,
+                timestamp: Date.now(),
+            });
+        }
+        return id;
+    }
+    /**
+     * Get conversation history (for LLM context)
+     */
+    getMessages() {
+        return this.currentSession?.messages || [];
+    }
+    /**
+     * Get messages with IDs for summarization.
+     * Ensures all messages have IDs.
+     */
+    getMessagesWithIds() {
+        const messages = this.currentSession?.messages || [];
+        return messages.map((m, i) => ({
+            ...m,
+            id: m.id || `msg-${i}-${m.timestamp}`,
+        }));
+    }
+    /**
+     * Get current session (throws if none)
+     */
+    getCurrent() {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        return this.currentSession;
+    }
+    /**
+     * Get summary state for summarization.
+     */
+    getSummaryState() {
+        return this.currentSession?.meta.summaryState;
+    }
+    /**
+     * Update summary state after summarization.
+     */
+    updateSummaryState(state) {
+        if (!this.currentSession)
+            throw new Error('No active session');
+        this.currentSession.meta.summaryState = state;
+    }
+    /**
+     * Clear summary state (e.g., on session reset).
+     */
+    clearSummaryState() {
+        if (!this.currentSession)
+            return;
+        this.currentSession.meta.summaryState = undefined;
+    }
+    /**
+     * List all sessions (sorted by update time)
+     */
+    async listSessions() {
+        const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+        const sessions = [];
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const filePath = join(this.storageDir, file);
+            const data = await this.fileAdapter.readFile(filePath);
+            const session = JSON.parse(data);
+            sessions.push({
+                id: session.meta.id,
+                name: session.meta.name,
+                updatedAt: session.meta.updatedAt,
+            });
+        }
+        return sessions.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    /**
+     * Perform automatic session cleanup based on pruning strategy
+     */
+    async performAutoCleanup() {
+        const sessions = await this.loadAllSessions();
+        const analysis = this.pruningEngine.analyzeSessions(sessions);
+        let deleted = 0;
+        let archived = 0;
+        // Delete low-priority sessions
+        for (const sessionId of analysis.sessionsToDelete) {
+            await this.deleteSession(sessionId);
+            deleted++;
+        }
+        // Archive medium-priority sessions
+        for (const sessionId of analysis.sessionsToArchive) {
+            const session = sessions.find((s) => s.meta.id === sessionId);
+            if (session) {
+                await this.archiveSession(session);
+                await this.deleteSession(sessionId);
+                archived++;
+            }
+        }
+        return {
+            deleted,
+            archived,
+            kept: analysis.sessionsToKeep.length,
+        };
+    }
+    /**
+     * Archive a session with compression
+     */
+    async archiveSession(session) {
+        const importanceScore = this.pruningEngine.getSessionScore(session);
+        return await this.compressedStore.saveCompressed(session, importanceScore);
+    }
+    /**
+     * Load all sessions from storage
+     */
+    async loadAllSessions() {
+        const files = await this.fileAdapter.readdir(this.storageDir).catch(() => []);
+        const sessions = [];
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const filePath = join(this.storageDir, file);
+                const data = await this.fileAdapter.readFile(filePath);
+                const session = JSON.parse(data);
+                sessions.push(session);
+            }
+            catch (error) {
+                // Skip corrupted session files
+                console.warn(`Failed to load session file ${file}:`, error);
+            }
+        }
+        return sessions;
+    }
+    /**
+     * Delete a session file
+     */
+    async deleteSession(sessionId) {
+        const filePath = join(this.storageDir, `${sessionId}.json`);
+        try {
+            await this.fileAdapter.deleteFile(filePath);
+        }
+        catch (error) {
+            console.warn(`Failed to delete session ${sessionId}:`, error);
+        }
+    }
+    /**
+     * Get session importance score
+     */
+    getSessionScore(session) {
+        return this.pruningEngine.getSessionScore(session);
+    }
+    /**
+     * Update pruning strategy
+     */
+    updatePruningStrategy(strategy) {
+        this.pruningEngine.updateStrategy(strategy);
+    }
+    /**
+     * Get current pruning strategy
+     */
+    getPruningStrategy() {
+        return this.pruningEngine.getStrategy();
+    }
+    /**
+     * List archived sessions
+     */
+    async listArchivedSessions() {
+        // Implement archived session list functionality
+        // This needs to access the compressed storage
+        return [];
+    }
+    /**
+     * Restore session from archive
+     */
+    async restoreFromArchive(_archiveId) {
+        // Implement session restoration from archive functionality
+        // This needs to access the compressed storage and decompress
+        return null;
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/core/session/pruning-strategy.js

@@ -0,0 +1,153 @@
+/**
+ * Default memory pruning strategy configuration
+ */
+export const DEFAULT_PRUNING_STRATEGY = {
+    maxAgeDays: 30,
+    maxSessions: 50,
+    autoPrune: true,
+    gracePeriodDays: 7,
+    importanceScoring: calculateDefaultImportanceScore,
+    lowScoreThreshold: 10,
+};
+/**
+ * Default importance scoring algorithm
+ */
+export function calculateDefaultImportanceScore(session) {
+    let score = 0;
+    // Score based on successful iterations
+    score += session.meta.successfulIterations * 8;
+    // Score based on snapshot count
+    score += session.meta.snapshots.length * 3;
+    // Score based on recent activity (time decay)
+    const daysSinceUpdate = (Date.now() - session.meta.updatedAt) / (1000 * 60 * 60 * 24);
+    const recencyScore = Math.max(0, 12 - daysSinceUpdate);
+    score += recencyScore;
+    // Score based on message count
+    score += Math.min(session.messages.length * 0.5, 10);
+    // Score based on token usage
+    const totalTokens = session.meta.totalTokens.input + session.meta.totalTokens.output;
+    score += Math.min(totalTokens / 2000, 10); // Reduced token weight
+    return Math.round(score * 100) / 100; // Keep two decimal places
+}
+/**
+ * Session pruning engine
+ */
+export class SessionPruningEngine {
+    strategy;
+    constructor(strategy = {}) {
+        this.strategy = { ...DEFAULT_PRUNING_STRATEGY, ...strategy };
+    }
+    /**
+     * Analyze sessions and determine pruning strategy
+     */
+    analyzeSessions(sessions) {
+        const now = Date.now();
+        const sessionsWithScores = sessions.map((session) => ({
+            session,
+            score: this.strategy.importanceScoring(session),
+            ageInDays: (now - session.meta.createdAt) / (1000 * 60 * 60 * 24),
+        }));
+        // Sort by importance score descending
+        sessionsWithScores.sort((a, b) => b.score - a.score);
+        const result = {
+            sessionsToDelete: [],
+            sessionsToArchive: [],
+            sessionsToKeep: [],
+            summary: {
+                totalSessions: sessions.length,
+                deletedCount: 0,
+                archivedCount: 0,
+                keptCount: 0,
+            },
+        };
+        for (const { session, score, ageInDays } of sessionsWithScores) {
+            const isExpired = ageInDays > this.strategy.maxAgeDays;
+            const isInGracePeriod = ageInDays <= this.strategy.maxAgeDays + this.strategy.gracePeriodDays;
+            const hasLowScore = score < this.strategy.lowScoreThreshold;
+            if (isExpired && hasLowScore && !isInGracePeriod) {
+                // Expired and low importance sessions to delete directly
+                result.sessionsToDelete.push(session.meta.id);
+            }
+            else if (isExpired && hasLowScore) {
+                // Low importance sessions within grace period to archive
+                result.sessionsToArchive.push(session.meta.id);
+            }
+            else {
+                // Important sessions or unexpired sessions to keep
+                result.sessionsToKeep.push(session.meta.id);
+            }
+        }
+        // If sessions to keep exceed maximum limit, archive excess sessions
+        if (result.sessionsToKeep.length > this.strategy.maxSessions) {
+            const excessSessions = result.sessionsToKeep.slice(this.strategy.maxSessions);
+            result.sessionsToKeep = result.sessionsToKeep.slice(0, this.strategy.maxSessions);
+            result.sessionsToArchive.push(...excessSessions);
+        }
+        // Update statistics
+        result.summary.deletedCount = result.sessionsToDelete.length;
+        result.summary.archivedCount = result.sessionsToArchive.length;
+        result.summary.keptCount = result.sessionsToKeep.length;
+        return result;
+    }
+    /**
+     * Get session importance score
+     */
+    getSessionScore(session) {
+        return this.strategy.importanceScoring(session);
+    }
+    /**
+     * Update strategy configuration
+     */
+    updateStrategy(newStrategy) {
+        this.strategy = { ...this.strategy, ...newStrategy };
+    }
+    /**
+     * Get current strategy configuration
+     */
+    getStrategy() {
+        return { ...this.strategy };
+    }
+}
+/**
+ * Session archiver
+ */
+export class SessionArchiver {
+    archiveDir;
+    constructor(baseDir) {
+        this.archiveDir = `${baseDir}/.salmonloop/chat-archives`;
+    }
+    /**
+     * Create session archive
+     */
+    async createArchive(session, compressedData) {
+        const archiveId = `${session.meta.id}-${Date.now()}`;
+        const archivePath = `${this.archiveDir}/${archiveId}.mpack.gz`;
+        // Ensure archive directory exists
+        await this.ensureArchiveDir();
+        // Write compressed data
+        await this.writeCompressedData(archivePath, compressedData);
+        return archiveId;
+    }
+    /**
+     * Restore session from archive
+     */
+    async restoreFromArchive(_archiveId) {
+        try {
+            // Need to implement decompression and deserialization logic
+            // Return null for now, implement later
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async ensureArchiveDir() {
+        // This method is not implemented as it requires file system adapter
+        // The SessionArchiver is currently a placeholder for future implementation
+    }
+    async writeCompressedData(_archivePath, _compressedData) {
+        // This method is not implemented as it requires file system adapter
+        // The SessionArchiver is currently a placeholder for future implementation
+    }
+}
+//# sourceMappingURL=pruning-strategy.js.map

package/dist/core/session/session-context-builder.js

@@ -0,0 +1,122 @@
+import { TokenBudgetCalculator } from '../context/token/token-budget.js';
+export const DEFAULT_SESSION_CONTEXT_BUDGET_FRACTION = 0.15;
+export const DEFAULT_SESSION_CONTEXT_MIN_TOKENS = 256;
+export const DEFAULT_SESSION_CONTEXT_MAX_TOKENS = 4096;
+function clampInt(value, min, max) {
+    const v = Math.floor(value);
+    return Math.max(min, Math.min(max, v));
+}
+export function getDefaultSessionContextBudgetTokens(params) {
+    const calculator = new TokenBudgetCalculator();
+    if (typeof params.modelId === 'string' && params.modelId.trim()) {
+        calculator.setModel(params.modelId);
+    }
+    const recommended = calculator.getDefaultBudget();
+    const derived = recommended * DEFAULT_SESSION_CONTEXT_BUDGET_FRACTION;
+    return clampInt(derived, DEFAULT_SESSION_CONTEXT_MIN_TOKENS, DEFAULT_SESSION_CONTEXT_MAX_TOKENS);
+}
+function defaultCountTokens(textValue) {
+    // Deterministic approximation for English-ish text. This matches our existing conventions.
+    return Math.ceil(textValue.length / 4);
+}
+function toSafeHistoryMessage(msg) {
+    if (!msg || typeof msg !== 'object')
+        return null;
+    if (msg.role !== 'user' && msg.role !== 'assistant')
+        return null;
+    if (typeof msg.content !== 'string')
+        return null;
+    const content = msg.content.trimEnd();
+    if (!content)
+        return null;
+    return { role: msg.role, content };
+}
+/**
+ * Build a deterministic conversation context slice from a persisted session.
+ *
+ * Notes:
+ * - Only includes `user` and `assistant` messages.
+ * - Drops a leading `assistant` message to avoid starting mid-turn.
+ * - Uses a soft token budget with a deterministic approximation unless overridden.
+ */
+export function buildSessionConversationContext(messages, options) {
+    const history = Array.isArray(messages) ? messages.map(toSafeHistoryMessage).filter(Boolean) : [];
+    if (history.length === 0)
+        return [];
+    const maxMessages = clampInt(options.maxMessages ?? 32, 1, 256);
+    const budgetTokens = Math.max(0, Math.floor(options.budgetTokens));
+    if (budgetTokens === 0)
+        return [];
+    const count = options.countTokens ?? defaultCountTokens;
+    let remaining = budgetTokens;
+    const selectedReversed = [];
+    for (let i = history.length - 1; i >= 0; i--) {
+        if (selectedReversed.length >= maxMessages)
+            break;
+        const msg = history[i];
+        const tokens = Math.max(0, Math.floor(count(msg.content)));
+        if (tokens <= remaining) {
+            selectedReversed.push(msg);
+            remaining -= tokens;
+            continue;
+        }
+        if (selectedReversed.length === 0) {
+            // If a single message doesn't fit, include a deterministic prefix slice.
+            const maxChars = Math.max(0, remaining * 4);
+            if (maxChars >= 16) {
+                selectedReversed.push({ role: msg.role, content: msg.content.slice(0, maxChars) });
+            }
+        }
+        break;
+    }
+    const selected = selectedReversed.reverse();
+    while (selected.length > 0 && selected[0].role === 'assistant') {
+        selected.shift();
+    }
+    const summaryMessages = buildSummaryMessages(options.summaryState);
+    if (summaryMessages.length === 0) {
+        return selected;
+    }
+    const selectedTokens = selected.reduce((sum, msg) => sum + Math.max(0, Math.floor(count(msg.content))), 0);
+    let budgetLeftForSummary = Math.max(0, budgetTokens - selectedTokens);
+    const prepended = [];
+    for (const msg of summaryMessages) {
+        if (budgetLeftForSummary <= 0)
+            break;
+        const fullTokens = Math.max(0, Math.floor(count(msg.content)));
+        if (fullTokens <= budgetLeftForSummary) {
+            prepended.push(msg);
+            budgetLeftForSummary -= fullTokens;
+            continue;
+        }
+        const maxChars = Math.max(0, budgetLeftForSummary * 4);
+        if (maxChars >= 16) {
+            prepended.push({ role: 'system', content: msg.content.slice(0, maxChars) });
+        }
+        budgetLeftForSummary = 0;
+    }
+    return [...prepended, ...selected];
+}
+function buildSummaryMessages(summaryState) {
+    if (!summaryState)
+        return [];
+    const messages = [];
+    const structured = summaryState.structuredState;
+    if (structured) {
+        messages.push({
+            role: 'system',
+            content: `[Conversation structured state v${summaryState.summaryVersion ?? 2}]` +
+                `\ncontextHash=${summaryState.contextHash ?? 'none'}\n` +
+                JSON.stringify(structured),
+        });
+    }
+    const summaryText = typeof summaryState.summary === 'string' ? summaryState.summary.trim() : '';
+    if (summaryText) {
+        messages.push({
+            role: 'system',
+            content: `[Previous conversation summary]\n${summaryText}`,
+        });
+    }
+    return messages;
+}
+//# sourceMappingURL=session-context-builder.js.map

package/dist/core/session/summary-sync.js

@@ -0,0 +1,82 @@
+import { ConversationSummarizer } from '../context/summarization/summarizer.js';
+import { DEFAULT_SUMMARIZATION_CONFIG } from '../context/summarization/types.js';
+import { TokenTracker } from './token-tracker.js';
+export async function refreshSessionSummary(params) {
+    const { sessionManager, llm, contextHash } = params;
+    const strategy = params.strategy ?? 'auto';
+    if (!sessionManager)
+        return;
+    try {
+        const summarizer = new ConversationSummarizer({
+            chat: async ({ messages, temperature, maxTokens }) => {
+                const response = await llm.chat(messages, {
+                    temperature,
+                    maxTokens,
+                    phase: 'CONTEXT',
+                });
+                return { content: response.content };
+            },
+        }, {
+            count: (text) => TokenTracker.estimateTokens(text),
+        }, {
+            ...DEFAULT_SUMMARIZATION_CONFIG,
+            async: false,
+            summaryModel: {
+                model: llm.getModelId?.() ?? 'session-summary',
+                temperature: 0,
+                maxTokens: DEFAULT_SUMMARIZATION_CONFIG.maxSummaryTokens,
+            },
+        });
+        await summarizer.initialize();
+        const persistedState = sessionManager.getSummaryState();
+        if (persistedState) {
+            summarizer.restoreState(persistedState);
+        }
+        const messages = sessionManager.getMessagesWithIds().map((msg) => ({
+            id: msg.id,
+            role: msg.role,
+            content: msg.content,
+            timestamp: msg.timestamp,
+        }));
+        if (strategy === 'force') {
+            await summarizer.forceSummarize(messages, contextHash);
+        }
+        else {
+            await summarizer.triggerSummarization(messages, contextHash);
+        }
+        sessionManager.updateSummaryState(summarizer.getState());
+    }
+    catch {
+        // Best-effort summary update: never affect execution flow.
+    }
+}
+export function buildEffectiveConversationContext(params) {
+    const { sessionManager } = params;
+    const summaryState = sessionManager.getSummaryState();
+    const messages = sessionManager.getMessagesWithIds().map((msg) => ({
+        id: msg.id,
+        role: msg.role,
+        content: msg.content,
+        timestamp: msg.timestamp,
+    }));
+    const summarizer = new ConversationSummarizer({
+        chat: async () => ({ content: '' }),
+    }, {
+        count: (text) => TokenTracker.estimateTokens(text),
+    }, {
+        ...DEFAULT_SUMMARIZATION_CONFIG,
+        async: false,
+        summaryModel: {
+            model: params.llm.getModelId?.() ?? 'session-summary',
+            temperature: 0,
+            maxTokens: DEFAULT_SUMMARIZATION_CONFIG.maxSummaryTokens,
+        },
+    });
+    if (summaryState) {
+        summarizer.restoreState(summaryState);
+    }
+    return summarizer
+        .getEffectiveContext(messages)
+        .map((m) => ({ role: m.role, content: m.content }));
+}
+//# sourceMappingURL=summary-sync.js.map