@ekkos/cli 0.2.18 → 0.3.3

package/dist/lib/usage-parser.d.ts

@@ -0,0 +1,72 @@
+export interface TurnMetrics {
+    turn_number: number;
+    timestamp: string;
+    input_tokens: number;
+    output_tokens: number;
+    cache_read_tokens: number;
+    cache_creation_tokens: number;
+    total_tokens: number;
+    context_percentage: number;
+    model: string;
+}
+export interface SessionUsage {
+    session_id: string;
+    instance_id: string;
+    session_name: string;
+    turn_count: number;
+    total_input_tokens: number;
+    total_output_tokens: number;
+    total_cache_read_tokens: number;
+    total_cache_creation_tokens: number;
+    total_tokens: number;
+    total_cost: number;
+    avg_context_percentage: number;
+    max_context_percentage: number;
+    started_at: string;
+    last_activity: string;
+    models_used: string[];
+    turns: TurnMetrics[];
+    patterns_retrieved?: number;
+    patterns_applied?: number;
+    patterns_learned?: number;
+    confidence_gain?: number;
+}
+export interface CcusageSession {
+    sessionId: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    totalTokens: number;
+    totalCost: number;
+    lastActivity: string;
+    modelsUsed: string[];
+    modelBreakdowns: {
+        modelName: string;
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        cost: number;
+    }[];
+    projectPath: string;
+}
+export interface CcusageOutput {
+    sessions: CcusageSession[];
+}
+/**
+ * Get all sessions using ccusage
+ */
+export declare function getAllSessions(instanceId?: string): Promise<SessionUsage[]>;
+/**
+ * Get specific session usage using ccusage
+ */
+export declare function getSessionUsage(sessionId: string, instanceId?: string): Promise<SessionUsage | null>;
+/**
+ * Get human-readable session name
+ */
+export declare function getSessionName(sessionId: string): string;
+/**
+ * Get current session ID from active Claude Code process
+ */
+export declare function getCurrentSessionId(): string | null;

package/dist/lib/usage-parser.js

@@ -0,0 +1,238 @@
+"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.getAllSessions = getAllSessions;
+exports.getSessionUsage = getSessionUsage;
+exports.getSessionName = getSessionName;
+exports.getCurrentSessionId = getCurrentSessionId;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Get all sessions using ccusage
+ */
+async function getAllSessions(instanceId) {
+    try {
+        // Run ccusage to get all sessions
+        const result = (0, child_process_1.execSync)('npx -y ccusage@latest session --json --breakdown', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'], // Suppress npm warnings
+        });
+        const data = JSON.parse(result);
+        // Convert ccusage format to our format
+        const sessions = await Promise.all(data.sessions.map(async (session) => convertCcusageSession(session, instanceId)));
+        return sessions.filter((s) => s !== null);
+    }
+    catch (error) {
+        console.error('Failed to fetch sessions from ccusage:', error);
+        return [];
+    }
+}
+/**
+ * Get specific session usage using ccusage
+ */
+async function getSessionUsage(sessionId, instanceId) {
+    try {
+        // Run ccusage to get all sessions (--id flag doesn't work for IDs with dashes)
+        const result = (0, child_process_1.execSync)('npx -y ccusage@latest session --json --breakdown', {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'ignore'], // Suppress npm warnings
+        });
+        const data = JSON.parse(result);
+        // Find the specific session
+        const session = data.sessions.find(s => s.sessionId === sessionId);
+        if (!session) {
+            return null;
+        }
+        return convertCcusageSession(session, instanceId);
+    }
+    catch (error) {
+        console.error('Failed to fetch session from ccusage:', error);
+        return null;
+    }
+}
+/**
+ * Convert ccusage session to our SessionUsage format
+ */
+async function convertCcusageSession(session, instanceId) {
+    // Try to get turn-by-turn data from Claude Code's JSONL files
+    const turns = 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
+    let patternMetrics;
+    try {
+        patternMetrics = await fetchPatternMetrics(session.sessionId);
+    }
+    catch {
+        // Fail silently if memory API not available
+    }
+    return {
+        session_id: session.sessionId,
+        instance_id: instanceId || 'unknown',
+        session_name: getSessionName(session.sessionId),
+        turn_count: turns.length || 0,
+        total_input_tokens: session.inputTokens,
+        total_output_tokens: session.outputTokens,
+        total_cache_read_tokens: session.cacheReadTokens,
+        total_cache_creation_tokens: session.cacheCreationTokens,
+        total_tokens: session.totalTokens,
+        total_cost: session.totalCost,
+        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
+ */
+async function getTurnMetrics(sessionId, instanceId) {
+    // Try multiple possible locations for Claude Code JSONL files
+    const possiblePaths = [
+        path.join(os.homedir(), '.claude', 'projects', instanceId || '', `${sessionId}.jsonl`),
+        path.join(os.homedir(), '.config', 'claude', 'projects', instanceId || '', `${sessionId}.jsonl`),
+        path.join(os.homedir(), '.codex', instanceId || '', `${sessionId}.jsonl`),
+    ];
+    for (const filePath of possiblePaths) {
+        if (fs.existsSync(filePath)) {
+            try {
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const lines = content.trim().split('\n');
+                const turns = [];
+                for (const line of lines) {
+                    try {
+                        const entry = JSON.parse(line);
+                        // Look for usage events
+                        if (entry.type === 'usage' || entry.usage) {
+                            const usage = entry.usage || entry;
+                            turns.push({
+                                turn_number: turns.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.model || 'unknown',
+                            });
+                        }
+                    }
+                    catch {
+                        // Skip invalid JSON lines
+                    }
+                }
+                return turns;
+            }
+            catch {
+                // Continue to next path
+            }
+        }
+    }
+    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;
+}

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,

package/dist/restore/RestoreOrchestrator.js

@@ -58,8 +58,10 @@ const types_js_1 = require("../cache/types.js");
 const stream_tailer_js_1 = require("../capture/stream-tailer.js");
 const paths_js_1 = require("../utils/paths.js");
 // API configuration
-const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://api.ekkos.dev';
+const MEMORY_API_URL = process.env.EKKOS_API_URL || 'https://mcp.ekkos.dev';
 const CONFIG_PATH = path.join(os.homedir(), '.ekkos', 'config.json');
+// Rehydration patterns
+const STUB_REGEX = /\[ekkOS:page-out:r2:\/\/([^/]+)\/([^/]+)\/([^/]+)\/([^\]?]+)(?:\?range=(\d+)-(\d+))?\]/g;
 /**
  * Load auth token from config
  */
@@ -122,45 +124,131 @@ class RestoreOrchestrator {
                 latency_ms: Date.now() - startTime,
             };
         }
