@ekkos/cli 0.2.18 → 1.0.0

package/dist/lib/usage-parser.js

@@ -0,0 +1,583 @@
+"use strict";
+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.isEkkosSessionName = isEkkosSessionName;
+exports.resolveSessionName = resolveSessionName;
+exports.getSessionUsageByName = getSessionUsageByName;
+exports.listEkkosSessions = listEkkosSessions;
+exports.getAllSessions = getAllSessions;
+exports.getSessionUsage = getSessionUsage;
+exports.getSessionName = getSessionName;
+exports.getCurrentSessionId = getCurrentSessionId;
+exports.getDailyUsage = getDailyUsage;
+exports.getWeeklyUsage = getWeeklyUsage;
+exports.getMonthlyUsage = getMonthlyUsage;
+exports.getBucketUsage = getBucketUsage;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// ── Anthropic model pricing per 1M tokens ──────────────────────────────────
+const MODEL_PRICING = {
+    'claude-opus-4-6': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-opus-4-5-20250620': { input: 15, output: 75, cacheWrite: 18.75, cacheRead: 1.50 },
+    'claude-sonnet-4-5-20250929': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    'claude-sonnet-4-5-20250514': { input: 3, output: 15, cacheWrite: 3.75, cacheRead: 0.30 },
+    'claude-haiku-4-5-20251001': { input: 0.80, output: 4, cacheWrite: 1.00, cacheRead: 0.08 },
+};
+function getModelPricing(modelId) {
+    if (MODEL_PRICING[modelId])
+        return MODEL_PRICING[modelId];
+    if (modelId.includes('opus'))
+        return MODEL_PRICING['claude-opus-4-6'];
+    if (modelId.includes('sonnet'))
+        return MODEL_PRICING['claude-sonnet-4-5-20250929'];
+    if (modelId.includes('haiku'))
+        return MODEL_PRICING['claude-haiku-4-5-20251001'];
+    return MODEL_PRICING['claude-sonnet-4-5-20250929']; // fallback
+}
+function calculateTurnCost(model, usage) {
+    const p = getModelPricing(model);
+    return ((usage.input_tokens / 1000000) * p.input +
+        (usage.output_tokens / 1000000) * p.output +
+        (usage.cache_creation_tokens / 1000000) * p.cacheWrite +
+        (usage.cache_read_tokens / 1000000) * p.cacheRead);
+}
+/** Detect ekkOS 3-word session names like "lit-lex-zip" */
+function isEkkosSessionName(name) {
+    return /^[a-z]+-[a-z]+-[a-z]+$/.test(name);
+}
+function encodeProjectPath(projectPath) {
+    return projectPath.replace(/\//g, '-');
+}
+/** Resolve an ekkOS session name to a JSONL UUID */
+function resolveSessionName(name) {
+    // 1) Check active-sessions.json (most current)
+    const activeSessionsPath = path.join(os.homedir(), '.ekkos', 'active-sessions.json');
+    if (fs.existsSync(activeSessionsPath)) {
+        try {
+            const sessions = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf-8'));
+            // Find first entry with a valid UUID sessionId (skip "unknown" or empty)
+            const match = sessions.find(s => s.sessionName === name && s.sessionId && s.sessionId !== 'unknown' && s.sessionId.length > 8);
+            if (match) {
+                return {
+                    uuid: match.sessionId,
+                    sessionName: match.sessionName,
+                    projectPath: match.projectPath,
+                    encodedProjectPath: encodeProjectPath(match.projectPath),
+                    startedAt: match.startedAt,
+                };
+            }
+        }
+        catch { /* ignore */ }
+    }
+    // 2) Fallback: scan local cache index
+    const cacheDir = path.join(os.homedir(), '.ekkos', 'cache', 'sessions');
+    if (fs.existsSync(cacheDir)) {
+        try {
+            const instances = fs.readdirSync(cacheDir).filter(f => fs.statSync(path.join(cacheDir, f)).isDirectory());
+            for (const inst of instances) {
+                const indexPath = path.join(cacheDir, inst, 'index.json');
+                if (fs.existsSync(indexPath)) {
+                    const index = JSON.parse(fs.readFileSync(indexPath, 'utf-8'));
+                    if (index[name]) {
+                        return {
+                            uuid: index[name].session_id,
+                            sessionName: name,
+                            projectPath: index[name].project_path || '',
+                            encodedProjectPath: encodeProjectPath(index[name].project_path || ''),
+                        };
+                    }
+                }
+            }
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
+/** Parse a single JSONL file and return SessionUsage for an ekkOS-named session */
+async function getSessionUsageByName(name) {
+    const resolved = resolveSessionName(name);
+    if (!resolved)
+        return null;
+    const jsonlPath = path.join(os.homedir(), '.claude', 'projects', resolved.encodedProjectPath, `${resolved.uuid}.jsonl`);
+    if (!fs.existsSync(jsonlPath))
+        return null;
+    const content = fs.readFileSync(jsonlPath, 'utf-8');
+    const lines = content.trim().split('\n');
+    const turns = [];
+    let totalCost = 0;
+    const modelsUsed = new Set();
+    let startedAt = '';
+    let lastActivity = '';
+    const seenMessageIds = new Set();
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            if (entry.type === 'assistant' && entry.message?.usage) {
+                // Deduplicate: Claude Code writes one JSONL entry per content block
+                // (thinking, text, tool_use) but they share the same message.id and usage stats.
+                const msgId = entry.message.id;
+                if (msgId && seenMessageIds.has(msgId))
+                    continue;
+                if (msgId)
+                    seenMessageIds.add(msgId);
+                const usage = entry.message.usage;
+                const model = entry.message.model || 'unknown';
+                modelsUsed.add(model);
+                const inputTokens = usage.input_tokens || 0;
+                const outputTokens = usage.output_tokens || 0;
+                const cacheReadTokens = usage.cache_read_input_tokens || 0;
+                const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+                const totalTokens = inputTokens + outputTokens + cacheReadTokens + cacheCreationTokens;
+                const turnCost = calculateTurnCost(model, {
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_read_tokens: cacheReadTokens,
+                    cache_creation_tokens: cacheCreationTokens,
+                });
+                totalCost += turnCost;
+                const ts = entry.timestamp || new Date().toISOString();
+                if (!startedAt)
+                    startedAt = ts;
+                lastActivity = ts;
+                turns.push({
+                    turn_number: turns.length,
+                    timestamp: ts,
+                    input_tokens: inputTokens,
+                    output_tokens: outputTokens,
+                    cache_read_tokens: cacheReadTokens,
+                    cache_creation_tokens: cacheCreationTokens,
+                    total_tokens: totalTokens,
+                    context_percentage: calculateContextPercentage(usage),
+                    model,
+                });
+            }
+        }
+        catch { /* skip bad lines */ }
+    }
+    if (turns.length === 0)
+        return null;
+    const totalInputTokens = turns.reduce((s, t) => s + t.input_tokens, 0);
+    const totalOutputTokens = turns.reduce((s, t) => s + t.output_tokens, 0);
+    const totalCacheReadTokens = turns.reduce((s, t) => s + t.cache_read_tokens, 0);
+    const totalCacheCreationTokens = turns.reduce((s, t) => s + t.cache_creation_tokens, 0);
+    const totalTokens = totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheCreationTokens;
+    const avgContextPct = turns.reduce((s, t) => s + t.context_percentage, 0) / turns.length;
+    const maxContextPct = Math.max(...turns.map(t => t.context_percentage));
+    let patternMetrics;
+    try {
+        patternMetrics = await fetchPatternMetrics(resolved.uuid);
+    }
+    catch { /* ok */ }
+    return {
+        session_id: resolved.uuid,
+        instance_id: resolved.encodedProjectPath,
+        session_name: name,
+        turn_count: turns.length,
+        total_input_tokens: totalInputTokens,
+        total_output_tokens: totalOutputTokens,
+        total_cache_read_tokens: totalCacheReadTokens,
+        total_cache_creation_tokens: totalCacheCreationTokens,
+        total_tokens: totalTokens,
+        total_cost: totalCost,
+        avg_context_percentage: avgContextPct,
+        max_context_percentage: maxContextPct,
+        started_at: startedAt || resolved.startedAt || 'unknown',
+        last_activity: lastActivity,
+        models_used: Array.from(modelsUsed),
+        turns,
+        ...patternMetrics,
+    };
+}
+/** List ekkOS sessions with lightweight cost data (for session list view) */
+async function listEkkosSessions(limit = 30) {
+    const activeSessionsPath = path.join(os.homedir(), '.ekkos', 'active-sessions.json');
+    if (!fs.existsSync(activeSessionsPath))
+        return [];
+    let sessions;
+    try {
+        sessions = JSON.parse(fs.readFileSync(activeSessionsPath, 'utf-8'));
+    }
+    catch {
+        return [];
+    }
+    // Filter to valid 3-word ekkOS names only, sort by lastHeartbeat descending
+    sessions = sessions
+        .filter(s => isEkkosSessionName(s.sessionName))
+        .sort((a, b) => (b.lastHeartbeat || '').localeCompare(a.lastHeartbeat || ''))
+        .slice(0, limit);
+    const results = [];
+    for (const s of sessions) {
+        const encoded = encodeProjectPath(s.projectPath);
+        const jsonlPath = path.join(os.homedir(), '.claude', 'projects', encoded, `${s.sessionId}.jsonl`);
+        let cost = 0;
+        let tokens = 0;
+        let turnCount = 0;
+        const models = new Set();
+        const seenMsgIds = new Set();
+        if (fs.existsSync(jsonlPath)) {
+            try {
+                const content = fs.readFileSync(jsonlPath, 'utf-8');
+                for (const line of content.trim().split('\n')) {
+                    try {
+                        const entry = JSON.parse(line);
+                        if (entry.type === 'assistant' && entry.message?.usage) {
+                            // Deduplicate: multiple content blocks per API call share same message.id
+                            const msgId = entry.message.id;
+                            if (msgId && seenMsgIds.has(msgId))
+                                continue;
+                            if (msgId)
+                                seenMsgIds.add(msgId);
+                            const u = entry.message.usage;
+                            const model = entry.message.model || 'unknown';
+                            models.add(model);
+                            turnCount++;
+                            const inp = u.input_tokens || 0;
+                            const out = u.output_tokens || 0;
+                            const cr = u.cache_read_input_tokens || 0;
+                            const cc = u.cache_creation_input_tokens || 0;
+                            tokens += inp + out + cr + cc;
+                            cost += calculateTurnCost(model, {
+                                input_tokens: inp,
+                                output_tokens: out,
+                                cache_read_tokens: cr,
+                                cache_creation_tokens: cc,
+                            });
+                        }
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            catch { /* skip */ }
+        }
+        // Only include sessions that have actual JSONL data
+        if (turnCount > 0) {
+            results.push({
+                name: s.sessionName,
+                uuid: s.sessionId,
+                projectPath: s.projectPath,
+                startedAt: s.startedAt,
+                lastHeartbeat: s.lastHeartbeat,
+                cost,
+                tokens,
+                models: Array.from(models),
+                turnCount,
+            });
+        }
+    }
+    return results;
+}
+// Removed CcusageOutput - using direct import from ccusage/data-loader
+/**
+ * Get all sessions using ccusage library
+ */
+async function getAllSessions(instanceId) {
+    try {
+        // Use dynamic import for ESM module ccusage (type assertion to bypass TS module resolution)
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadSessionData();
+        // Convert ccusage format to our format (skip turn loading for performance in list view)
+        const sessions = await Promise.all(data.map(async (session) => convertCcusageSession(session, instanceId, true)));
+        return sessions.filter((s) => s !== null);
+    }
+    catch (error) {
+        console.error('Failed to fetch sessions from ccusage:', error);
+        return [];
+    }
+}
+/**
+ * Get specific session usage using ccusage library
+ */
+async function getSessionUsage(sessionId, instanceId) {
+    try {
+        // Use dynamic import for ESM module ccusage (type assertion to bypass TS module resolution)
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadSessionData();
+        // Find the specific session
+        const session = data.find((s) => s.sessionId === sessionId);
+        if (!session) {
+            return null;
+        }
+        // Load full turn data for specific session view
+        return convertCcusageSession(session, instanceId, false);
+    }
+    catch (error) {
+        console.error('Failed to fetch session from ccusage:', error);
+        return null;
+    }
+}
+/**
+ * Convert ccusage session to our SessionUsage format
+ * @param session - ccusage session data
+ * @param instanceId - project instance ID
+ * @param skipTurns - skip loading turn-by-turn data (for performance in list view)
+ */
+async function convertCcusageSession(session, instanceId, skipTurns = false) {
+    // Try to get turn-by-turn data from Claude Code's JSONL files (unless skipped for performance)
+    const turns = skipTurns ? [] : await getTurnMetrics(session.sessionId, instanceId);
+    // Calculate context percentages if we have turn data
+    let avgContextPercentage = 0;
+    let maxContextPercentage = 0;
+    if (turns.length > 0) {
+        avgContextPercentage =
+            turns.reduce((sum, t) => sum + t.context_percentage, 0) / turns.length;
+        maxContextPercentage = Math.max(...turns.map((t) => t.context_percentage));
+    }
+    // Try to fetch ekkOS pattern metrics from memory API (skip for list view for performance)
+    let patternMetrics;
+    if (!skipTurns) {
+        try {
+            patternMetrics = await fetchPatternMetrics(session.sessionId);
+        }
+        catch {
+            // Fail silently if memory API not available
+        }
+    }
+    // Compute total tokens (ccusage doesn't provide a totalTokens field)
+    const totalTokens = (session.inputTokens || 0) + (session.outputTokens || 0) +
+        (session.cacheCreationTokens || 0) + (session.cacheReadTokens || 0);
+    return {
+        session_id: session.sessionId,
+        instance_id: instanceId || 'unknown',
+        session_name: getSessionName(session.sessionId),
+        turn_count: turns.length || 0,
+        total_input_tokens: session.inputTokens || 0,
+        total_output_tokens: session.outputTokens || 0,
+        total_cache_read_tokens: session.cacheReadTokens || 0,
+        total_cache_creation_tokens: session.cacheCreationTokens || 0,
+        total_tokens: totalTokens,
+        total_cost: session.totalCost || session.cost || 0,
+        avg_context_percentage: avgContextPercentage,
+        max_context_percentage: maxContextPercentage,
+        started_at: turns[0]?.timestamp || 'unknown',
+        last_activity: session.lastActivity,
+        models_used: session.modelsUsed,
+        turns,
+        ...patternMetrics,
+    };
+}
+/**
+ * Get turn-by-turn metrics from Claude Code JSONL files
+ * sessionId from ccusage is the project path (e.g., '-Volumes-MacMiniPort-DEV-EKKOS')
+ * but JSONL files are named by UUID. So we need to scan all files in the directory.
+ */
+async function getTurnMetrics(sessionId, instanceId) {
+    // Possible project directories
+    const possibleDirs = [
+        path.join(os.homedir(), '.claude', 'projects', sessionId),
+        path.join(os.homedir(), '.config', 'claude', 'projects', sessionId),
+        path.join(os.homedir(), '.codex', sessionId),
+    ];
+    const allTurns = [];
+    const seenMsgIds = new Set();
+    for (const dir of possibleDirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        try {
+            // Get all JSONL files in this directory
+            const files = fs.readdirSync(dir).filter(f => f.endsWith('.jsonl'));
+            for (const file of files) {
+                const filePath = path.join(dir, file);
+                try {
+                    const content = fs.readFileSync(filePath, 'utf-8');
+                    const lines = content.trim().split('\n');
+                    for (const line of lines) {
+                        try {
+                            const entry = JSON.parse(line);
+                            // Look for assistant messages with usage data
+                            // Claude Code stores usage in entry.message.usage for type='assistant' entries
+                            if (entry.type === 'assistant' && entry.message?.usage) {
+                                // Deduplicate: multiple content blocks per API call share same message.id
+                                const msgId = entry.message?.id;
+                                if (msgId && seenMsgIds.has(msgId))
+                                    continue;
+                                if (msgId)
+                                    seenMsgIds.add(msgId);
+                                const usage = entry.message.usage;
+                                allTurns.push({
+                                    turn_number: allTurns.length,
+                                    timestamp: entry.timestamp || new Date().toISOString(),
+                                    input_tokens: usage.input_tokens || 0,
+                                    output_tokens: usage.output_tokens || 0,
+                                    cache_read_tokens: usage.cache_read_input_tokens || 0,
+                                    cache_creation_tokens: usage.cache_creation_input_tokens || 0,
+                                    total_tokens: (usage.input_tokens || 0) +
+                                        (usage.output_tokens || 0) +
+                                        (usage.cache_read_input_tokens || 0) +
+                                        (usage.cache_creation_input_tokens || 0),
+                                    context_percentage: calculateContextPercentage(usage),
+                                    model: entry.message?.model || 'unknown',
+                                });
+                            }
+                        }
+                        catch {
+                            // Skip invalid JSON lines
+                        }
+                    }
+                }
+                catch {
+                    // Skip unreadable files
+                }
+            }
+            // If we found any turns, return them (no need to check other directories)
+            if (allTurns.length > 0) {
+                // Sort by timestamp
+                allTurns.sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+                // Renumber turns after sorting
+                allTurns.forEach((turn, i) => turn.turn_number = i);
+                return allTurns;
+            }
+        }
+        catch {
+            // Continue to next directory
+        }
+    }
+    return [];
+}
+/**
+ * Calculate context percentage from usage data
+ */
+function calculateContextPercentage(usage) {
+    const totalTokens = (usage.input_tokens || 0) +
+        (usage.cache_read_input_tokens || 0) +
+        (usage.cache_creation_input_tokens || 0);
+    // Claude Code context window is typically 200k tokens
+    const contextWindow = 200000;
+    return (totalTokens / contextWindow) * 100;
+}
+/**
+ * Fetch pattern metrics from ekkOS memory API
+ */
+async function fetchPatternMetrics(sessionId) {
+    try {
+        const response = await fetch(`http://localhost:3001/api/v1/session/stats?session_id=${sessionId}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return null;
+        }
+        const data = await response.json();
+        return {
+            patterns_retrieved: data.patterns_retrieved || 0,
+            patterns_applied: data.patterns_applied || 0,
+            patterns_learned: data.patterns_learned || 0,
+            confidence_gain: data.confidence_gain || 0,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get human-readable session name
+ */
+function getSessionName(sessionId) {
+    // Extract last part of path-based session IDs
+    const parts = sessionId.split('/');
+    const lastPart = parts[parts.length - 1];
+    // If it's a UUID-like string, try to map to session name
+    // For now, just return a shortened version
+    if (lastPart.length > 20) {
+        return lastPart.substring(0, 8) + '...' + lastPart.substring(lastPart.length - 8);
+    }
+    return lastPart;
+}
+/**
+ * Get current session ID from active Claude Code process
+ */
+function getCurrentSessionId() {
+    // TODO: Extract from process environment or Claude Code state
+    // For now, require user to pass session ID
+    return null;
+}
+/**
+ * Load daily usage data via ccusage library
+ */
+async function getDailyUsage() {
+    try {
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadDailyUsageData();
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to load daily usage:', error);
+        return [];
+    }
+}
+/**
+ * Load weekly usage data via ccusage library
+ */
+async function getWeeklyUsage() {
+    try {
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadWeeklyUsageData();
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to load weekly usage:', error);
+        return [];
+    }
+}
+/**
+ * Load monthly usage data via ccusage library
+ */
+async function getMonthlyUsage() {
+    try {
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadMonthlyUsageData();
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to load monthly usage:', error);
+        return [];
+    }
+}
+/**
+ * Load bucket (5-hour block) usage data via ccusage library
+ */
+async function getBucketUsage() {
+    try {
+        const ccusage = await Promise.resolve(`${'ccusage/data-loader'}`).then(s => __importStar(require(s)));
+        const data = await ccusage.loadBucketUsageData();
+        return data;
+    }
+    catch (error) {
+        console.error('Failed to load bucket usage:', error);
+        return [];
+    }
+}

package/dist/restore/RestoreOrchestrator.d.ts

@@ -30,6 +30,10 @@ export declare class RestoreOrchestrator {
      * Main restore function - attempts tiers in order
      */
     restore(options?: RestoreOptions): Promise<CacheResult<RestorePayload>>;
+    /**
+     * Scan payload for [ekkOS:page-out:...] stubs and rehydrate from Proxy
+     */
+    private rehydratePayload;
     /**
      * Tier -1: Restore from stream log (has mid-turn content)
      * This is checked FIRST because stream logs have the most recent data,