@ekkos/cli 0.2.0

package/dist/restore/RestoreOrchestrator.js

@@ -0,0 +1,481 @@
+"use strict";
+/**
+ * ekkOS Fast /continue - Restore Orchestrator
+ *
+ * Implements the 3-tier restore chain for near-zero context loss:
+ * - Tier 0: Local JSONL cache (~20ms)
+ * - Tier 1: Redis hot cache (~150ms)
+ * - Tier 2: Supabase cold store (~500ms)
+ *
+ * Falls back through tiers on miss, tracks which tier succeeded.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restoreOrchestrator = exports.RestoreOrchestrator = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const LocalSessionStore_js_1 = require("../cache/LocalSessionStore.js");
+const types_js_1 = require("../cache/types.js");
+// API configuration
+const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://api.ekkos.dev';
+const CONFIG_PATH = path.join(os.homedir(), '.ekkos', 'config.json');
+/**
+ * Load auth token from config
+ */
+function loadAuthToken() {
+    try {
+        if (fs.existsSync(CONFIG_PATH)) {
+            const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+            return config.hookApiKey || config.apiKey || '';
+        }
+    }
+    catch {
+        // Ignore config errors
+    }
+    return '';
+}
+/**
+ * RestoreOrchestrator - Tiered restore for /continue
+ */
+class RestoreOrchestrator {
+    constructor() {
+        this.localStore = new LocalSessionStore_js_1.LocalSessionStore();
+        this.authToken = loadAuthToken();
+    }
+    /**
+     * Main restore function - attempts tiers in order
+     */
+    async restore(options = {}) {
+        const startTime = Date.now();
+        const lastN = options.last_n || 10;
+        // Resolve session
+        let sessionId = options.session_id;
+        let sessionName = options.session_name;
+        if (sessionName && !sessionId) {
+            sessionId = this.localStore.getSessionId(sessionName) || undefined;
+        }
+        if (!sessionId && !sessionName) {
+            // Get most recent session
+            const sessions = this.localStore.listSessions();
+            if (sessions.length > 0) {
+                sessionId = sessions[0].session_id;
+                sessionName = sessions[0].session_name;
+            }
+        }
+        if (!sessionId) {
+            return {
+                success: false,
+                error: 'No session specified and no recent sessions found',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // Try Tier 0: Local cache
+        const localResult = await this.restoreFromLocal(sessionId, sessionName || '', lastN);
+        if (localResult.success && localResult.data) {
+            return {
+                ...localResult,
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // Try Tier 1: Redis
+        const redisResult = await this.restoreFromRedis(sessionName || sessionId, lastN);
+        if (redisResult.success && redisResult.data) {
+            return {
+                ...redisResult,
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // Try Tier 2: Supabase
+        const supabaseResult = await this.restoreFromSupabase(sessionId, lastN);
+        if (supabaseResult.success && supabaseResult.data) {
+            return {
+                ...supabaseResult,
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // All tiers failed
+        return {
+            success: false,
+            error: `All restore tiers failed. Local: ${localResult.error}, Redis: ${redisResult.error}, Supabase: ${supabaseResult.error}`,
+            latency_ms: Date.now() - startTime,
+        };
+    }
+    /**
+     * Tier 0: Restore from local JSONL cache
+     */
+    async restoreFromLocal(sessionId, sessionName, lastN) {
+        const startTime = Date.now();
+        const turnsResult = this.localStore.getLastTurns(sessionId, lastN);
+        if (!turnsResult.success || !turnsResult.data || turnsResult.data.length === 0) {
+            return {
+                success: false,
+                error: turnsResult.error || 'No turns found in local cache',
+                source: 'local',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // Mark each turn as complete or incomplete using stricter validation
+        const allTurns = turnsResult.data.map((t) => ({
+            ...t,
+            is_complete: (0, types_js_1.isValidAssistantResponse)(t.assistant_response),
+        }));
+        // Separate complete turns from incomplete (pending) turns
+        const completeTurns = allTurns.filter((t) => t.is_complete);
+        const pendingTurns = allTurns.filter((t) => !t.is_complete);
+        // Get the most recent pending turn (user query not yet answered)
+        const pendingTurn = pendingTurns.length > 0 ? pendingTurns[pendingTurns.length - 1] : undefined;
+        if (completeTurns.length === 0) {
+            // No complete turns, but might have pending user query
+            if (pendingTurn) {
+                return {
+                    success: false,
+                    error: `No complete turns found. Pending user query: "${pendingTurn.user_query.slice(0, 50)}..."`,
+                    source: 'local',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            return {
+                success: false,
+                error: 'No complete turns found (all turns missing assistant_response)',
+                source: 'local',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        // Use complete turns for context, but include pending for awareness
+        const turns = completeTurns;
+        const latest = turns[turns.length - 1]; // Guaranteed to be complete
+        const meta = this.localStore.getSessionMeta(sessionId);
+        // Estimate tokens (rough: 4 chars per token)
+        const totalChars = turns.reduce((sum, t) => sum + t.user_query.length + t.assistant_response.length, 0);
+        const payload = {
+            session_id: sessionId,
+            session_name: sessionName || this.localStore.getSessionName(sessionId) || 'unknown',
+            source: 'local',
+            restored_turns: turns,
+            latest: {
+                user_query: latest.user_query,
+                assistant_response: latest.assistant_response,
+            },
+            pending_turn: pendingTurn
+                ? {
+                    turn_id: pendingTurn.turn_id,
+                    user_query: pendingTurn.user_query,
+                    ts: pendingTurn.ts,
+                }
+                : undefined,
+            directives: [], // Will be fetched separately if needed
+            patterns: [],
+            metadata: {
+                acked_turn_id: meta?.acked_turn_id || 0,
+                last_flush_ts: meta?.last_flush_ts || new Date().toISOString(),
+                token_estimate: Math.ceil(totalChars / 4),
+                complete_turn_count: completeTurns.length,
+                has_pending: !!pendingTurn,
+            },
+        };
+        return {
+            success: true,
+            data: payload,
+            source: 'local',
+            latency_ms: Date.now() - startTime,
+        };
+    }
+    /**
+     * Tier 1: Restore from Redis via API
+     */
+    async restoreFromRedis(sessionName, lastN) {
+        const startTime = Date.now();
+        if (!this.authToken) {
+            return {
+                success: false,
+                error: 'No auth token configured',
+                source: 'redis',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        try {
+            const url = `${MEMORY_API_URL}/api/v1/working/restore?session=${encodeURIComponent(sessionName)}&full=true&limit=${lastN}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(5000), // 5 second timeout
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: `Redis API returned ${response.status}`,
+                    source: 'redis',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            const data = await response.json();
+            if (data.mode === 'full_restore' && data.turns && data.turns.length > 0) {
+                const allTurns = data.turns.map((t, idx) => ({
+                    turn_id: t.turn_number || idx + 1,
+                    ts: t.timestamp || new Date().toISOString(),
+                    user_query: t.user?.query || '',
+                    assistant_response: t.agent?.response || '',
+                    tools_used: t.agent?.tools_used || [],
+                    files_referenced: t.user?.files_referenced || [],
+                    is_complete: (0, types_js_1.isValidAssistantResponse)(t.agent?.response),
+                }));
+                // Separate complete turns from pending
+                const completeTurns = allTurns.filter((t) => t.is_complete);
+                const pendingTurns = allTurns.filter((t) => !t.is_complete);
+                const pendingTurn = pendingTurns.length > 0 ? pendingTurns[pendingTurns.length - 1] : undefined;
+                if (completeTurns.length === 0) {
+                    return {
+                        success: false,
+                        error: pendingTurn
+                            ? `No complete turns in Redis. Pending: "${pendingTurn.user_query.slice(0, 50)}..."`
+                            : 'No complete turns found in Redis',
+                        source: 'redis',
+                        latency_ms: Date.now() - startTime,
+                    };
+                }
+                const turns = completeTurns;
+                const latest = turns[turns.length - 1]; // Guaranteed to be complete
+                const payload = {
+                    session_id: data.session_id || sessionName,
+                    session_name: data.session_name || sessionName,
+                    source: 'redis',
+                    restored_turns: turns,
+                    latest: {
+                        user_query: latest.user_query,
+                        assistant_response: latest.assistant_response,
+                    },
+                    pending_turn: pendingTurn
+                        ? {
+                            turn_id: pendingTurn.turn_id,
+                            user_query: pendingTurn.user_query,
+                            ts: pendingTurn.ts,
+                        }
+                        : undefined,
+                    directives: [],
+                    patterns: [],
+                    metadata: {
+                        acked_turn_id: turns.length,
+                        last_flush_ts: new Date().toISOString(),
+                        token_estimate: data.token_estimate || 0,
+                        complete_turn_count: completeTurns.length,
+                        has_pending: !!pendingTurn,
+                    },
+                };
+                return {
+                    success: true,
+                    data: payload,
+                    source: 'redis',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            return {
+                success: false,
+                error: 'No turns found in Redis',
+                source: 'redis',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+                source: 'redis',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Tier 2: Restore from Supabase via API
+     */
+    async restoreFromSupabase(sessionId, lastN) {
+        const startTime = Date.now();
+        if (!this.authToken) {
+            return {
+                success: false,
+                error: 'No auth token configured',
+                source: 'supabase',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        try {
+            // Use the episodic memory API to get conversations
+            const url = `${MEMORY_API_URL}/api/v1/memory/recall?session_id=${encodeURIComponent(sessionId)}&limit=${lastN}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(10000), // 10 second timeout for cold storage
+            });
+            if (!response.ok) {
+                return {
+                    success: false,
+                    error: `Supabase API returned ${response.status}`,
+                    source: 'supabase',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            const data = await response.json();
+            if (data.conversations && data.conversations.length > 0) {
+                const allTurns = data.conversations.map((c, idx) => ({
+                    turn_id: idx + 1,
+                    ts: c.processed_at || c.created_at || new Date().toISOString(),
+                    user_query: c.user_query || '',
+                    assistant_response: c.assistant_response || '',
+                    tools_used: [],
+                    files_referenced: c.metadata?.file_changes?.map((f) => f.path) || [],
+                    is_complete: (0, types_js_1.isValidAssistantResponse)(c.assistant_response),
+                }));
+                // Separate complete turns from pending
+                const completeTurns = allTurns.filter((t) => t.is_complete);
+                const pendingTurns = allTurns.filter((t) => !t.is_complete);
+                const pendingTurn = pendingTurns.length > 0 ? pendingTurns[pendingTurns.length - 1] : undefined;
+                if (completeTurns.length === 0) {
+                    return {
+                        success: false,
+                        error: pendingTurn
+                            ? `No complete turns in Supabase. Pending: "${pendingTurn.user_query.slice(0, 50)}..."`
+                            : 'No complete turns found in Supabase',
+                        source: 'supabase',
+                        latency_ms: Date.now() - startTime,
+                    };
+                }
+                const turns = completeTurns;
+                const latest = turns[turns.length - 1]; // Guaranteed to be complete
+                const payload = {
+                    session_id: sessionId,
+                    session_name: data.session_name || 'unknown',
+                    source: 'supabase',
+                    restored_turns: turns,
+                    latest: {
+                        user_query: latest.user_query,
+                        assistant_response: latest.assistant_response,
+                    },
+                    pending_turn: pendingTurn
+                        ? {
+                            turn_id: pendingTurn.turn_id,
+                            user_query: pendingTurn.user_query,
+                            ts: pendingTurn.ts,
+                        }
+                        : undefined,
+                    directives: [],
+                    patterns: [],
+                    metadata: {
+                        acked_turn_id: turns.length,
+                        last_flush_ts: new Date().toISOString(),
+                        token_estimate: 0,
+                        complete_turn_count: completeTurns.length,
+                        has_pending: !!pendingTurn,
+                    },
+                };
+                return {
+                    success: true,
+                    data: payload,
+                    source: 'supabase',
+                    latency_ms: Date.now() - startTime,
+                };
+            }
+            return {
+                success: false,
+                error: 'No conversations found in Supabase',
+                source: 'supabase',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+                source: 'supabase',
+                latency_ms: Date.now() - startTime,
+            };
+        }
+    }
+    /**
+     * Format RestorePayload as system-reminder markdown
+     */
+    formatAsSystemReminder(payload) {
+        const lines = [
+            '<system-reminder>',
+            'CONTEXT RESTORED (ekkOS /continue)',
+            `Session: ${payload.session_name} (${payload.session_id})`,
+            `Source: ${payload.source}`,
+            `Turns restored: ${payload.restored_turns.length}`,
+            '',
+            '## Last User Request',
+            payload.latest.user_query,
+            '',
+            '## Last Assistant Response',
+            payload.latest.assistant_response.slice(0, 2000),
+            payload.latest.assistant_response.length > 2000 ? '\n[...truncated...]' : '',
+            '',
+            '## Recent Turns (older → newer)',
+        ];
+        // Add turn summaries (skip last one since it's shown in detail above)
+        const turnsToShow = payload.restored_turns.slice(0, -1);
+        for (let i = 0; i < turnsToShow.length; i++) {
+            const turn = turnsToShow[i];
+            const userSnippet = turn.user_query.slice(0, 100) + (turn.user_query.length > 100 ? '...' : '');
+            const assistantSnippet = turn.assistant_response.slice(0, 100) + (turn.assistant_response.length > 100 ? '...' : '');
+            lines.push(`${i + 1}) U: ${userSnippet}`);
+            lines.push(`   A: ${assistantSnippet}`);
+        }
+        lines.push('');
+        lines.push('INSTRUCTION: Resume seamlessly where you left off.');
+        lines.push('Do not ask "what were we doing?"');
+        lines.push('Start your response with: "✓ Continuing -"');
+        lines.push('</system-reminder>');
+        return lines.join('\n');
+    }
+    /**
+     * Get restore statistics
+     */
+    getStats() {
+        const stats = this.localStore.getStats();
+        return {
+            local_sessions: stats.session_count,
+            local_turns: stats.total_turns,
+            local_size_bytes: stats.cache_size_bytes,
+        };
+    }
+}
+exports.RestoreOrchestrator = RestoreOrchestrator;
+// Export singleton instance
+exports.restoreOrchestrator = new RestoreOrchestrator();

package/dist/restore/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * ekkOS Fast /continue - Restore Module
+ */
+export * from './RestoreOrchestrator.js';

package/dist/restore/index.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * ekkOS Fast /continue - Restore Module
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RestoreOrchestrator.js"), exports);

package/dist/utils/platform.d.ts

@@ -0,0 +1,29 @@
+export declare const isWindows: boolean;
+export declare const isMac: boolean;
+export declare const isLinux: boolean;
+export declare const PLATFORM_URL = "https://platform.ekkos.dev";
+export declare const MCP_API_URL = "https://mcp.ekkos.dev";
+export declare const HOME_DIR: string;
+export declare const EKKOS_DIR: string;
+export declare const EKKOS_CONFIG: string;
+export declare const CLAUDE_DIR: string;
+export declare const CLAUDE_CONFIG: string;
+export declare const CLAUDE_SETTINGS: string;
+export declare const CLAUDE_HOOKS_DIR: string;
+export declare const CLAUDE_SKILLS_DIR: string;
+export declare const CLAUDE_AGENTS_DIR: string;
+export declare const CLAUDE_PLUGINS_DIR: string;
+export declare const CLAUDE_STATE_DIR: string;
+export declare const CLAUDE_MD: string;
+export declare const CURSOR_DIR: string;
+export declare const CURSOR_MCP: string;
+export declare const WINDSURF_DIR: string;
+export declare const WINDSURF_MCP: string;
+/**
+ * Detect which IDEs are installed on this system
+ */
+export declare function detectInstalledIDEs(): string[];
+/**
+ * Get the current running IDE from environment
+ */
+export declare function detectCurrentIDE(): string | null;

package/dist/utils/platform.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WINDSURF_MCP = exports.WINDSURF_DIR = exports.CURSOR_MCP = exports.CURSOR_DIR = exports.CLAUDE_MD = exports.CLAUDE_STATE_DIR = exports.CLAUDE_PLUGINS_DIR = exports.CLAUDE_AGENTS_DIR = exports.CLAUDE_SKILLS_DIR = exports.CLAUDE_HOOKS_DIR = exports.CLAUDE_SETTINGS = exports.CLAUDE_CONFIG = exports.CLAUDE_DIR = exports.EKKOS_CONFIG = exports.EKKOS_DIR = exports.HOME_DIR = exports.MCP_API_URL = exports.PLATFORM_URL = exports.isLinux = exports.isMac = exports.isWindows = void 0;
+exports.detectInstalledIDEs = detectInstalledIDEs;
+exports.detectCurrentIDE = detectCurrentIDE;
+const os_1 = require("os");
+const path_1 = require("path");
+const fs_1 = require("fs");
+exports.isWindows = (0, os_1.platform)() === 'win32';
+exports.isMac = (0, os_1.platform)() === 'darwin';
+exports.isLinux = (0, os_1.platform)() === 'linux';
+exports.PLATFORM_URL = 'https://platform.ekkos.dev';
+exports.MCP_API_URL = 'https://mcp.ekkos.dev';
+// Common directories
+exports.HOME_DIR = (0, os_1.homedir)();
+exports.EKKOS_DIR = (0, path_1.join)(exports.HOME_DIR, '.ekkos');
+exports.EKKOS_CONFIG = (0, path_1.join)(exports.EKKOS_DIR, 'config.json');
+exports.CLAUDE_DIR = (0, path_1.join)(exports.HOME_DIR, '.claude');
+exports.CLAUDE_CONFIG = (0, path_1.join)(exports.HOME_DIR, '.claude.json');
+exports.CLAUDE_SETTINGS = (0, path_1.join)(exports.CLAUDE_DIR, 'settings.json');
+exports.CLAUDE_HOOKS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'hooks');
+exports.CLAUDE_SKILLS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'skills');
+exports.CLAUDE_AGENTS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'agents');
+exports.CLAUDE_PLUGINS_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'plugins', 'ekkos');
+exports.CLAUDE_STATE_DIR = (0, path_1.join)(exports.CLAUDE_DIR, 'state');
+exports.CLAUDE_MD = (0, path_1.join)(exports.CLAUDE_DIR, 'CLAUDE.md');
+exports.CURSOR_DIR = (0, path_1.join)(exports.HOME_DIR, '.cursor');
+exports.CURSOR_MCP = (0, path_1.join)(exports.CURSOR_DIR, 'mcp.json');
+exports.WINDSURF_DIR = (0, path_1.join)(exports.HOME_DIR, '.codeium', 'windsurf');
+exports.WINDSURF_MCP = (0, path_1.join)(exports.WINDSURF_DIR, 'mcp_config.json');
+/**
+ * Detect which IDEs are installed on this system
+ */
+function detectInstalledIDEs() {
+    const ides = [];
+    // Check Claude Code
+    if ((0, fs_1.existsSync)(exports.CLAUDE_DIR) || process.env.CLAUDE_CODE) {
+        ides.push('claude');
+    }
+    // Check Cursor
+    if ((0, fs_1.existsSync)(exports.CURSOR_DIR)) {
+        ides.push('cursor');
+    }
+    // Check Windsurf
+    if ((0, fs_1.existsSync)(exports.WINDSURF_DIR)) {
+        ides.push('windsurf');
+    }
+    return ides;
+}
+/**
+ * Get the current running IDE from environment
+ */
+function detectCurrentIDE() {
+    const termProgram = process.env.TERM_PROGRAM?.toLowerCase() || '';
+    const termEmulator = process.env.TERMINAL_EMULATOR?.toLowerCase() || '';
+    if (termProgram.includes('cursor'))
+        return 'cursor';
+    if (termProgram.includes('vscode') || termEmulator.includes('vscode'))
+        return 'vscode';
+    if (termProgram.includes('windsurf') || termProgram.includes('codeium'))
+        return 'windsurf';
+    if (process.env.CLAUDE_CODE)
+        return 'claude';
+    return null;
+}