nexus-prime 0.2.0

package/dist/engines/token-optimizer.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Token Optimizer Engine
+ *
+ * Intelligent token allocation using AdaptiveKVMerge principles.
+ */
+export declare class TokenOptimizer {
+    private maxTokens;
+    private qualityThreshold;
+    private compressionHistory;
+    constructor(maxTokens?: number);
+    /**
+     * Assess task complexity (0-1)
+     */
+    assessComplexity(task: string): number;
+    /**
+     * Determine compression ratio based on complexity
+     */
+    getCompressionRatio(complexity: number): number;
+    /**
+     * Optimize token allocation
+     */
+    optimize(context: string[], task: string): {
+        tokens: number;
+        ratio: number;
+        strategy: string;
+    };
+    /**
+     * Track compression for learning
+     */
+    trackCompression(taskType: string, quality: number): void;
+    /**
+     * Get average quality for a task type
+     */
+    getAverageQuality(taskType: string): number;
+}
+export declare const createTokenOptimizer: (maxTokens?: number) => TokenOptimizer;
+export declare class SLERPCompressor {
+    /**
+     * SLERP interpolation between two vectors
+     */
+    slerp(v1: number[], v2: number[], t: number): number[];
+    /**
+     * Compress layers using SLERP
+     */
+    compressLayers(layers: number[][], strategy?: 'aggressive' | 'moderate' | 'conservative'): {
+        compressed: number[][];
+        ratio: number;
+    };
+    private magnitude;
+    private dotProduct;
+}
+export declare const createSLERPCompressor: () => SLERPCompressor;
+//# sourceMappingURL=token-optimizer.d.ts.map

package/dist/engines/token-optimizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-optimizer.d.ts","sourceRoot":"","sources":["../../src/engines/token-optimizer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,gBAAgB,CAAgB;IACxC,OAAO,CAAC,kBAAkB,CAAkC;gBAEhD,SAAS,GAAE,MAAe;IAItC;;OAEG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAoBtC;;OAEG;IACH,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAM/C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG;QACzC,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB;IAgBD;;OAEG;IACH,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI;IAIzD;;OAEG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM;CAI5C;AAED,eAAO,MAAM,oBAAoB,GAAI,YAAY,MAAM,mBACxB,CAAC;AAIhC,qBAAa,eAAe;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE;IAetD;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,GAAE,YAAY,GAAG,UAAU,GAAG,cAA2B,GAAG;QACrG,UAAU,EAAE,MAAM,EAAE,EAAE,CAAC;QACvB,KAAK,EAAE,MAAM,CAAC;KACf;IAiBD,OAAO,CAAC,SAAS;IAIjB,OAAO,CAAC,UAAU;CAGnB;AAED,eAAO,MAAM,qBAAqB,uBAA8B,CAAC"}

package/dist/engines/token-optimizer.js

