@ekkos/cli 0.2.17 → 0.3.3

package/dist/cron/promoter.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * ekkOS PROMETHEUS Pattern Promoter
+ * ==================================
+ *
+ * Daily cron job that evaluates patterns for promotion to constitutional memory.
+ *
+ * Constitutional patterns are injected into the system prompt via @ekkos/patch,
+ * making them "instincts" that don't require retrieval.
+ *
+ * Promotion Criteria (default):
+ * - Success rate ≥ 85%
+ * - Applications ≥ 5
+ * - Skip rate ≤ 10%
+ * - Confidence ≥ 70%
+ * - Used within last 30 days
+ * - Used in ≥ 2 unique sessions
+ *
+ * Usage:
+ *   npx ekkos-promote                  # Run promotion evaluation
+ *   npx ekkos-promote --dry-run        # Preview without applying changes
+ *   npx ekkos-promote --user <uuid>    # Promote for specific user
+ *
+ * Schedule via launchd (macOS) or cron:
+ *   0 6 * * * /path/to/node /path/to/ekkos-promote
+ */
+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.evaluatePromotions = evaluatePromotions;
+exports.queryPatternStats = queryPatternStats;
+exports.writePatchConfig = writePatchConfig;
+const supabase_js_1 = require("@supabase/supabase-js");
+const prometheus_1 = require("@ekkos/prometheus");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+// ═══════════════════════════════════════════════════════════════════════════
+// Pattern Stats Query
+// ═══════════════════════════════════════════════════════════════════════════
+async function queryPatternStats(supabase, userId) {
+    // Query patterns with their application stats
+    let query = supabase
+        .from('patterns')
+        .select(`
+      pattern_id,
+      title,
+      content,
+      success_rate,
+      applied_count,
+      confidence_score,
+      created_at,
+      updated_at,
+      tags,
+      user_id
+    `)
+        .eq('quarantined', false)
+        .gte('applied_count', 1); // Only consider applied patterns
+    if (userId) {
+        query = query.eq('user_id', userId);
+    }
+    const { data: patterns, error } = await query;
+    if (error) {
+        throw new Error(`Failed to query patterns: ${error.message}`);
+    }
+    if (!patterns || patterns.length === 0) {
+        return [];
+    }
+    // Get application details for skip rate and session count
+    const patternIds = patterns.map(p => p.pattern_id);
+    const { data: applications } = await supabase
+        .from('pattern_applications')
+        .select('pattern_id, outcome_success, created_at, user_id')
+        .in('pattern_id', patternIds);
+    const { data: skips } = await supabase
+        .from('pattern_skips')
+        .select('pattern_id')
+        .in('pattern_id', patternIds);
+    // Aggregate stats per pattern
+    const appsByPattern = new Map();
+    const skipsByPattern = new Map();
+    for (const app of applications || []) {
+        if (!appsByPattern.has(app.pattern_id)) {
+            appsByPattern.set(app.pattern_id, []);
+        }
+        appsByPattern.get(app.pattern_id).push(app);
+    }
+    for (const skip of skips || []) {
+        const count = skipsByPattern.get(skip.pattern_id) || 0;
+        skipsByPattern.set(skip.pattern_id, count + 1);
+    }
+    // Build PatternStats for each pattern
+    return patterns.map(p => {
+        const apps = appsByPattern.get(p.pattern_id) || [];
+        const skipCount = skipsByPattern.get(p.pattern_id) || 0;
+        const successCount = apps.filter(a => a.outcome_success === true).length;
+        const failureCount = apps.filter(a => a.outcome_success === false).length;
+        const totalApplications = successCount + failureCount;
+        // Count unique sessions (using created_at date as proxy)
+        const uniqueDates = new Set(apps.map(a => new Date(a.created_at).toISOString().split('T')[0]));
+        const stats = {
+            patternId: p.pattern_id,
+            title: p.title || 'Untitled',
+            successCount,
+            failureCount,
+            skipCount,
+            totalApplications: totalApplications || p.applied_count || 0,
+            uniqueSessions: uniqueDates.size,
+            firstApplied: new Date(p.created_at),
+            lastApplied: new Date(p.updated_at || p.created_at),
+            currentConfidence: p.confidence_score || p.success_rate || 0.5,
+            tags: p.tags,
+        };
+        return stats;
+    });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Promotion Logic
+// ═══════════════════════════════════════════════════════════════════════════
+async function evaluatePromotions(supabase, config) {
+    const result = {
+        evaluated: 0,
+        promoted: 0,
+        demoted: 0,
+        patterns: [],
+    };
+    // Get pattern stats
+    const patternStats = await queryPatternStats(supabase, config.userId);
+    result.evaluated = patternStats.length;
+    if (config.verbose) {
+        console.log(`[PROMOTER] Evaluating ${patternStats.length} patterns...`);
+    }
+    // Get currently promoted patterns (from promoted_patterns table or metadata)
+    const { data: currentlyPromoted } = await supabase
+        .from('patterns')
+        .select('pattern_id')
+        .eq('evolution_stage', 'constitutional');
+    const promotedSet = new Set((currentlyPromoted || []).map(p => p.pattern_id));
+    const promotedPatterns = [];
+    // Evaluate each pattern
+    for (const stats of patternStats) {
+        const evaluation = prometheus_1.promotionEvaluator.evaluate(stats);
+        const wasPromoted = promotedSet.has(stats.patternId);
+        if (evaluation.eligible && !wasPromoted) {
+            // PROMOTE: Pattern meets criteria and wasn't promoted before
+            result.promoted++;
+            result.patterns.push({
+                patternId: stats.patternId,
+                title: stats.title,
+                action: 'promoted',
+                score: evaluation.score,
+            });
+            if (!config.dryRun) {
+                // Update pattern to constitutional
+                await supabase
+                    .from('patterns')
+                    .update({
+                    evolution_stage: 'constitutional',
+                    promoted_at: new Date().toISOString(),
+                })
+                    .eq('pattern_id', stats.patternId);
+                // Emit PATTERN_PROMOTED event
+                prometheus_1.learningEvents.emitPatternPromoted({
+                    id: stats.patternId,
+                    title: stats.title,
+                    confidenceBefore: stats.currentConfidence,
+                    confidenceAfter: 1.0,
+                    tier: 'constitutional',
+                    successRate: stats.successCount / Math.max(stats.totalApplications, 1),
+                    appliedCount: stats.totalApplications,
+                }, {
+                    daysInEpisodic: Math.floor((Date.now() - stats.firstApplied.getTime()) / (1000 * 60 * 60 * 24)),
+                    totalApplications: stats.totalApplications,
+                    finalSuccessRate: stats.successCount / Math.max(stats.totalApplications, 1),
+                });
+            }
+            // Fetch full pattern for patch config
+            const { data: fullPattern } = await supabase
+                .from('patterns')
+                .select('content, tags')
+                .eq('pattern_id', stats.patternId)
+                .single();
+            if (fullPattern) {
+                // Parse problem/solution from content
+                const content = fullPattern.content || '';
+                const problemMatch = content.match(/## Problem\n([\s\S]*?)(?=\n## Solution|$)/);
+                const solutionMatch = content.match(/## Solution\n([\s\S]*?)$/);
+                promotedPatterns.push({
+                    id: stats.patternId,
+                    title: stats.title,
+                    problem: problemMatch?.[1]?.trim() || 'N/A',
+                    solution: solutionMatch?.[1]?.trim() || content,
+                    promotedAt: new Date().toISOString(),
+                    successRate: stats.successCount / Math.max(stats.totalApplications, 1),
+                    appliedCount: stats.totalApplications,
+                    tags: fullPattern.tags,
+                });
+            }
+            if (config.verbose) {
+                console.log(`  ✓ PROMOTE: "${stats.title}" (score: ${evaluation.score.toFixed(2)})`);
+            }
+        }
+        else if (!evaluation.eligible && wasPromoted) {
+            // DEMOTE: Pattern no longer meets criteria
+            result.demoted++;
+            // Find the main blocker for demotion reason
+            const reason = evaluation.blockers[0]?.includes('success')
+                ? 'low_success_rate'
+                : evaluation.blockers[0]?.includes('skip')
+                    ? 'high_skip_rate'
+                    : 'outdated';
+            result.patterns.push({
+                patternId: stats.patternId,
+                title: stats.title,
+                action: 'demoted',
+                score: evaluation.score,
+                reason,
+            });
+            if (!config.dryRun) {
+                // Update pattern back to episodic
+                await supabase
+                    .from('patterns')
+                    .update({
+                    evolution_stage: 'episodic',
+                    demoted_at: new Date().toISOString(),
+                })
+                    .eq('pattern_id', stats.patternId);
+                // Emit PATTERN_DEMOTED event
+                prometheus_1.learningEvents.emitPatternDemoted({
+                    id: stats.patternId,
+                    title: stats.title,
+                    confidenceBefore: 1.0,
+                    confidenceAfter: stats.currentConfidence,
+                    tier: 'episodic',
+                    successRate: stats.successCount / Math.max(stats.totalApplications, 1),
+                    appliedCount: stats.totalApplications,
+                }, reason);
+            }
+            if (config.verbose) {
+                console.log(`  ✗ DEMOTE: "${stats.title}" (${reason})`);
+            }
+        }
+        else {
+            result.patterns.push({
+                patternId: stats.patternId,
+                title: stats.title,
+                action: 'unchanged',
+                score: evaluation.score,
+            });
+        }
+    }
+    // Also include patterns that are already promoted and still eligible
+    for (const stats of patternStats) {
+        const evaluation = prometheus_1.promotionEvaluator.evaluate(stats);
+        if (evaluation.eligible && promotedSet.has(stats.patternId)) {
+            // Fetch and include in patch config
+            const { data: fullPattern } = await supabase
+                .from('patterns')
+                .select('content, tags')
+                .eq('pattern_id', stats.patternId)
+                .single();
+            if (fullPattern) {
+                const content = fullPattern.content || '';
+                const problemMatch = content.match(/## Problem\n([\s\S]*?)(?=\n## Solution|$)/);
+                const solutionMatch = content.match(/## Solution\n([\s\S]*?)$/);
+                promotedPatterns.push({
+                    id: stats.patternId,
+                    title: stats.title,
+                    problem: problemMatch?.[1]?.trim() || 'N/A',
+                    solution: solutionMatch?.[1]?.trim() || content,
+                    promotedAt: new Date().toISOString(),
+                    successRate: stats.successCount / Math.max(stats.totalApplications, 1),
+                    appliedCount: stats.totalApplications,
+                    tags: fullPattern.tags,
+                });
+            }
+        }
+    }
+    // Generate patch config
+    result.patchConfig = {
+        version: '1.0.0',
+        generatedAt: new Date().toISOString(),
+        promotedPatterns,
+        totalPatterns: promotedPatterns.length,
+    };
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// Patch Config Generation
+// ═══════════════════════════════════════════════════════════════════════════
+function writePatchConfig(config, outputPath) {
+    const dir = path.dirname(outputPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(outputPath, JSON.stringify(config, null, 2));
+    console.log(`[PROMOTER] Wrote patch config to: ${outputPath}`);
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// CLI Entry Point
+// ═══════════════════════════════════════════════════════════════════════════
+async function main() {
+    const args = process.argv.slice(2);
+    const config = {
+        supabaseUrl: process.env.SUPABASE_URL || process.env.NEXT_PUBLIC_SUPABASE_URL || '',
+        supabaseKey: process.env.SUPABASE_SECRET_KEY || process.env.SUPABASE_SERVICE_ROLE_KEY || '',
+        dryRun: args.includes('--dry-run'),
+        userId: args.includes('--user') ? args[args.indexOf('--user') + 1] : undefined,
+        patchConfigPath: path.join(os.homedir(), '.ekkos', 'promoted-patterns.json'),
+        verbose: args.includes('--verbose') || args.includes('-v'),
+    };
+    // Allow custom output path
+    if (args.includes('--output')) {
+        config.patchConfigPath = args[args.indexOf('--output') + 1];
+    }
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('  ekkOS PROMETHEUS Pattern Promoter');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log(`  Mode: ${config.dryRun ? 'DRY RUN (no changes)' : 'LIVE'}`);
+    console.log(`  User: ${config.userId || 'All users'}`);
+    console.log(`  Output: ${config.patchConfigPath}`);
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('');
+    if (!config.supabaseUrl || !config.supabaseKey) {
+        console.error('[ERROR] Missing SUPABASE_URL or SUPABASE_SECRET_KEY environment variables');
+        process.exit(1);
+    }
+    const supabase = (0, supabase_js_1.createClient)(config.supabaseUrl, config.supabaseKey);
+    try {
+        const result = await evaluatePromotions(supabase, config);
+        console.log('');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log('  Results');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log(`  Patterns evaluated: ${result.evaluated}`);
+        console.log(`  Promoted: ${result.promoted}`);
+        console.log(`  Demoted: ${result.demoted}`);
+        console.log(`  Constitutional total: ${result.patchConfig?.totalPatterns || 0}`);
+        console.log('═══════════════════════════════════════════════════════════════');
+        // Write patch config
+        if (!config.dryRun && result.patchConfig) {
+            writePatchConfig(result.patchConfig, config.patchConfigPath);
+        }
+        else if (config.dryRun && result.patchConfig) {
+            console.log('\n[DRY RUN] Would write patch config with:');
+            console.log(`  - ${result.patchConfig.totalPatterns} promoted patterns`);
+        }
+        // Summary of changes
+        if (result.patterns.filter(p => p.action !== 'unchanged').length > 0) {
+            console.log('\nChanges:');
+            for (const p of result.patterns) {
+                if (p.action === 'promoted') {
+                    console.log(`  🎓 PROMOTED: "${p.title}" (score: ${p.score.toFixed(2)})`);
+                }
+                else if (p.action === 'demoted') {
+                    console.log(`  ⬇️  DEMOTED: "${p.title}" (${p.reason})`);
+                }
+            }
+        }
+        else {
+            console.log('\nNo promotion changes needed.');
+        }
+        console.log('\n✓ Promotion evaluation complete');
+    }
+    catch (error) {
+        console.error('[ERROR]', error);
+        process.exit(1);
+    }
+}
+// Run if executed directly
+main().catch(console.error);

package/dist/index.js

@@ -48,6 +48,7 @@ const hooks_1 = require("./commands/hooks");
 const setup_remote_1 = require("./commands/setup-remote");
 const agent_1 = require("./commands/agent");
 const state_1 = require("./utils/state");
+const usage_1 = require("./commands/usage");
 const chalk_1 = __importDefault(require("chalk"));
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -88,15 +89,19 @@ commander_1.program
     .option('-v, --verbose', 'Show debug output')
     .option('-d, --doctor', 'Run diagnostics before starting')
     .option('-r, --research', 'Auto-run research agent on startup (scans arXiv for new AI papers)')
-    .option('--no-inject', 'Monitor-only mode (detect context wall but print instructions instead of auto-inject)')
+    .option('--skip-inject', 'Monitor-only mode (detect context wall but print instructions instead of auto-inject)')
+    .option('--skip-dna', 'Skip ccDNA injection (bypass Claude Code patching)')
+    .option('--skip-proxy', 'Skip API proxy (use direct Anthropic API, disables seamless context eviction)')
     .action((options) => {
     (0, run_1.run)({
         session: options.session,
         bypass: options.bypass,
         verbose: options.verbose,
         doctor: options.doctor,
-        noInject: options.noInject,
-        research: options.research
+        noInject: options.skipInject,
+        research: options.research,
+        noDna: options.skipDna,
+        noProxy: options.skipProxy
     });
 });
 // Doctor command - check system prerequisites
@@ -169,6 +174,22 @@ hooksCmd
     .action((options) => {
     (0, hooks_1.hooksStatus)({ verbose: options.verbose });
 });
+// Usage command - track session token usage
+commander_1.program
+    .command('usage [session-id]')
+    .description('Track Claude Code session token usage and context percentage')
+    .option('--instance <id>', 'Instance ID (project path identifier)')
+    .option('--list', 'List available sessions')
+    .action((sessionId, options) => {
+    const args = [];
+    if (sessionId)
+        args.push(sessionId);
+    if (options.instance)
+        args.push('--instance', options.instance);
+    if (options.list)
+        args.push('--list');
+    (0, usage_1.usageCommand)(args);
+});
 // Sessions command - list active Claude Code sessions (swarm support)
 commander_1.program
     .command('sessions')

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

@@ -0,0 +1,47 @@
+/**
+ * Simple usage monitoring for ekkOS embedding costs
+ * Tracks daily usage to prevent runaway costs
+ */
+interface UsageRecord {
+    date: string;
+    embeddings: number;
+    cost: number;
+    model: string;
+}
+interface DailyUsage {
+    date: string;
+    totalEmbeddings: number;
+    totalCost: number;
+    byModel: Record<string, {
+        count: number;
+        cost: number;
+    }>;
+}
+/**
+ * Load usage records
+ */
+export declare function loadUsage(): Promise<UsageRecord[]>;
+/**
+ * Record an embedding generation
+ */
+export declare function recordEmbedding(model?: string, tokens?: number): Promise<void>;
+/**
+ * Get usage for a specific date
+ */
+export declare function getUsageForDate(date: string): Promise<DailyUsage>;
+/**
+ * Get usage for the last N days
+ */
+export declare function getUsageForDays(days: number): Promise<DailyUsage[]>;
+/**
+ * Check if usage exceeds threshold
+ */
+export declare function checkThreshold(dailyLimit?: number, costLimit?: number): Promise<{
+    exceeded: boolean;
+    usage: DailyUsage;
+}>;
+/**
+ * Clear old usage data (keep last 90 days)
+ */
+export declare function pruneOldUsage(): Promise<void>;
+export {};

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);
+}