@ekkos/cli 0.2.18 → 1.0.0

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/deploy/instructions.d.ts

@@ -1,9 +1,12 @@
 /**
- * Deploy CLAUDE.md to ~/.claude/CLAUDE.md
+ * Deploy ekkOS instructions to ~/.claude/rules/ekkos.md
+ *
+ * Uses Claude Code's user-level rules directory — auto-loaded for all projects
+ * without touching the user's existing CLAUDE.md.
  */
 export declare function deployInstructions(): void;
 /**
- * Check if CLAUDE.md is deployed
+ * Check if ekkOS instructions are deployed
  */
 export declare function isInstructionsDeployed(): boolean;
 /**

package/dist/deploy/instructions.js

@@ -7,21 +7,24 @@ const fs_1 = require("fs");
 const platform_1 = require("../utils/platform");
 const templates_1 = require("../utils/templates");
 /**
- * Deploy CLAUDE.md to ~/.claude/CLAUDE.md
+ * Deploy ekkOS instructions to ~/.claude/rules/ekkos.md
+ *
+ * Uses Claude Code's user-level rules directory — auto-loaded for all projects
+ * without touching the user's existing CLAUDE.md.
  */
 function deployInstructions() {
-    // Ensure .claude directory exists
-    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_DIR)) {
-        (0, fs_1.mkdirSync)(platform_1.CLAUDE_DIR, { recursive: true });
+    // Ensure ~/.claude/rules/ exists
+    if (!(0, fs_1.existsSync)(platform_1.CLAUDE_RULES_DIR)) {
+        (0, fs_1.mkdirSync)(platform_1.CLAUDE_RULES_DIR, { recursive: true });
     }
-    // Copy CLAUDE.md template
-    (0, templates_1.copyTemplateFile)('CLAUDE.md', platform_1.CLAUDE_MD);
+    // Deploy to rules/ekkos.md (safe to overwrite — this is our file)
+    (0, templates_1.copyTemplateFile)('CLAUDE.md', platform_1.CLAUDE_EKKOS_RULES);
 }
 /**
- * Check if CLAUDE.md is deployed
+ * Check if ekkOS instructions are deployed
  */
 function isInstructionsDeployed() {
-    return (0, fs_1.existsSync)(platform_1.CLAUDE_MD);
+    return (0, fs_1.existsSync)(platform_1.CLAUDE_EKKOS_RULES);
 }
 /**
  * Get the CLAUDE.md content (for preview)