@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/session/project-session-manager.js

@@ -0,0 +1,650 @@
+/**
+ * Project Session Manager
+ *
+ * Manages per-project session persistence. Each project has its own
+ * session directory with terminal-scoped sessions and optional history.
+ *
+ * Directory structure:
+ *   ~/.compilr-dev/sessions/
+ *   ├── project-{id}/
+ *   │   ├── current-{8hex}.json  # Active session (terminal-scoped)
+ *   │   └── history/             # Previous sessions (optional)
+ *   │       └── {timestamp}.json
+ *   └── global/
+ *       └── current-{8hex}.json  # Quick chat mode (no project)
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { getSessionsPath } from '../settings/paths.js';
+import { truncatePlain as truncate } from '@compilr-dev/ui-core/utils';
+import { getActiveTerminalSessionId } from '../multi-agent/session-registry.js';
+import { getDb } from '../db/index.js';
+import { getTeamCheckpointer } from '../multi-agent/checkpointer.js';
+// =============================================================================
+// Constants
+// =============================================================================
+const GLOBAL_SESSION_DIR = 'global';
+const HISTORY_DIR = 'history';
+/**
+ * Get the current session filename, scoped to this terminal.
+ * Requires an active terminal session ID.
+ */
+function getCurrentSessionFilename() {
+    const sessionId = getActiveTerminalSessionId();
+    if (sessionId) {
+        return `current-${sessionId.slice(0, 8)}.json`;
+    }
+    // Shouldn't happen — terminal session is always registered at startup.
+    // Use a random prefix to avoid collisions if it somehow does.
+    const fallback = Math.random().toString(16).slice(2, 10);
+    return `current-${fallback}.json`;
+}
+// =============================================================================
+// Project Session Manager
+// =============================================================================
+export class ProjectSessionManager {
+    sessionsPath;
+    constructor(sessionsPath) {
+        this.sessionsPath = sessionsPath ?? getSessionsPath();
+    }
+    // ---------------------------------------------------------------------------
+    // Path Helpers
+    // ---------------------------------------------------------------------------
+    /**
+     * Get the session directory for a project.
+     */
+    getProjectSessionDir(projectId) {
+        if (projectId === null) {
+            return path.join(this.sessionsPath, GLOBAL_SESSION_DIR);
+        }
+        return path.join(this.sessionsPath, `project-${String(projectId)}`);
+    }
+    /**
+     * Get the path to the current session file for a project.
+     * Uses terminal-scoped filename when multi-terminal is active.
+     */
+    getCurrentSessionPath(projectId) {
+        return path.join(this.getProjectSessionDir(projectId), getCurrentSessionFilename());
+    }
+    /**
+     * Get the path to the history directory for a project.
+     */
+    getHistoryDir(projectId) {
+        return path.join(this.getProjectSessionDir(projectId), HISTORY_DIR);
+    }
+    /**
+     * Ensure project session directory exists.
+     */
+    ensureProjectSessionDir(projectId) {
+        const dir = this.getProjectSessionDir(projectId);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Save/Load Operations
+    // ---------------------------------------------------------------------------
+    /**
+     * Save a session for a project.
+     * Overwrites the current session file.
+     */
+    async saveProjectSession(projectId, projectName, state, workflowState) {
+        this.ensureProjectSessionDir(projectId);
+        const session = {
+            sessionId: state.sessionId,
+            projectId,
+            projectName,
+            messages: state.messages,
+            todos: state.todos,
+            turnCount: state.turnCount,
+            totalTokensUsed: state.totalTokensUsed,
+            workflowState,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+        };
+        // Check if current session exists - preserve createdAt
+        const existingPath = this.getCurrentSessionPath(projectId);
+        if (fs.existsSync(existingPath)) {
+            try {
+                const existing = JSON.parse(fs.readFileSync(existingPath, 'utf-8'));
+                session.createdAt = existing.createdAt;
+            }
+            catch {
+                // Ignore parse errors
+            }
+        }
+        const content = JSON.stringify(session, null, 2);
+        await fs.promises.writeFile(existingPath, content, 'utf-8');
+    }
+    /**
+     * Load the current session for a project.
+     * Returns null if no session exists.
+     */
+    async loadProjectSession(projectId) {
+        const sessionPath = this.getCurrentSessionPath(projectId);
+        if (!fs.existsSync(sessionPath))
+            return null;
+        try {
+            const content = await fs.promises.readFile(sessionPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Load a specific terminal's session file by prefix.
+     * Used when resuming another terminal's session from the resume overlay.
+     */
+    async loadProjectSessionByPrefix(projectId, terminalPrefix) {
+        const dir = this.getProjectSessionDir(projectId);
+        const sessionPath = path.join(dir, `current-${terminalPrefix}.json`);
+        if (!fs.existsSync(sessionPath))
+            return null;
+        try {
+            const content = await fs.promises.readFile(sessionPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Delete a specific terminal's current session file.
+     */
+    async deleteSessionByPrefix(projectId, terminalPrefix) {
+        const dir = this.getProjectSessionDir(projectId);
+        const sessionPath = path.join(dir, `current-${terminalPrefix}.json`);
+        if (!fs.existsSync(sessionPath))
+            return false;
+        try {
+            await fs.promises.unlink(sessionPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Claim a session from another terminal by renaming its file to this terminal's prefix.
+     * This makes the session "owned" by the current terminal so other terminals won't see it
+     * as available.
+     */
+    claimSession(projectId, fromPrefix, toPrefix) {
+        const dir = this.getProjectSessionDir(projectId);
+        const fromPath = path.join(dir, `current-${fromPrefix}.json`);
+        const toPath = path.join(dir, `current-${toPrefix}.json`);
+        if (!fs.existsSync(fromPath))
+            return false;
+        try {
+            fs.renameSync(fromPath, toPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if a project has a current session for this terminal.
+     */
+    hasProjectSession(projectId) {
+        return fs.existsSync(this.getCurrentSessionPath(projectId));
+    }
+    /**
+     * Fast check: does the current project have a session modified within maxAge ms?
+     * Uses fs.statSync — O(1) instead of scanning all session directories.
+     */
+    hasRecentSessionFast(projectId, maxAgeMs = 24 * 60 * 60 * 1000) {
+        const sessionPath = this.getCurrentSessionPath(projectId);
+        try {
+            const stat = fs.statSync(sessionPath);
+            return Date.now() - stat.mtimeMs < maxAgeMs;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Archive the current session to history (before starting fresh).
+     */
+    async archiveCurrentSession(projectId) {
+        const currentPath = this.getCurrentSessionPath(projectId);
+        if (!fs.existsSync(currentPath)) {
+            return false;
+        }
+        try {
+            const historyDir = this.getHistoryDir(projectId);
+            fs.mkdirSync(historyDir, { recursive: true });
+            // Generate timestamp-based filename
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const historyPath = path.join(historyDir, `${timestamp}.json`);
+            // Move current to history
+            await fs.promises.rename(currentPath, historyPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Delete the current session for a project.
+     */
+    async deleteCurrentSession(projectId) {
+        const currentPath = this.getCurrentSessionPath(projectId);
+        if (!fs.existsSync(currentPath)) {
+            return false;
+        }
+        try {
+            await fs.promises.unlink(currentPath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Listing Operations
+    // ---------------------------------------------------------------------------
+    /**
+     * List all sessions grouped by project.
+     */
+    async listAllSessions() {
+        const result = new Map();
+        if (!fs.existsSync(this.sessionsPath)) {
+            return result;
+        }
+        const entries = await fs.promises.readdir(this.sessionsPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            let projectId = null;
+            if (entry.name === GLOBAL_SESSION_DIR) {
+                projectId = null;
+            }
+            else if (entry.name.startsWith('project-')) {
+                const idStr = entry.name.replace('project-', '');
+                projectId = parseInt(idStr, 10);
+                if (isNaN(projectId))
+                    continue;
+            }
+            else {
+                continue;
+            }
+            const sessions = await this.listProjectSessions(projectId);
+            if (sessions.length > 0) {
+                result.set(projectId, sessions);
+            }
+        }
+        return result;
+    }
+    /**
+     * List sessions for a specific project (all current terminals + history).
+     */
+    async listProjectSessions(projectId) {
+        const sessions = [];
+        // Load ALL terminal-scoped current sessions (not just ours)
+        const currentSessions = await this.listAllCurrentSessions(projectId);
+        sessions.push(...currentSessions);
+        // Load history sessions
+        const historyDir = this.getHistoryDir(projectId);
+        if (fs.existsSync(historyDir)) {
+            const historyFiles = await fs.promises.readdir(historyDir);
+            for (const file of historyFiles) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const content = await fs.promises.readFile(path.join(historyDir, file), 'utf-8');
+                    const session = JSON.parse(content);
+                    sessions.push(this.toSessionInfo(session, false));
+                }
+                catch {
+                    // Skip invalid files
+                }
+            }
+        }
+        // Sort by updatedAt descending
+        sessions.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+        return sessions;
+    }
+    /**
+     * Scan a project directory for ALL current-*.json files (not just this terminal's).
+     * Returns a ProjectSessionInfo for each one found.
+     */
+    async listAllCurrentSessions(projectId) {
+        const dir = this.getProjectSessionDir(projectId);
+        if (!fs.existsSync(dir))
+            return [];
+        const files = await fs.promises.readdir(dir);
+        const sessions = [];
+        for (const file of files) {
+            // Match current-{8hex}.json only (skip legacy current.json)
+            if (!/^current-[a-f0-9]{8}\.json$/.test(file))
+                continue;
+            try {
+                const content = await fs.promises.readFile(path.join(dir, file), 'utf-8');
+                const session = JSON.parse(content);
+                const terminalPrefix = this.extractTerminalPrefix(file);
+                sessions.push(this.toSessionInfo(session, true, terminalPrefix));
+            }
+            catch {
+                // Skip invalid files
+            }
+        }
+        return sessions;
+    }
+    /**
+     * Extract the 8-hex terminal prefix from a session filename.
+     */
+    extractTerminalPrefix(filename) {
+        const match = /^current-([a-f0-9]{8})\.json$/.exec(filename);
+        return match ? match[1] : null;
+    }
+    /**
+     * Look up terminal info (label, active status) from the terminal_sessions table.
+     * If the terminal has exited (row deleted), returns a fallback label from the prefix.
+     */
+    getTerminalInfo(prefix) {
+        try {
+            // Check for active terminal first
+            const row = getDb().prepare(`SELECT label, status FROM terminal_sessions WHERE id LIKE ? || '%' LIMIT 1`).get(prefix);
+            if (row) {
+                return {
+                    label: row.label ?? `Terminal ${prefix.slice(0, 4)}`,
+                    isActive: row.status === 'active',
+                };
+            }
+        }
+        catch {
+            // DB not available — fall through to fallback
+        }
+        // Terminal exited and row was deleted — generate fallback label
+        return { label: `Terminal ${prefix.slice(0, 4)}`, isActive: false };
+    }
+    /**
+     * Convert ProjectSession to ProjectSessionInfo.
+     */
+    toSessionInfo(session, isCurrent, terminalPrefix) {
+        // Extract preview from last actual user message (not tool_result)
+        let preview = '';
+        // Filter to only user messages that have actual text content (not tool_result)
+        const userTextMessages = session.messages.filter((m) => {
+            if (m.role !== 'user')
+                return false;
+            // String content is always user text
+            if (typeof m.content === 'string')
+                return true;
+            // Array content - check if it has text blocks (not just tool_result)
+            if (Array.isArray(m.content)) {
+                return m.content.some((b) => b.type === 'text');
+            }
+            return false;
+        });
+        if (userTextMessages.length > 0) {
+            const lastUserMsg = userTextMessages[userTextMessages.length - 1];
+            if (typeof lastUserMsg.content === 'string') {
+                preview = lastUserMsg.content;
+            }
+            else if (Array.isArray(lastUserMsg.content)) {
+                const textBlock = lastUserMsg.content.find((b) => b.type === 'text');
+                if (textBlock?.type === 'text') {
+                    preview = textBlock.text;
+                }
+            }
+        }
+        // Truncate preview
+        const maxPreviewLen = 100;
+        if (preview.length > maxPreviewLen) {
+            preview = truncate(preview, maxPreviewLen);
+        }
+        // Sanitize preview (remove markdown, newlines)
+        preview = preview.replace(/^#+\s*/gm, '').replace(/\n/g, ' ').trim();
+        // Build session ID that preserves terminal identity
+        let sessionId;
+        if (isCurrent) {
+            const projectSuffix = session.projectId !== null ? String(session.projectId) : 'global';
+            sessionId = terminalPrefix
+                ? `current-${terminalPrefix}-${projectSuffix}`
+                : `current-${projectSuffix}`;
+        }
+        else {
+            sessionId = session.sessionId;
+        }
+        // Look up terminal info from DB if we have a prefix
+        let terminalLabel = null;
+        let isActiveTerminal = false;
+        if (terminalPrefix) {
+            const ownSessionId = getActiveTerminalSessionId();
+            const ownPrefix = ownSessionId ? ownSessionId.slice(0, 8) : null;
+            if (terminalPrefix === ownPrefix) {
+                // This is our own session — use our known label
+                isActiveTerminal = true;
+                try {
+                    const row = getDb().prepare(`SELECT label FROM terminal_sessions WHERE id = ? LIMIT 1`).get(ownSessionId);
+                    terminalLabel = row?.label ?? 'This terminal';
+                }
+                catch {
+                    terminalLabel = 'This terminal';
+                }
+            }
+            else {
+                const info = this.getTerminalInfo(terminalPrefix);
+                terminalLabel = info.label;
+                isActiveTerminal = info.isActive;
+            }
+        }
+        // Look up team agent count from team file (if terminal-scoped)
+        let teamAgentCount = 0;
+        if (terminalPrefix) {
+            try {
+                teamAgentCount = getTeamCheckpointer().getTeamAgentCountByPrefix(session.projectId, terminalPrefix);
+            }
+            catch {
+                // Best effort
+            }
+        }
+        return {
+            sessionId,
+            createdAt: session.createdAt,
+            updatedAt: session.updatedAt,
+            messageCount: session.messages.length,
+            preview,
+            projectId: session.projectId,
+            projectName: session.projectName,
+            workflowMode: session.workflowState?.mode,
+            terminalPrefix: terminalPrefix ?? null,
+            terminalLabel,
+            isActiveTerminal,
+            teamAgentCount,
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Cleanup
+    // ---------------------------------------------------------------------------
+    /**
+     * Delete legacy (pre-multi-terminal) files from all project session directories.
+     * Removes: current.json, team.json, shared-context.json, agent-{id}.json (no 8-hex prefix).
+     * Call once at startup. Safe to call multiple times (no-op if no legacy files).
+     */
+    async cleanupLegacyFiles() {
+        if (!fs.existsSync(this.sessionsPath))
+            return 0;
+        let deleted = 0;
+        // Legacy file patterns (no 8-hex terminal prefix)
+        const isLegacyFile = (name) => {
+            if (name === 'current.json')
+                return true;
+            if (name === 'team.json')
+                return true;
+            if (name === 'shared-context.json')
+                return true;
+            // agent-{id}.json but NOT agent-{8hex}-{id}.json
+            if (name.startsWith('agent-') && name.endsWith('.json')) {
+                // New format: agent-{8hex}-{id}.json — has two dashes after "agent-"
+                const rest = name.slice('agent-'.length, -'.json'.length);
+                // If rest matches {8hex}-{anything}, it's new format → NOT legacy
+                if (/^[a-f0-9]{8}-.+$/.test(rest))
+                    return false;
+                return true;
+            }
+            return false;
+        };
+        try {
+            const entries = await fs.promises.readdir(this.sessionsPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const dirPath = path.join(this.sessionsPath, entry.name);
+                try {
+                    const files = await fs.promises.readdir(dirPath);
+                    for (const file of files) {
+                        if (isLegacyFile(file)) {
+                            try {
+                                await fs.promises.unlink(path.join(dirPath, file));
+                                deleted++;
+                            }
+                            catch {
+                                // Ignore individual file errors
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // Ignore directory read errors
+                }
+            }
+        }
+        catch {
+            // Ignore top-level errors
+        }
+        return deleted;
+    }
+    /**
+     * Delete old history sessions beyond retention limit.
+     */
+    async cleanupHistory(projectId, maxHistoryCount = 10) {
+        const historyDir = this.getHistoryDir(projectId);
+        if (!fs.existsSync(historyDir)) {
+            return 0;
+        }
+        const files = await fs.promises.readdir(historyDir);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        if (jsonFiles.length <= maxHistoryCount) {
+            return 0;
+        }
+        // Sort by filename (timestamp-based, oldest first)
+        jsonFiles.sort();
+        const toDelete = jsonFiles.slice(0, jsonFiles.length - maxHistoryCount);
+        let deleted = 0;
+        for (const file of toDelete) {
+            try {
+                await fs.promises.unlink(path.join(historyDir, file));
+                deleted++;
+            }
+            catch {
+                // Ignore errors
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Clean up old sessions across all projects based on retention days.
+     * Only deletes history files — current sessions are always preserved.
+     * Returns count of deleted files.
+     */
+    async cleanupOldSessions(retentionDays) {
+        if (retentionDays <= 0)
+            return 0; // 0 = forever, no cleanup
+        if (!fs.existsSync(this.sessionsPath))
+            return 0;
+        const cutoffMs = Date.now() - (retentionDays * 24 * 60 * 60 * 1000);
+        let totalDeleted = 0;
+        try {
+            const entries = await fs.promises.readdir(this.sessionsPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (!entry.isDirectory())
+                    continue;
+                const historyDir = path.join(this.sessionsPath, entry.name, HISTORY_DIR);
+                if (!fs.existsSync(historyDir))
+                    continue;
+                try {
+                    const files = await fs.promises.readdir(historyDir);
+                    for (const file of files) {
+                        if (!file.endsWith('.json'))
+                            continue;
+                        const filePath = path.join(historyDir, file);
+                        try {
+                            const stat = await fs.promises.stat(filePath);
+                            if (stat.mtimeMs < cutoffMs) {
+                                await fs.promises.unlink(filePath);
+                                totalDeleted++;
+                            }
+                        }
+                        catch {
+                            // Skip individual file errors
+                        }
+                    }
+                }
+                catch {
+                    // Skip directory read errors
+                }
+            }
+        }
+        catch {
+            // Best effort cleanup
+        }
+        return totalDeleted;
+    }
+    /**
+     * Delete all history files for a specific project.
+     * Optionally also deletes the current session.
+     * Returns count of deleted files.
+     */
+    async deleteProjectHistory(projectId, includeCurrentSession = false) {
+        let deleted = 0;
+        // Delete history files
+        const historyDir = this.getHistoryDir(projectId);
+        if (fs.existsSync(historyDir)) {
+            try {
+                const files = await fs.promises.readdir(historyDir);
+                for (const file of files) {
+                    if (!file.endsWith('.json'))
+                        continue;
+                    try {
+                        await fs.promises.unlink(path.join(historyDir, file));
+                        deleted++;
+                    }
+                    catch {
+                        // Skip individual file errors
+                    }
+                }
+            }
+            catch {
+                // Best effort
+            }
+        }
+        // Optionally delete current session
+        if (includeCurrentSession) {
+            const currentPath = this.getCurrentSessionPath(projectId);
+            if (fs.existsSync(currentPath)) {
+                try {
+                    await fs.promises.unlink(currentPath);
+                    deleted++;
+                }
+                catch {
+                    // Best effort
+                }
+            }
+        }
+        return deleted;
+    }
+}
+// =============================================================================
+// Singleton Instance
+// =============================================================================
+let _instance = null;
+export function getProjectSessionManager() {
+    if (!_instance) {
+        _instance = new ProjectSessionManager();
+    }
+    return _instance;
+}