+        let result;
         // Try Tier -1: Stream log (has mid-turn content, most recent data)
         const streamResult = await this.restoreFromStreamLog(instanceId, sessionId, sessionName || '', lastN);
         if (streamResult.success && streamResult.data) {
-            return {
-                ...streamResult,
-                latency_ms: Date.now() - startTime,
-            };
+            result = streamResult;
         }
-        // Try Tier 0: Local cache
-        const localResult = await this.restoreFromLocal(instanceId, 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, instanceId);
-        if (redisResult.success && redisResult.data) {
-            return {
-                ...redisResult,
-                latency_ms: Date.now() - startTime,
-            };
+        else {
+            // Try Tier 0: Local cache
+            const localResult = await this.restoreFromLocal(instanceId, sessionId, sessionName || '', lastN);
+            if (localResult.success && localResult.data) {
+                result = localResult;
+            }
+            else {
+                // Try Tier 1: Redis
+                const redisResult = await this.restoreFromRedis(sessionName || sessionId, lastN, instanceId);
+                if (redisResult.success && redisResult.data) {
+                    result = redisResult;
+                }
+                else {
+                    // Try Tier 2: Supabase
+                    const supabaseResult = await this.restoreFromSupabase(sessionId, lastN, instanceId);
+                    if (supabaseResult.success && supabaseResult.data) {
+                        result = supabaseResult;
+                    }
+                    else {
+                        // 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,
+                        };
+                    }
+                }
+            }
         }
-        // Try Tier 2: Supabase
-        const supabaseResult = await this.restoreFromSupabase(sessionId, lastN, instanceId);
-        if (supabaseResult.success && supabaseResult.data) {
-            return {
-                ...supabaseResult,
-                latency_ms: Date.now() - startTime,
-            };
+        // Rehydrate stubs if any found in restored payload
+        if (result.success && result.data) {
+            await this.rehydratePayload(result.data);
         }
-        // All tiers failed
         return {
-            success: false,
-            error: `All restore tiers failed. Local: ${localResult.error}, Redis: ${redisResult.error}, Supabase: ${supabaseResult.error}`,
+            ...result,
             latency_ms: Date.now() - startTime,
         };
     }