@@ -0,0 +1,115 @@
+/**
+ * Token Optimizer Engine
+ *
+ * Intelligent token allocation using AdaptiveKVMerge principles.
+ */
+export class TokenOptimizer {
+    maxTokens;
+    qualityThreshold = 0.64;
+    compressionHistory = new Map();
+    constructor(maxTokens = 128000) {
+        this.maxTokens = maxTokens;
+    }
+    /**
+     * Assess task complexity (0-1)
+     */
+    assessComplexity(task) {
+        // Simple heuristic-based assessment
+        const indicators = {
+            simple: ['what', 'when', 'who', 'where', 'is', 'are', '?', 'list'],
+            complex: ['build', 'create', 'design', 'implement', 'develop', 'explain why', 'analyze']
+        };
+        let score = 0.5;
+        const taskLower = task.toLowerCase();
+        for (const word of indicators.simple) {
+            if (taskLower.includes(word))
+                score -= 0.1;
+        }
+        for (const word of indicators.complex) {
+            if (taskLower.includes(word))
+                score += 0.15;
+        }
+        return Math.max(0, Math.min(1, score));
+    }
+    /**
+     * Determine compression ratio based on complexity
+     */
+    getCompressionRatio(complexity) {
+        if (complexity < 0.3)
+            return 8.0; // Aggressive for simple
+        if (complexity < 0.7)
+            return 5.0; // Moderate for normal
+        return 3.0; // Conservative for complex
+    }
+    /**
+     * Optimize token allocation
+     */
+    optimize(context, task) {
+        const complexity = this.assessComplexity(task);
+        const ratio = this.getCompressionRatio(complexity);
+        // Estimate tokens needed
+        const baseTokens = context.reduce((sum, c) => sum + c.length / 4, 0);
+        const optimizedTokens = Math.floor(baseTokens / ratio);
+        return {
+            tokens: Math.min(optimizedTokens, this.maxTokens),
+            ratio,
+            strategy: complexity < 0.3 ? 'aggressive' :
+                complexity < 0.7 ? 'moderate' : 'conservative'
+        };
+    }
+    /**
+     * Track compression for learning
+     */
+    trackCompression(taskType, quality) {
+        this.compressionHistory.set(taskType, quality);
+    }
+    /**
+     * Get average quality for a task type
+     */
+    getAverageQuality(taskType) {
+        const history = this.compressionHistory.get(taskType);
+        return history || 0.5;
+    }
+}
+export const createTokenOptimizer = (maxTokens) => new TokenOptimizer(maxTokens);
+// ===== Advanced: SLERP-based compression (from AdaptiveKVMerge) =====
+export class SLERPCompressor {
+    /**
+     * SLERP interpolation between two vectors
+     */
+    slerp(v1, v2, t) {
+        const dot = this.dotProduct(v1, v2) / (this.magnitude(v1) * this.magnitude(v2) || 1);
+        const omega = Math.acos(Math.max(-1, Math.min(1, dot)));
+        const sinOmega = Math.sin(omega);
+        if (sinOmega < 1e-6) {
+            return v1.map((x, i) => (1 - t) * x + t * (v2[i] || 0));
+        }
+        const a = Math.sin((1 - t) * omega) / sinOmega;
+        const b = Math.sin(t * omega) / sinOmega;
+        return v1.map((x, i) => a * x + b * (v2[i] || 0));
+    }
+    /**
+     * Compress layers using SLERP
+     */
+    compressLayers(layers, strategy = 'moderate') {
+        const t = strategy === 'aggressive' ? 0.7 : strategy === 'moderate' ? 0.5 : 0.3;
+        const compressed = [];
+        for (let i = 1; i < layers.length; i += 2) {
+            if (i < layers.length) {
+                compressed.push(this.slerp(layers[i], layers[i - 1], t));
+            }
+        }
+        return {
+            compressed,
+            ratio: layers.length / (compressed.length || 1)
+        };
+    }
+    magnitude(v) {
+        return Math.sqrt(v.reduce((sum, x) => sum + x * x, 0));
+    }
+    dotProduct(a, b) {
+        return a.reduce((sum, x, i) => sum + x * (b[i] || 0), 0);
+    }
+}
+export const createSLERPCompressor = () => new SLERPCompressor();
+//# sourceMappingURL=token-optimizer.js.map

