@ekkos/cli 0.2.18 → 1.0.0

package/dist/lib/usage-monitor.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Simple usage monitoring for ekkOS embedding costs
+ * Tracks daily usage to prevent runaway costs
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUsage = loadUsage;
+exports.recordEmbedding = recordEmbedding;
+exports.getUsageForDate = getUsageForDate;
+exports.getUsageForDays = getUsageForDays;
+exports.checkThreshold = checkThreshold;
+exports.pruneOldUsage = pruneOldUsage;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+const USAGE_FILE = path_1.default.join((0, os_1.homedir)(), '.ekkos', 'usage.json');
+const COST_PER_1M_TOKENS = 0.02; // OpenAI text-embedding-3-small
+const AVG_TOKENS_PER_EMBEDDING = 100; // Conservative estimate
+/**
+ * Ensure usage file exists
+ */
+async function ensureUsageFile() {
+    const dir = path_1.default.dirname(USAGE_FILE);
+    await promises_1.default.mkdir(dir, { recursive: true });
+    try {
+        await promises_1.default.access(USAGE_FILE);
+    }
+    catch {
+        await promises_1.default.writeFile(USAGE_FILE, JSON.stringify([], null, 2));
+    }
+}
+/**
+ * Load usage records
+ */
+async function loadUsage() {
+    await ensureUsageFile();
+    const data = await promises_1.default.readFile(USAGE_FILE, 'utf-8');
+    return JSON.parse(data);
+}
+/**
+ * Save usage records
+ */
+async function saveUsage(records) {
+    await ensureUsageFile();
+    await promises_1.default.writeFile(USAGE_FILE, JSON.stringify(records, null, 2));
+}
+/**
+ * Record an embedding generation
+ */
+async function recordEmbedding(model = 'text-embedding-3-small', tokens = AVG_TOKENS_PER_EMBEDDING) {
+    const cost = (tokens / 1000000) * COST_PER_1M_TOKENS;
+    const today = new Date().toISOString().split('T')[0];
+    const records = await loadUsage();
+    records.push({
+        date: today,
+        embeddings: 1,
+        cost,
+        model,
+    });
+    await saveUsage(records);
+}
+/**
+ * Get usage for a specific date
+ */
+async function getUsageForDate(date) {
+    const records = await loadUsage();
+    const dayRecords = records.filter(r => r.date === date);
+    const byModel = {};
+    let totalEmbeddings = 0;
+    let totalCost = 0;
+    for (const record of dayRecords) {
+        totalEmbeddings += record.embeddings;
+        totalCost += record.cost;
+        if (!byModel[record.model]) {
+            byModel[record.model] = { count: 0, cost: 0 };
+        }
+        byModel[record.model].count += record.embeddings;
+        byModel[record.model].cost += record.cost;
+    }
+    return {
+        date,
+        totalEmbeddings,
+        totalCost,
+        byModel,
+    };
+}
+/**
+ * Get usage for the last N days
+ */
+async function getUsageForDays(days) {
+    const results = [];
+    const today = new Date();
+    for (let i = 0; i < days; i++) {
+        const date = new Date(today);
+        date.setDate(date.getDate() - i);
+        const dateStr = date.toISOString().split('T')[0];
+        const usage = await getUsageForDate(dateStr);
+        results.push(usage);
+    }
+    return results;
+}
+/**
+ * Check if usage exceeds threshold
+ */
+async function checkThreshold(dailyLimit = 10000, costLimit = 10.0) {
+    const today = new Date().toISOString().split('T')[0];
+    const usage = await getUsageForDate(today);
+    const exceeded = usage.totalEmbeddings > dailyLimit || usage.totalCost > costLimit;
+    return { exceeded, usage };
+}
+/**
+ * Clear old usage data (keep last 90 days)
+ */
+async function pruneOldUsage() {
+    const records = await loadUsage();
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 90);
+    const cutoffStr = cutoff.toISOString().split('T')[0];
+    const pruned = records.filter(r => r.date >= cutoffStr);
+    await saveUsage(pruned);
+}

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

@@ -0,0 +1,162 @@
+export interface ActiveSession {
+    sessionId: string;
+    sessionName: string;
+    pid: number;
+    startedAt: string;
+    projectPath: string;
+    lastHeartbeat: string;
+}
+interface SessionNameResolution {
+    uuid: string;
+    sessionName: string;
+    projectPath: string;
+    encodedProjectPath: string;
+    startedAt?: string;
+}
+/** Detect ekkOS 3-word session names like "lit-lex-zip" */
+export declare function isEkkosSessionName(name: string): boolean;
+/** Resolve an ekkOS session name to a JSONL UUID */
+export declare function resolveSessionName(name: string): SessionNameResolution | null;
+/** Parse a single JSONL file and return SessionUsage for an ekkOS-named session */
+export declare function getSessionUsageByName(name: string): Promise<SessionUsage | null>;
+/** List ekkOS sessions with lightweight cost data (for session list view) */
+export declare function listEkkosSessions(limit?: number): Promise<{
+    name: string;
+    uuid: string;
+    projectPath: string;
+    startedAt: string;
+    lastHeartbeat: string;
+    cost: number;
+    tokens: number;
+    models: string[];
+    turnCount: number;
+}[]>;
+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;
+    cost: number;
+    totalCost: number;
+    lastActivity: string;
+    versions?: string[];
+    modelsUsed: string[];
+    modelBreakdowns: {
+        modelName: string;
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        cost: number;
+    }[];
+    projectPath: string;
+}
+/** Daily usage entry from ccusage */
+export interface CcusageDailyUsage {
+    date: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: {
+        modelName: string;
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        cost: number;
+    }[];
+}
+/** Weekly usage entry from ccusage */
+export interface CcusageWeeklyUsage {
+    week: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: CcusageDailyUsage['modelBreakdowns'];
+}
+/** Monthly usage entry from ccusage */
+export interface CcusageMonthlyUsage {
+    month: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: CcusageDailyUsage['modelBreakdowns'];
+}
+/**
+ * Get all sessions using ccusage library
+ */
+export declare function getAllSessions(instanceId?: string): Promise<SessionUsage[]>;
+/**
+ * Get specific session usage using ccusage library
+ */
+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;
+/**
+ * Load daily usage data via ccusage library
+ */
+export declare function getDailyUsage(): Promise<CcusageDailyUsage[]>;
+/**
+ * Load weekly usage data via ccusage library
+ */
+export declare function getWeeklyUsage(): Promise<CcusageWeeklyUsage[]>;
+/**
+ * Load monthly usage data via ccusage library
+ */
+export declare function getMonthlyUsage(): Promise<CcusageMonthlyUsage[]>;
+/**
+ * Load bucket (5-hour block) usage data via ccusage library
+ */
+export declare function getBucketUsage(): Promise<any[]>;
+export {};