+    /**
+     * Scan payload for [ekkOS:page-out:...] stubs and rehydrate from Proxy
+     */
+    async rehydratePayload(payload) {
+        const stubs = new Set();
+        // Scan all restored turns (both user queries and assistant responses)
+        // Stubs are injected as user messages, so check user_query too
+        for (const turn of payload.restored_turns) {
+            for (const text of [turn.user_query, turn.assistant_response]) {
+                if (!text)
+                    continue;
+                STUB_REGEX.lastIndex = 0;
+                const matches = text.match(STUB_REGEX);
+                if (matches) {
+                    for (const match of matches)
+                        stubs.add(match);
+                }
+            }
+        }
+        // Also scan latest (both user and assistant)
+        for (const text of [payload.latest.user_query, payload.latest.assistant_response]) {
+            if (!text)
+                continue;
+            STUB_REGEX.lastIndex = 0;
+            const matches = text.match(STUB_REGEX);
+            if (matches) {
+                for (const match of matches)
+                    stubs.add(match);
+            }
+        }
+        if (stubs.size === 0)
+            return;
+        console.log(`[Restore] Detected ${stubs.size} stubs, rehydrating...`);
+        try {
+            const url = `${MEMORY_API_URL}/api/v1/context/rehydrate`;
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${this.authToken}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ stubs: Array.from(stubs) }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!response.ok) {
+                console.warn(`[Restore] Rehydration API failed: ${response.status}`);
+                return;
+            }
+            const { rehydrated } = await response.json();
+            if (!rehydrated || !Array.isArray(rehydrated))
+                return;
+            // Create mapping of stub -> content
+            const stubMap = new Map();
+            for (const entry of rehydrated) {
+                const content = entry.messages.map((m) => {
+                    const role = m.role === 'user' ? 'U' : 'A';
+                    const text = typeof m.content === 'string'
+                        ? m.content
+                        : Array.isArray(m.content)
+                            ? m.content.map((b) => b.text || '').join('\n')
+                            : '';
+                    return `${role}: ${text}`;
+                }).join('\n\n');
+                stubMap.set(entry.stub, content);
+            }
+            // Replace stubs in turns
+            for (const turn of payload.restored_turns) {
+                for (const [stub, content] of stubMap.entries()) {
+                    turn.assistant_response = turn.assistant_response.replace(stub, `[REHYDRATED CONTENT]\n${content}`);
+                }
+            }
+            // Replace stubs in latest
+            for (const [stub, content] of stubMap.entries()) {
+                payload.latest.assistant_response = payload.latest.assistant_response.replace(stub, `[REHYDRATED CONTENT]\n${content}`);
+            }
+            console.log(`[Restore] Successfully rehydrated ${stubMap.size} stubs`);
+        }
+        catch (err) {
+            console.warn(`[Restore] Rehydration error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     /**
      * Tier -1: Restore from stream log (has mid-turn content)
      * This is checked FIRST because stream logs have the most recent data,

package/package.json

@@ -1,19 +1,13 @@
 {
   "name": "@ekkos/cli",
-  "version": "0.2.18",
+  "version": "0.3.3",
   "description": "Setup ekkOS memory for AI coding assistants (Claude Code, Cursor, Windsurf)",
   "main": "dist/index.js",
   "bin": {
     "ekkos": "dist/index.js",
     "cli": "dist/index.js",
-    "ekkos-capture": "dist/cache/capture.js"
-  },
-  "scripts": {
-    "build": "tsc",
-    "dev": "ts-node src/index.ts",
-    "prepack": "node scripts/build-templates.js prepack",
-    "postpack": "node scripts/build-templates.js postpack",
-    "prepublishOnly": "npm run build"
+    "ekkos-capture": "dist/cache/capture.js",
+    "ekkos-promote": "dist/cron/promoter.js"
   },
   "keywords": [
     "ekkos",
@@ -28,13 +22,15 @@
   "author": "ekkOS",
   "license": "MIT",
   "dependencies": {
+    "@supabase/supabase-js": "^2.39.8",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "inquirer": "^9.2.23",
     "node-pty": "1.2.0-beta.7",
     "open": "^10.0.0",
     "ora": "^8.0.1",
-    "ws": "^8.19.0"
+    "ws": "^8.19.0",
+    "@ekkos/prometheus": "0.1.0"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
@@ -46,5 +42,9 @@
   "files": [
     "dist",
     "templates"
-  ]
-}
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts"
+  }
+}

package/templates/ekkos-manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://ekkos.dev/schemas/manifest-v1.json",
   "manifestVersion": "1.0.0",
-  "generatedAt": "2026-01-22T06:19:22.744Z",
+  "generatedAt": "2026-02-04T04:30:49.260Z",
   "platforms": {
     "darwin": {
       "configDir": "~/.ekkos",
@@ -68,7 +68,7 @@
           "source": "hooks/user-prompt-submit.sh",
           "destination": "user-prompt-submit.sh",
           "description": "User prompt submit hook (Unix)",
-          "checksum": "0e006eb7becba874f34fc622c9ee83b3c96a6e00daf95db840369894af94abf3",
+          "checksum": "38aa190d08e2c24129e7f653732a860693fbd2a7015e59226aec57e8b3659114",
           "executable": true
         },
         {