package/dist/engines/token-optimizer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-optimizer.js","sourceRoot":"","sources":["../../src/engines/token-optimizer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,MAAM,OAAO,cAAc;IACjB,SAAS,CAAS;IAClB,gBAAgB,GAAW,IAAI,CAAC;IAChC,kBAAkB,GAAwB,IAAI,GAAG,EAAE,CAAC;IAE5D,YAAY,YAAoB,MAAM;QACpC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,IAAY;QAC3B,oCAAoC;QACpC,MAAM,UAAU,GAAG;YACjB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC;YAClE,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,CAAC;SACzF,CAAC;QAEF,IAAI,KAAK,GAAG,GAAG,CAAC;QAChB,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAErC,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YACrC,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,KAAK,IAAI,GAAG,CAAC;QAC7C,CAAC;QACD,KAAK,MAAM,IAAI,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;YACtC,IAAI,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,KAAK,IAAI,IAAI,CAAC;QAC9C,CAAC;QAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IACzC,CAAC;IAED;;OAEG;IACH,mBAAmB,CAAC,UAAkB;QACpC,IAAI,UAAU,GAAG,GAAG;YAAE,OAAO,GAAG,CAAC,CAAM,wBAAwB;QAC/D,IAAI,UAAU,GAAG,GAAG;YAAE,OAAO,GAAG,CAAC,CAAM,sBAAsB;QAC7D,OAAO,GAAG,CAAC,CAA+B,2BAA2B;IACvE,CAAC;IAED;;OAEG;IACH,QAAQ,CAAC,OAAiB,EAAE,IAAY;QAKtC,MAAM,UAAU,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;QAEnD,yBAAyB;QACzB,MAAM,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;QACrE,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,KAAK,CAAC,CAAC;QAEvD,OAAO;YACL,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,eAAe,EAAE,IAAI,CAAC,SAAS,CAAC;YACjD,KAAK;YACL,QAAQ,EAAE,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;gBACjC,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,cAAc;SACzD,CAAC;IACJ,CAAC;IAED;;OAEG;IACH,gBAAgB,CAAC,QAAgB,EAAE,OAAe;QAChD,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAED;;OAEG;IACH,iBAAiB,CAAC,QAAgB;QAChC,MAAM,OAAO,GAAG,IAAI,CAAC,kBAAkB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACtD,OAAO,OAAO,IAAI,GAAG,CAAC;IACxB,CAAC;CACF;AAED,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,SAAkB,EAAE,EAAE,CACzD,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;AAEhC,uEAAuE;AAEvE,MAAM,OAAO,eAAe;IAC1B;;OAEG;IACH,KAAK,CAAC,EAAY,EAAE,EAAY,EAAE,CAAS;QACzC,MAAM,GAAG,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC;QACrF,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;QACxD,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAEjC,IAAI,QAAQ,GAAG,IAAI,EAAE,CAAC;YACpB,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC1D,CAAC;QAED,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAC;QAC/C,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC,GAAG,QAAQ,CAAC;QAEzC,OAAO,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,MAAkB,EAAE,WAAuD,UAAU;QAIlG,MAAM,CAAC,GAAG,QAAQ,KAAK,YAAY,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,KAAK,UAAU,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;QAEhF,MAAM,UAAU,GAAe,EAAE,CAAC;QAElC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1C,IAAI,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;gBACtB,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC3D,CAAC;QACH,CAAC;QAED,OAAO;YACL,UAAU;YACV,KAAK,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,UAAU,CAAC,MAAM,IAAI,CAAC,CAAC;SAChD,CAAC;IACJ,CAAC;IAEO,SAAS,CAAC,CAAW;QAC3B,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IAEO,UAAU,CAAC,CAAW,EAAE,CAAW;QACzC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;CACF;AAED,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,EAAE,CAAC,IAAI,eAAe,EAAE,CAAC"}

