@ekkos/cli 0.3.3 → 1.0.1

package/dist/lib/usage-parser.js

@@ -33,27 +33,283 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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;
-const child_process_1 = require("child_process");
+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
+ * Get all sessions using ccusage library
  */
 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)));
+        // 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) {
@@ -62,22 +318,20 @@ async function getAllSessions(instanceId) {
     }
 }
 /**
- * Get specific session usage using ccusage
+ * Get specific session usage using ccusage library
  */
 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);
+        // 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.sessions.find(s => s.sessionId === sessionId);
+        const session = data.find((s) => s.sessionId === sessionId);
         if (!session) {
             return null;
         }
-        return convertCcusageSession(session, instanceId);
+        // Load full turn data for specific session view
+        return convertCcusageSession(session, instanceId, false);
     }
     catch (error) {
         console.error('Failed to fetch session from ccusage:', error);
@@ -86,10 +340,13 @@ async function getSessionUsage(sessionId, instanceId) {
 }
 /**
  * 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) {
-    // Try to get turn-by-turn data from Claude Code's JSONL files
-    const turns = await getTurnMetrics(session.sessionId, instanceId);
+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;
@@ -98,25 +355,30 @@ async function convertCcusageSession(session, instanceId) {
             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
+    // Try to fetch ekkOS pattern metrics from memory API (skip for list view for performance)
     let patternMetrics;
-    try {
-        patternMetrics = await fetchPatternMetrics(session.sessionId);
-    }
-    catch {
-        // Fail silently if memory API not available
+    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,
-        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,
+        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',
@@ -128,52 +390,79 @@ async function convertCcusageSession(session, instanceId) {
 }
 /**
  * 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) {
-    // 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`),
+    // 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),
     ];
-    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',
-                            });
+    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 invalid JSON lines
                     }
                 }
-                return turns;
+                catch {
+                    // Skip unreadable files
+                }
             }
-            catch {
-                // Continue to next path
+            // 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 [];
 }
@@ -236,3 +525,59 @@ function getCurrentSessionId() {
     // 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/utils/log-rotate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Rotate a log file if it exceeds the maximum size.
+ * Shifts existing backups up (e.g., .1 → .2, .2 → .3) and deletes the oldest if it exceeds maxBackups.
+ *
+ * @param logPath - Path to the log file
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ * @param maxBackups - Maximum number of backup files to keep (default: 3)
+ */
+export declare function rotateLogIfNeeded(logPath: string, maxBytes?: number, maxBackups?: number): void;
+/**
+ * Append a message to a log file, rotating it first if needed.
+ * Creates the directory if it doesn't exist.
+ *
+ * @param logPath - Path to the log file
+ * @param message - Message to append
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ */
+export declare function appendLog(logPath: string, message: string, maxBytes?: number): void;

package/dist/utils/log-rotate.js

@@ -0,0 +1,74 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rotateLogIfNeeded = rotateLogIfNeeded;
+exports.appendLog = appendLog;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Rotate a log file if it exceeds the maximum size.
+ * Shifts existing backups up (e.g., .1 → .2, .2 → .3) and deletes the oldest if it exceeds maxBackups.
+ *
+ * @param logPath - Path to the log file
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ * @param maxBackups - Maximum number of backup files to keep (default: 3)
+ */
+function rotateLogIfNeeded(logPath, maxBytes = 5 * 1024 * 1024, maxBackups = 3) {
+    try {
+        // Check if log file exists and get its size
+        if (!fs_1.default.existsSync(logPath)) {
+            return;
+        }
+        const stats = fs_1.default.statSync(logPath);
+        if (stats.size < maxBytes) {
+            return; // No rotation needed
+        }
+        // Delete the oldest backup if it would exceed maxBackups
+        const oldestBackup = `${logPath}.${maxBackups}`;
+        if (fs_1.default.existsSync(oldestBackup)) {
+            fs_1.default.unlinkSync(oldestBackup);
+        }
+        // Shift existing backups up (e.g., .2 → .3, .1 → .2)
+        for (let i = maxBackups - 1; i >= 1; i--) {
+            const currentBackup = `${logPath}.${i}`;
+            const nextBackup = `${logPath}.${i + 1}`;
+            if (fs_1.default.existsSync(currentBackup)) {
+                fs_1.default.renameSync(currentBackup, nextBackup);
+            }
+        }
+        // Rotate the current log to .1
+        fs_1.default.renameSync(logPath, `${logPath}.1`);
+    }
+    catch (error) {
+        // Silently fail - logging utilities should never crash the caller
+        // In a production scenario, you might want to log this to stderr or a separate error log
+        // console.error('[log-rotate] Failed to rotate log:', error);
+    }
+}
+/**
+ * Append a message to a log file, rotating it first if needed.
+ * Creates the directory if it doesn't exist.
+ *
+ * @param logPath - Path to the log file
+ * @param message - Message to append
+ * @param maxBytes - Maximum file size in bytes before rotation (default: 5MB)
+ */
+function appendLog(logPath, message, maxBytes) {
+    try {
+        // Create directory if it doesn't exist
+        const dir = path_1.default.dirname(logPath);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        // Rotate if needed
+        rotateLogIfNeeded(logPath, maxBytes);
+        // Append message
+        fs_1.default.appendFileSync(logPath, message + '\n', 'utf8');
+    }
+    catch (error) {
+        // Silently fail - logging utilities should never crash the caller
+        // console.error('[log-rotate] Failed to append log:', error);
+    }
+}

package/dist/utils/platform.d.ts

@@ -15,6 +15,8 @@ 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 CLAUDE_RULES_DIR: string;
+export declare const CLAUDE_EKKOS_RULES: string;
 export declare const CURSOR_DIR: string;
 export declare const CURSOR_MCP: string;
 export declare const WINDSURF_DIR: string;