package/dist/engines/token-supremacy.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Token Supremacy Engine
+ *
+ * Purpose: Make every token count. This engine runs BEFORE any large context
+ * operation and decides what to read, what to skip, what to summarize.
+ *
+ * Built for AntiGravity to reduce token waste by 50-70%.
+ */
+export interface FileRef {
+    path: string;
+    sizeBytes: number;
+    lastModified?: number;
+}
+export type ReadAction = 'skip' | 'outline' | 'partial' | 'full';
+export interface FileReadPlan {
+    file: FileRef;
+    action: ReadAction;
+    startLine?: number;
+    endLine?: number;
+    reason: string;
+    estimatedTokens: number;
+}
+export interface ReadingPlan {
+    task: string;
+    files: FileReadPlan[];
+    totalEstimatedTokens: number;
+    savings: number;
+    sessionBudget: number;
+}
+export interface SessionSummary {
+    sessionId: string;
+    timestamp: number;
+    files: string[];
+    fileSHAs: Record<string, string>;
+    summary: string;
+    keyDecisions: string[];
+}
+export interface ContextDelta {
+    added: FileRef[];
+    changed: FileRef[];
+    unchanged: FileRef[];
+    summary?: string;
+}
+export interface TokenBudget {
+    total: number;
+    allocated: Map<string, number>;
+    remaining: number;
+}
+export declare class TokenSupremacyEngine {
+    private sessionBudget;
+    private sessionPath;
+    private relevanceCache;
+    private relevanceCachePath;
+    constructor(sessionBudget?: number);
+    /**
+     * Plan a token-efficient reading strategy for a given task + files.
+     */
+    plan(task: string, files: FileRef[]): ReadingPlan;
+    /**
+     * Legacy compatibility wrapper for NexusPrime.
+     */
+    optimize(context: string[], task: string): ReadingPlan;
+    differential(prev: SessionSummary, curr: FileRef[]): ContextDelta;
+    allocateBudget(workers: Array<{
+        id: string;
+        estimatedValue: number;
+        estimatedCost: number;
+    }>, totalBudget?: number): TokenBudget;
+    learn(taskType: string, usefulFiles: string[], skipFiles: string[]): void;
+    private loadRelevanceCache;
+    private saveRelevanceCache;
+    saveSessionSummary(summary: SessionSummary): void;
+    loadLatestSessionSummary(): SessionSummary | null;
+    private extractKeywords;
+    private scoreRelevance;
+    private estimateHotLines;
+    private fingerprintFile;
+    /**
+     * Adjust token budget based on task complexity signals.
+     * Complex tasks get +25% budget; simple lookups get -25%.
+     */
+    private hypertune;
+}
+export declare function formatReadingPlan(plan: ReadingPlan): string;
+export declare const createTokenSupremacyEngine: (budget?: number) => TokenSupremacyEngine;
+//# sourceMappingURL=token-supremacy.d.ts.map

package/dist/engines/token-supremacy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-supremacy.d.ts","sourceRoot":"","sources":["../../src/engines/token-supremacy.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,MAAM,WAAW,OAAO;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAEjE,MAAM,WAAW,YAAY;IACzB,IAAI,EAAE,OAAO,CAAC;IACd,MAAM,EAAE,UAAU,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,WAAW;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,EAAE,CAAC;IACtB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,cAAc;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IACzB,KAAK,EAAE,OAAO,EAAE,CAAC;IACjB,OAAO,EAAE,OAAO,EAAE,CAAC;IACnB,SAAS,EAAE,OAAO,EAAE,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,WAAW;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;CACrB;AAMD,qBAAa,oBAAoB;IAC7B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,WAAW,CAAS;IAG5B,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,kBAAkB,CAAS;gBAEvB,aAAa,GAAE,MAAgB;IAc3C;;OAEG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,WAAW;IA8EjD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,WAAW;IActD,YAAY,CAAC,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,YAAY;IA6BjE,cAAc,CACV,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAA;KAAE,CAAC,EAC7E,WAAW,GAAE,MAA2B,GACzC,WAAW;IAuBd,KAAK,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,IAAI;IAgBzE,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,kBAAkB;IAgB1B,kBAAkB,CAAC,OAAO,EAAE,cAAc,GAAG,IAAI;IAMjD,wBAAwB,IAAI,cAAc,GAAG,IAAI;IAuBjD,OAAO,CAAC,eAAe;IAkBvB,OAAO,CAAC,cAAc;IAmFtB,OAAO,CAAC,gBAAgB;IAiBxB,OAAO,CAAC,eAAe;IAKvB;;;OAGG;IACH,OAAO,CAAC,SAAS;CAqBpB;AAMD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAmC3D;AAED,eAAO,MAAM,0BAA0B,GAAI,SAAS,MAAM,yBACtB,CAAC"}

package/dist/engines/token-supremacy.js

@@ -0,0 +1,403 @@
+/**
+ * Token Supremacy Engine
+ *
+ * Purpose: Make every token count. This engine runs BEFORE any large context
+ * operation and decides what to read, what to skip, what to summarize.
+ *
+ * Built for AntiGravity to reduce token waste by 50-70%.
+ */
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs';
+// ─────────────────────────────────────────────────────────────────────────────
+// Core Engine
+// ─────────────────────────────────────────────────────────────────────────────
+export class TokenSupremacyEngine {
+    sessionBudget;
+    sessionPath;
+    // Per-session learned relevance: task keyword → file paths that helped
+    relevanceCache = new Map();
+    relevanceCachePath;
+    constructor(sessionBudget = 200_000) {
+        this.sessionBudget = sessionBudget;
+        this.sessionPath = path.join(os.homedir(), '.nexus-prime', 'sessions');
+        this.relevanceCachePath = path.join(os.homedir(), '.nexus-prime', 'relevance.json');
+        fs.mkdirSync(this.sessionPath, { recursive: true });
+        if (!fs.existsSync(path.dirname(this.relevanceCachePath))) {
+            fs.mkdirSync(path.dirname(this.relevanceCachePath), { recursive: true });
+        }
+        this.loadRelevanceCache();
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Primary API: generate a reading plan for a task
+    /**
+     * Plan a token-efficient reading strategy for a given task + files.
+     */
+    plan(task, files) {
+        // Apply hypertuning if we have many files
+        if (files.length > 10) {
+            this.hypertune(task);
+        }
+        const taskKeywords = this.extractKeywords(task);
+        const plans = [];
+        let totalTokens = 0;
+        let fullReadTokens = 0;
+        for (const file of files) {
+            const relevance = this.scoreRelevance(file.path, taskKeywords);
+            const estFull = Math.ceil(file.sizeBytes / 4); // ~4 chars per token
+            fullReadTokens += estFull;
+            let plan;
+            if (relevance < 0.15) {
+                // Irrelevant — skip entirely
+                plan = {
+                    file,
+                    action: 'skip',
+                    reason: `low relevance (${relevance.toFixed(2)}) to task`,
+                    estimatedTokens: 0
+                };
+            }
+            else if (estFull < 300) {
+                // Small file — always read fully
+                plan = {
+                    file,
+                    action: 'full',
+                    reason: 'small file, cheap to read',
+                    estimatedTokens: estFull
+                };
+            }
+            else if (relevance < 0.40 || estFull > 30_000) {
+                // Low relevance or huge file — outline only
+                plan = {
+                    file,
+                    action: 'outline',
+                    reason: relevance < 0.40
+                        ? `medium relevance (${relevance.toFixed(2)}), read outline`
+                        : `large file (${Math.round(file.sizeBytes / 1024)}KB), read outline`,
+                    estimatedTokens: 250
+                };
+            }
+            else if (estFull > 5_000) {
+                // Large but relevant — read hot sections
+                const { start, end } = this.estimateHotLines(file, taskKeywords);
+                plan = {
+                    file,
+                    action: 'partial',
+                    startLine: start,
+                    endLine: end,
+                    reason: `relevant but large — reading lines ${start}-${end}`,
+                    estimatedTokens: Math.ceil(((end - start) * 80) / 4) // ~80 chars/line
+                };
+            }
+            else {
+                // Relevant, reasonable size — full read
+                plan = {
+                    file,
+                    action: 'full',
+                    reason: `high relevance (${relevance.toFixed(2)})`,
+                    estimatedTokens: estFull
+                };
+            }
+            totalTokens += plan.estimatedTokens;
+            plans.push(plan);
+        }
+        return {
+            task,
+            files: plans,
+            totalEstimatedTokens: totalTokens,
+            savings: fullReadTokens - totalTokens,
+            sessionBudget: this.sessionBudget
+        };
+    }
+    /**
+     * Legacy compatibility wrapper for NexusPrime.
+     */
+    optimize(context, task) {
+        const files = context.map((c, i) => ({
+            path: `context_${i}.txt`,
+            sizeBytes: c.length * 4,
+            lastModified: Date.now()
+        }));
+        return this.plan(task, files);
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Differential Context: only pass what CHANGED
+    // Saves ~60-70% tokens on follow-up sessions
+    // ───────────────────────────────────────────────────────────────────────────
+    differential(prev, curr) {
+        const delta = {
+            added: [],
+            changed: [],
+            unchanged: [],
+            summary: prev.summary
+        };
+        for (const file of curr) {
+            const prevSHA = prev.fileSHAs[file.path];
+            const currSHA = this.fingerprintFile(file);
+            if (!prevSHA) {
+                delta.added.push(file);
+            }
+            else if (prevSHA !== currSHA) {
+                delta.changed.push(file);
+            }
+            else {
+                delta.unchanged.push(file); // SKIP — use prior summary
+            }
+        }
+        return delta;
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Multi-Worker Token Budget Allocation
+    // Byzantine-inspired: workers bid, budget allocated by expected value
+    // ───────────────────────────────────────────────────────────────────────────
+    allocateBudget(workers, totalBudget = this.sessionBudget) {
+        const bids = workers.map(w => ({
+            id: w.id,
+            score: w.estimatedValue / Math.max(w.estimatedCost, 1)
+        }));
+        const totalScore = bids.reduce((s, b) => s + b.score, 0) || 1;
+        const allocated = new Map();
+        let used = 0;
+        for (const bid of bids) {
+            const share = Math.floor((bid.score / totalScore) * totalBudget);
+            allocated.set(bid.id, share);
+            used += share;
+        }
+        return { total: totalBudget, allocated, remaining: totalBudget - used };
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Learn: record which files were actually useful for a task type
+    // ───────────────────────────────────────────────────────────────────────────
+    learn(taskType, usefulFiles, skipFiles) {
+        if (!this.relevanceCache.has(taskType)) {
+            this.relevanceCache.set(taskType, new Map());
+        }
+        const cache = this.relevanceCache.get(taskType);
+        for (const f of usefulFiles) {
+            cache.set(f, (cache.get(f) ?? 0) + 1.0);
+        }
+        for (const f of skipFiles) {
+            cache.set(f, (cache.get(f) ?? 0) - 0.3); // mild penalty
+        }
+        this.saveRelevanceCache();
+    }
+    loadRelevanceCache() {
+        try {
+            if (fs.existsSync(this.relevanceCachePath)) {
+                const data = JSON.parse(fs.readFileSync(this.relevanceCachePath, 'utf-8'));
+                for (const [taskType, fileScores] of Object.entries(data)) {
+                    const scoreMap = new Map(Object.entries(fileScores));
+                    this.relevanceCache.set(taskType, scoreMap);
+                }
+            }
+        }
+        catch (e) {
+            console.error('Failed to load relevance cache:', e);
+        }
+    }
+    saveRelevanceCache() {
+        try {
+            const data = {};
+            for (const [taskType, scoreMap] of this.relevanceCache.entries()) {
+                data[taskType] = Object.fromEntries(scoreMap.entries());
+            }
+            fs.writeFileSync(this.relevanceCachePath, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            console.error('Failed to save relevance cache:', e);
+        }
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Session summary persistence
+    // ───────────────────────────────────────────────────────────────────────────
+    saveSessionSummary(summary) {
+        const date = new Date(summary.timestamp).toISOString().slice(0, 10);
+        const file = path.join(this.sessionPath, `${date}-${summary.sessionId}.json`);
+        fs.writeFileSync(file, JSON.stringify(summary, null, 2));
+    }
+    loadLatestSessionSummary() {
+        try {
+            const files = fs.readdirSync(this.sessionPath)
+                .filter(f => f.endsWith('.json'))
+                .sort()
+                .reverse();
+            if (files.length === 0)
+                return null;
+            const content = fs.readFileSync(path.join(this.sessionPath, files[0]), 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    // ───────────────────────────────────────────────────────────────────────────
+    // Helpers
+    // ───────────────────────────────────────────────────────────────────────────
+    extractKeywords(task) {
+        // Remove stop words, extract meaningful tokens
+        const stopWords = new Set([
+            'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been',
+            'being', 'have', 'has', 'had', 'do', 'does', 'did', 'will',
+            'would', 'could', 'should', 'may', 'might', 'must', 'can',
+            'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from',
+            'and', 'or', 'but', 'if', 'then', 'than', 'that', 'this',
+            'it', 'its', 'we', 'our', 'you', 'your', 'i', 'my'
+        ]);
+        return task
+            .toLowerCase()
+            .replace(/[^a-z0-9\s_\-\/\.]/g, ' ')
+            .split(/\s+/)
+            .filter(w => w.length > 2 && !stopWords.has(w));
+    }
+    scoreRelevance(filePath, keywords) {
+        if (keywords.length === 0)
+            return 0.5;
+        // ── Normalize path: strip cwd prefix so keywords match relative segments ──
+        const cwd = process.cwd().toLowerCase().replace(/\\/g, '/');
+        let normalized = filePath.toLowerCase().replace(/\\/g, '/');
+        if (normalized.startsWith(cwd)) {
+            normalized = normalized.slice(cwd.length).replace(/^\//, '');
+        }
+        const parts = normalized.split('/');
+        const fileName = parts[parts.length - 1];
+        const baseName = fileName.replace(/\.[^.]+$/, ''); // e.g. "memory" from "memory.ts"
+        const ext = fileName.split('.').pop() ?? '';
+        // ── Extension-based baseline: .ts/.js files always get a floor for code tasks ──
+        let extBaseline = 0;
+        if (['ts', 'js', 'tsx', 'jsx'].includes(ext))
+            extBaseline = 0.20;
+        else if (['json', 'md'].includes(ext))
+            extBaseline = 0.15;
+        // ── Path keyword matching ──
+        let pathScore = 0;
+        let pathMatches = 0;
+        for (const kw of keywords) {
+            // Check basename directly (e.g. keyword "memory" matches "memory.ts")
+            if (baseName === kw || baseName.includes(kw)) {
+                pathMatches++;
+                pathScore += 1.5;
+            }
+            else if (normalized.includes(kw)) {
+                pathMatches++;
+                pathScore += 0.8;
+            }
+        }
+        // ── Content-aware scoring (first 500 bytes) — weighted heavily ──
+        let contentBonus = 0;
+        try {
+            const fullPath = path.isAbsolute(filePath) ? filePath : path.join(process.cwd(), filePath);
+            if (fs.existsSync(fullPath)) {
+                const fd = fs.openSync(fullPath, 'r');
+                const buffer = Buffer.alloc(500);
+                const bytesRead = fs.readSync(fd, buffer, 0, 500, 0);
+                fs.closeSync(fd);
+                const content = buffer.toString('utf-8', 0, bytesRead).toLowerCase();
+                const contentKeywords = this.extractKeywords(content);
+                let contentMatches = 0;
+                for (const kw of keywords) {
+                    if (contentKeywords.includes(kw))
+                        contentMatches++;
+                }
+                // Boost from 0.6 → 0.8 — content is the most reliable signal
+                contentBonus = (contentMatches / keywords.length) * 0.8;
+            }
+        }
+        catch { /* ignore */ }
+        // ── Learned relevance ──
+        const taskType = keywords.slice(0, 3).join('_');
+        const learnedScore = this.relevanceCache.get(taskType)?.get(filePath) ?? 0;
+        // ── Semantic type bonuses ──
+        let typeBonus = 0;
+        const codeKws = ['fix', 'bug', 'debug', 'error', 'impl', 'add', 'build', 'audit', 'nexus', 'prime', 'tools', 'code', 'source'];
+        const memKws = ['memory', 'cache', 'store', 'recall', 'persist'];
+        const testKws = ['test', 'spec', 'jest', 'validate', 'verify'];
+        if (keywords.some(k => codeKws.includes(k)) && ['ts', 'js', 'json', 'md'].includes(ext)) {
+            typeBonus = 0.15;
+        }
+        if (keywords.some(k => memKws.includes(k)) && (normalized.includes('memory') || baseName.includes('memory'))) {
+            typeBonus = 0.4;
+        }
+        if (keywords.some(k => testKws.includes(k)) && ['test', 'spec'].some(t => fileName.includes(t))) {
+            typeBonus = 0.3;
+        }
+        // ── Combine: baseline + path + content + type + learned ──
+        const pathComponent = keywords.length > 0
+            ? (pathMatches / keywords.length) * (pathScore / Math.max(pathMatches, 1))
+            : 0;
+        return Math.min(1, Math.max(extBaseline, pathComponent + typeBonus + learnedScore * 0.1 + contentBonus));
+    }
+    estimateHotLines(file, keywords) {
+        // Without reading the file, estimate hot sections by filename heuristics
+        // In production, the Ghost Pass pre-reads and provides actual line hints
+        const totalLines = Math.ceil(file.sizeBytes / 80); // ~80 chars/line
+        const windowSize = Math.min(200, Math.ceil(totalLines * 0.3));
+        // Heuristic: hot code tends to be in first 30% or last 30% of file
+        // Default to first section (imports + main logic)
+        return {
+            start: 1,
+            end: Math.min(windowSize, totalLines)
+        };
+    }
+    fingerprintFile(file) {
+        // Use mtime + size as cheap fingerprint (no hashing needed)
+        return `${file.lastModified ?? 0}-${file.sizeBytes}`;
+    }
+    /**
+     * Adjust token budget based on task complexity signals.
+     * Complex tasks get +25% budget; simple lookups get -25%.
+     */
+    hypertune(task) {
+        const taskLower = task.toLowerCase();
+        const originalBudget = this.sessionBudget;
+        // Complexity signals
+        const complexSignals = ['refactor', 'complex', 'rewrite', 'migration', 'audit', 'architecture', 'redesign'];
+        const simpleSignals = ['lookup', 'find', 'list', 'check', 'quick', 'status'];
+        const isComplex = complexSignals.some(s => taskLower.includes(s));
+        const isSimple = simpleSignals.some(s => taskLower.includes(s));
+        if (isComplex) {
+            this.sessionBudget = Math.round(originalBudget * 1.25);
+        }
+        else if (isSimple) {
+            this.sessionBudget = Math.round(originalBudget * 0.75);
+        }
+        if (this.sessionBudget !== originalBudget) {
+            console.error(`[Token Engine] Hypertuned: budget ${originalBudget.toLocaleString()} → ${this.sessionBudget.toLocaleString()} tokens (${isComplex ? 'complex' : 'simple'} task detected)`);
+        }
+    }
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Plan formatter (for MCP response)
+// ─────────────────────────────────────────────────────────────────────────────
+export function formatReadingPlan(plan) {
+    const lines = [
+        `📊 Token Budget Plan for: "${plan.task}"`,
+        `Total estimated: ${plan.totalEstimatedTokens.toLocaleString()} tokens`,
+        `Savings vs full read: ${plan.savings.toLocaleString()} tokens (${Math.round(plan.savings / Math.max(plan.savings + plan.totalEstimatedTokens, 1) * 100)}%)`,
+        '',
+        '📋 Reading Plan:'
+    ];
+    const byAction = {
+        full: [], outline: [], partial: [], skip: []
+    };
+    for (const fp of plan.files) {
+        byAction[fp.action].push(fp);
+    }
+    if (byAction.full.length > 0) {
+        lines.push('  ✅ Read fully:');
+        byAction.full.forEach(f => lines.push(`    • ${f.file.path} (~${f.estimatedTokens} tokens)`));
+    }
+    if (byAction.partial.length > 0) {
+        lines.push('  ✂️  Read partially:');
+        byAction.partial.forEach(f => lines.push(`    • ${f.file.path} lines ${f.startLine}-${f.endLine} (~${f.estimatedTokens} tokens)`));
+    }
+    if (byAction.outline.length > 0) {
+        lines.push('  🔍 Outline only:');
+        byAction.outline.forEach(f => lines.push(`    • ${f.file.path} (~${f.estimatedTokens} tokens)`));
+    }
+    if (byAction.skip.length > 0) {
+        lines.push('  ⏭️  Skip:');
+        byAction.skip.forEach(f => lines.push(`    • ${f.file.path} (${f.reason})`));
+    }
+    return lines.join('\n');
+}
+export const createTokenSupremacyEngine = (budget) => new TokenSupremacyEngine(budget);
+//# sourceMappingURL=token-supremacy.js.map