synapsexcoder 6.0.0

package/dist/modes/synapse-modes.js

@@ -0,0 +1,69 @@
+/**
+ * SynapseXcoder Mode Registry
+ *
+ * Central registry for processing modes including Phase 0 additional modes
+ * and user-defined custom modes from ~/.synapsexcoder/custom-modes.yaml
+ */
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { parse as parseYaml } from "yaml";
+const BUILTIN_MODES = [
+    { id: "full_pipeline", label: "Full Pipeline", description: "Complete multi-agent pipeline" },
+    { id: "merge_only", label: "Merge Only", description: "Combine inputs without analysis" },
+    { id: "analyze_only", label: "Analyze Only", description: "Detection and assessment only" },
+    { id: "review_only", label: "Review Only", description: "Review without rewrites" },
+    { id: "rewrite_only", label: "Rewrite Only", description: "Apply fixes from prior analysis" },
+    { id: "dry_run", label: "Dry Run", description: "Simulate without writes" },
+    { id: "security_scan", label: "Security Scan", description: "Vulnerability assessment" },
+    { id: "debug_assistant", label: "Debug Assistant", description: "Stack trace analysis" },
+    { id: "api_validation", label: "API Validation", description: "Endpoint validation" },
+    { id: "doc_generator", label: "Doc Generator", description: "Documentation extraction" },
+    { id: "ui_design", label: "UI Design", description: "Mockups and WCAG audit" },
+    { id: "create_mode", label: "Create Mode", description: "Greenfield scaffolding" },
+    { id: "debug_mode", label: "Debug Mode", description: "Focused debugging workflow" },
+    { id: "refactor_mode", label: "Refactor Mode", description: "Structured refactoring" },
+    { id: "document_mode", label: "Document Mode", description: "Deep documentation generation" },
+    { id: "security_mode", label: "Security Mode", description: "Hardened security workflow" },
+];
+export class SynapseModeRegistry {
+    customModes = new Map();
+    constructor() {
+        this.loadCustomModes();
+    }
+    loadCustomModes() {
+        const path = join(homedir(), ".synapsexcoder", "custom-modes.yaml");
+        if (!existsSync(path))
+            return;
+        try {
+            const doc = parseYaml(readFileSync(path, "utf-8"));
+            for (const [id, def] of Object.entries(doc.modes ?? {})) {
+                this.customModes.set(id, {
+                    id,
+                    label: def.label ?? id,
+                    description: def.description ?? "",
+                    agents: def.agents,
+                    tools: def.tools,
+                    basePipeline: def.basePipeline ?? def.pipeline,
+                });
+            }
+        }
+        catch {
+            // Invalid YAML — skip custom modes
+        }
+    }
+    listModes() {
+        return [...BUILTIN_MODES, ...this.customModes.values()];
+    }
+    getMode(id) {
+        return (BUILTIN_MODES.find((m) => m.id === id) ?? this.customModes.get(id));
+    }
+    registerCustomMode(def) {
+        this.customModes.set(String(def.id), def);
+    }
+    isValidMode(id) {
+        return this.getMode(id) !== undefined;
+    }
+}
+export const synapseModeRegistry = new SynapseModeRegistry();
+//# sourceMappingURL=synapse-modes.js.map

package/dist/modes/synapse-modes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"synapse-modes.js","sourceRoot":"","sources":["../../src/modes/synapse-modes.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,IAAI,CAAC;AAC9C,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAC5B,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAC;AAC7B,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,MAAM,CAAC;AAY1C,MAAM,aAAa,GAAqB;IACtC,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,+BAA+B,EAAE;IAC7F,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,iCAAiC,EAAE;IACzF,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,+BAA+B,EAAE;IAC3F,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,yBAAyB,EAAE;IACnF,EAAE,EAAE,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,iCAAiC,EAAE;IAC7F,EAAE,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,yBAAyB,EAAE;IAC3E,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,0BAA0B,EAAE;IACxF,EAAE,EAAE,EAAE,iBAAiB,EAAE,KAAK,EAAE,iBAAiB,EAAE,WAAW,EAAE,sBAAsB,EAAE;IACxF,EAAE,EAAE,EAAE,gBAAgB,EAAE,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,qBAAqB,EAAE;IACrF,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,0BAA0B,EAAE;IACxF,EAAE,EAAE,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,wBAAwB,EAAE;IAC9E,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,wBAAwB,EAAE;IAClF,EAAE,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,4BAA4B,EAAE;IACpF,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,wBAAwB,EAAE;IACtF,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,+BAA+B,EAAE;IAC7F,EAAE,EAAE,EAAE,eAAe,EAAE,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,4BAA4B,EAAE;CAC3F,CAAC;AAEF,MAAM,OAAO,mBAAmB;IACtB,WAAW,GAAG,IAAI,GAAG,EAA0B,CAAC;IAExD;QACE,IAAI,CAAC,eAAe,EAAE,CAAC;IACzB,CAAC;IAEO,eAAe;QACrB,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,gBAAgB,EAAE,mBAAmB,CAAC,CAAC;QACpE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO;QAC9B,IAAI,CAAC;YACH,MAAM,GAAG,GAAG,SAAS,CAAC,YAAY,CAAC,IAAI,EAAE,OAAO,CAAC,CAEhD,CAAC;YACF,KAAK,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC;gBACxD,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,EAAE;oBACvB,EAAE;oBACF,KAAK,EAAE,GAAG,CAAC,KAAK,IAAI,EAAE;oBACtB,WAAW,EAAE,GAAG,CAAC,WAAW,IAAI,EAAE;oBAClC,MAAM,EAAE,GAAG,CAAC,MAAM;oBAClB,KAAK,EAAE,GAAG,CAAC,KAAK;oBAChB,YAAY,EAAE,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,QAAQ;iBAC/C,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAAC,MAAM,CAAC;YACP,mCAAmC;QACrC,CAAC;IACH,CAAC;IAED,SAAS;QACP,OAAO,CAAC,GAAG,aAAa,EAAE,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,CAAC,EAAU;QAChB,OAAO,CACL,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CACnE,CAAC;IACJ,CAAC;IAED,kBAAkB,CAAC,GAAmB;QACpC,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,WAAW,CAAC,EAAU;QACpB,OAAO,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,SAAS,CAAC;IACxC,CAAC;CACF;AAED,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,mBAAmB,EAAE,CAAC"}

package/dist/opencode/agent-delegate.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Use ../synapsexcoder/agent-delegate.js */
+export * from "../synapsexcoder/agent-delegate.js";
+//# sourceMappingURL=agent-delegate.d.ts.map

package/dist/opencode/agent-delegate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-delegate.d.ts","sourceRoot":"","sources":["../../src/opencode/agent-delegate.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,cAAc,oCAAoC,CAAC"}

package/dist/opencode/agent-delegate.js

@@ -0,0 +1,3 @@
+/** @deprecated Use ../synapsexcoder/agent-delegate.js */
+export * from "../synapsexcoder/agent-delegate.js";
+//# sourceMappingURL=agent-delegate.js.map

package/dist/opencode/agent-delegate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-delegate.js","sourceRoot":"","sources":["../../src/opencode/agent-delegate.ts"],"names":[],"mappings":"AAAA,yDAAyD;AACzD,cAAc,oCAAoC,CAAC"}

package/dist/opencode/tool-bridge.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Use ../synapsexcoder/tool-bridge.js */
+export * from "../synapsexcoder/tool-bridge.js";
+//# sourceMappingURL=tool-bridge.d.ts.map

package/dist/opencode/tool-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-bridge.d.ts","sourceRoot":"","sources":["../../src/opencode/tool-bridge.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,cAAc,iCAAiC,CAAC"}

package/dist/opencode/tool-bridge.js

@@ -0,0 +1,3 @@
+/** @deprecated Use ../synapsexcoder/tool-bridge.js */
+export * from "../synapsexcoder/tool-bridge.js";
+//# sourceMappingURL=tool-bridge.js.map

package/dist/opencode/tool-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-bridge.js","sourceRoot":"","sources":["../../src/opencode/tool-bridge.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,cAAc,iCAAiC,CAAC"}

package/dist/optimization/token-optimizer-v2.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Token Optimizer v2 – Budget Optimizer
+ *
+ * Extends the existing TokenOptimizer with a simple budget‑aware API.
+ * The optimizer selects the most important context chunks that fit within
+ * a user‑specified token budget. It re‑uses the `createContextChunk` and
+ * `getOptimizedContext` methods from the original TokenOptimizer.
+ */
+import { TokenOptimizer } from "./token-optimizer";
+export declare class TokenBudgetOptimizer extends TokenOptimizer {
+    /**
+     * Optimize a set of context chunk IDs to fit within `budgetTokens`.
+     * Returns the selected chunk IDs in order of importance.
+     */
+    allocateBudget(budgetTokens: number, chunkIds: string[]): string[];
+}
+export declare function createTokenBudgetOptimizer(): TokenBudgetOptimizer;
+//# sourceMappingURL=token-optimizer-v2.d.ts.map

package/dist/optimization/token-optimizer-v2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-optimizer-v2.d.ts","sourceRoot":"","sources":["../../src/optimization/token-optimizer-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,qBAAa,oBAAqB,SAAQ,cAAc;IACtD;;;OAGG;IACI,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;CAI1E;AAED,wBAAgB,0BAA0B,IAAI,oBAAoB,CAEjE"}

package/dist/optimization/token-optimizer-v2.js

@@ -0,0 +1,23 @@
+/**
+ * Token Optimizer v2 – Budget Optimizer
+ *
+ * Extends the existing TokenOptimizer with a simple budget‑aware API.
+ * The optimizer selects the most important context chunks that fit within
+ * a user‑specified token budget. It re‑uses the `createContextChunk` and
+ * `getOptimizedContext` methods from the original TokenOptimizer.
+ */
+import { TokenOptimizer } from "./token-optimizer";
+export class TokenBudgetOptimizer extends TokenOptimizer {
+    /**
+     * Optimize a set of context chunk IDs to fit within `budgetTokens`.
+     * Returns the selected chunk IDs in order of importance.
+     */
+    allocateBudget(budgetTokens, chunkIds) {
+        const result = this.getOptimizedContext(budgetTokens, chunkIds);
+        return result.chunks.map((c) => c.id);
+    }
+}
+export function createTokenBudgetOptimizer() {
+    return new TokenBudgetOptimizer();
+}
+//# sourceMappingURL=token-optimizer-v2.js.map

package/dist/optimization/token-optimizer-v2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"token-optimizer-v2.js","sourceRoot":"","sources":["../../src/optimization/token-optimizer-v2.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,OAAO,oBAAqB,SAAQ,cAAc;IACtD;;;OAGG;IACI,cAAc,CAAC,YAAoB,EAAE,QAAkB;QAC5D,MAAM,MAAM,GAAG,IAAI,CAAC,mBAAmB,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;QAChE,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IACxC,CAAC;CACF;AAED,MAAM,UAAU,0BAA0B;IACxC,OAAO,IAAI,oBAAoB,EAAE,CAAC;AACpC,CAAC"}

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

@@ -0,0 +1,90 @@
+/**
+ * Token Efficiency Optimization System
+ *
+ * Implements MVI (Minimum Viable Information) principles from OpenAgentsControl
+ * for intelligent context compression and token optimization.
+ */
+export interface TokenMetrics {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+    estimatedCost: number;
+    compressionRatio: number;
+}
+export interface CompressedContext {
+    id: string;
+    originalSize: number;
+    compressedSize: number;
+    compressionRatio: number;
+    summary: string;
+    keyPoints: string[];
+    entities: Array<{
+        name: string;
+        type: "person" | "organization" | "technology" | "concept" | "file" | "function";
+        importance: number;
+    }>;
+    relationships: Array<{
+        from: string;
+        to: string;
+        type: string;
+        strength: number;
+    }>;
+    createdAt: number;
+    expiresAt?: number;
+}
+export interface ContextChunk {
+    id: string;
+    content: string;
+    type: "code" | "text" | "data" | "metadata";
+    importance: number;
+    tokens: number;
+    lastAccessed: number;
+    accessCount: number;
+    dependencies: string[];
+}
+export declare class TokenOptimizer {
+    private contextCache;
+    private chunkCache;
+    private compressionThreshold;
+    compressContext(content: string, type?: "code" | "conversation" | "documentation" | "mixed"): Promise<CompressedContext>;
+    private performCompression;
+    private compressCode;
+    private compressConversation;
+    private compressDocumentation;
+    private compressMixed;
+    createContextChunk(content: string, type: ContextChunk["type"], importance?: number): string;
+    getOptimizedContext(availableTokens: number, contextIds: string[]): {
+        chunks: ContextChunk[];
+        totalTokens: number;
+        compressionApplied: boolean;
+    };
+    generateSmartSummary(contents: string[], maxTokens: number, focus?: string): Promise<string>;
+    private extractRelevantParts;
+    private summarizeContent;
+    private calculateImportance;
+    estimateTokens(text: string): number;
+    calculateMetrics(prompt: string, completion: string, model?: string): TokenMetrics;
+    cleanupExpiredCache(): void;
+    getCacheStats(): {
+        compressedContexts: number;
+        contextChunks: number;
+        totalTokensSaved: number;
+    };
+    optimizeContextWindow(messages: Array<{
+        role: string;
+        content: string;
+    }>, maxTokens: number): Array<{
+        role: string;
+        content: string;
+    }>;
+    learnFromUsage(metrics: TokenMetrics, success: boolean): void;
+    analyzeEfficiency(): {
+        averageCompressionRatio: number;
+        tokenSavingsPercentage: number;
+        cacheHitRate: number;
+    };
+}
+export declare function createTokenOptimizer(): TokenOptimizer;
+export declare function estimateTokenCost(tokens: number, model?: string): number;
+export declare function optimizePromptForModel(prompt: string, _model: string, maxTokens: number): string;
+//# sourceMappingURL=token-optimizer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"token-optimizer.d.ts","sourceRoot":"","sources":["../../src/optimization/token-optimizer.ts"],"names":[],"mappings":"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"}

package/dist/optimization/token-optimizer.js

@@ -0,0 +1,399 @@
+/**
+ * Token Efficiency Optimization System
+ *
+ * Implements MVI (Minimum Viable Information) principles from OpenAgentsControl
+ * for intelligent context compression and token optimization.
+ */
+import { v4 as uuidv4 } from "uuid";
+export class TokenOptimizer {
+    contextCache = new Map();
+    chunkCache = new Map();
+    compressionThreshold = 1000; // tokens
+    // ========================================================================
+    // Context Compression
+    // ========================================================================
+    async compressContext(content, type = "mixed") {
+        const originalTokens = this.estimateTokens(content);
+        if (originalTokens < this.compressionThreshold) {
+            // No compression needed for small content
+            return {
+                id: uuidv4(),
+                originalSize: originalTokens,
+                compressedSize: originalTokens,
+                compressionRatio: 1.0,
+                summary: content,
+                keyPoints: [content],
+                entities: [],
+                relationships: [],
+                createdAt: Date.now(),
+            };
+        }
+        const compressed = await this.performCompression(content, type);
+        const compressedTokens = this.estimateTokens(compressed.summary);
+        return {
+            id: uuidv4(),
+            originalSize: originalTokens,
+            compressedSize: compressedTokens,
+            compressionRatio: originalTokens / compressedTokens,
+            summary: compressed.summary,
+            keyPoints: compressed.keyPoints,
+            entities: compressed.entities,
+            relationships: compressed.relationships,
+            createdAt: Date.now(),
+            expiresAt: Date.now() + 24 * 60 * 60 * 1000, // 24 hours
+        };
+    }
+    async performCompression(content, type) {
+        // Extract key information based on content type
+        switch (type) {
+            case "code":
+                return this.compressCode(content);
+            case "conversation":
+                return this.compressConversation(content);
+            case "documentation":
+                return this.compressDocumentation(content);
+            default:
+                return this.compressMixed(content);
+        }
+    }
+    compressCode(code) {
+        // Extract functions, classes, imports, and key logic
+        const functions = code.match(/function\s+\w+|const\s+\w+\s*=|class\s+\w+/g) || [];
+        const imports = code.match(/import\s+.*from\s+['"'][^'"']+['"']/g) || [];
+        const exports = code.match(/export\s+(const|function|class)/g) || [];
+        const keyPoints = [
+            `Functions: ${functions.slice(0, 5).join(", ")}`,
+            `Imports: ${imports.length} imports`,
+            `Exports: ${exports.length} exports`,
+        ];
+        const entities = functions.map((f) => ({
+            name: f
+                .replace(/^(function|const|class)\s+/, "")
+                .split("=")[0]
+                .trim(),
+            type: "function",
+            importance: 0.8,
+        }));
+        return {
+            summary: `Code module with ${functions.length} functions, ${imports.length} imports, ${exports.length} exports.`,
+            keyPoints,
+            entities,
+            relationships: [],
+        };
+    }
+    compressConversation(conversation) {
+        // Extract key decisions, agreements, and action items
+        const lines = conversation.split("\n");
+        const decisions = lines.filter((line) => line.toLowerCase().includes("decided") ||
+            line.toLowerCase().includes("agreed"));
+        const actions = lines.filter((line) => line.toLowerCase().includes("will") ||
+            line.toLowerCase().includes("should"));
+        const keyPoints = [...decisions.slice(0, 3), ...actions.slice(0, 3)];
+        return {
+            summary: `Conversation with ${decisions.length} decisions and ${actions.length} action items.`,
+            keyPoints,
+            entities: [],
+            relationships: [],
+        };
+    }
+    compressDocumentation(docs) {
+        // Extract headings, key concepts, and important information
+        const headings = docs.match(/^#{1,6}\s+.+$/gm) || [];
+        const keyTerms = docs.match(/\b[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\b/g) || [];
+        const keyPoints = headings.slice(0, 5).map((h) => h.replace(/^#+\s*/, ""));
+        const entities = keyTerms.slice(0, 10).map((term) => ({
+            name: term,
+            type: "concept",
+            importance: 0.6,
+        }));
+        return {
+            summary: `Documentation with ${headings.length} sections covering ${keyTerms.slice(0, 5).join(", ")}.`,
+            keyPoints,
+            entities,
+            relationships: [],
+        };
+    }
+    compressMixed(content) {
+        // Generic compression for mixed content
+        const sentences = content
+            .split(/[.!?]+/)
+            .filter((s) => s.trim().length > 10);
+        const keyPoints = sentences.slice(0, 5);
+        return {
+            summary: content.substring(0, 200) + (content.length > 200 ? "..." : ""),
+            keyPoints,
+            entities: [],
+            relationships: [],
+        };
+    }
+    // ========================================================================
+    // Context Chunking and Caching
+    // ========================================================================
+    createContextChunk(content, type, importance = 0.5) {
+        const chunk = {
+            id: uuidv4(),
+            content,
+            type,
+            importance,
+            tokens: this.estimateTokens(content),
+            lastAccessed: Date.now(),
+            accessCount: 1,
+            dependencies: [],
+        };
+        this.chunkCache.set(chunk.id, chunk);
+        return chunk.id;
+    }
+    getOptimizedContext(availableTokens, contextIds) {
+        const chunks = contextIds
+            .map((id) => this.chunkCache.get(id))
+            .filter((chunk) => chunk !== undefined)
+            .sort((a, b) => b.importance - a.importance); // Most important first
+        let selectedChunks = [];
+        let totalTokens = 0;
+        for (const chunk of chunks) {
+            if (totalTokens + chunk.tokens <= availableTokens) {
+                selectedChunks.push(chunk);
+                totalTokens += chunk.tokens;
+                chunk.lastAccessed = Date.now();
+                chunk.accessCount++;
+            }
+            else {
+                break;
+            }
+        }
+        // If we couldn't fit all important chunks, apply compression
+        const compressionApplied = selectedChunks.length < chunks.length;
+        return {
+            chunks: selectedChunks,
+            totalTokens,
+            compressionApplied,
+        };
+    }
+    // ========================================================================
+    // Intelligent Summarization
+    // ========================================================================
+    async generateSmartSummary(contents, maxTokens, focus) {
+        const combined = contents.join("\n\n");
+        const totalTokens = this.estimateTokens(combined);
+        if (totalTokens <= maxTokens) {
+            return combined;
+        }
+        // Extract most relevant parts based on focus
+        const relevantParts = this.extractRelevantParts(combined, focus);
+        const summary = await this.summarizeContent(relevantParts.join("\n\n"), maxTokens);
+        return summary;
+    }
+    extractRelevantParts(content, focus) {
+        const parts = content.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+        if (!focus) {
+            // Return most important parts (first, last, and middle sections)
+            const result = [parts[0]]; // First part
+            if (parts.length > 2)
+                result.push(parts[Math.floor(parts.length / 2)]); // Middle
+            if (parts.length > 1)
+                result.push(parts[parts.length - 1]); // Last part
+            return result;
+        }
+        // Filter parts that contain focus keywords
+        const focusWords = focus.toLowerCase().split(/\s+/);
+        return parts
+            .filter((part) => focusWords.some((word) => part.toLowerCase().includes(word)))
+            .slice(0, 5); // Limit to 5 most relevant parts
+    }
+    async summarizeContent(content, maxTokens) {
+        // Simple extractive summarization - in practice, this would use AI
+        const sentences = content
+            .split(/[.!?]+/)
+            .filter((s) => s.trim().length > 10);
+        const importantSentences = sentences
+            .sort((a, b) => this.calculateImportance(b) - this.calculateImportance(a))
+            .slice(0, Math.floor(maxTokens / 20)); // Estimate 20 tokens per sentence
+        return importantSentences.join(". ") + ".";
+    }
+    calculateImportance(sentence) {
+        let score = 0;
+        // Keywords that indicate importance
+        const importantWords = [
+            "important",
+            "key",
+            "critical",
+            "must",
+            "should",
+            "error",
+            "fix",
+            "bug",
+        ];
+        const questionWords = ["what", "how", "why", "when", "where", "who"];
+        importantWords.forEach((word) => {
+            if (sentence.toLowerCase().includes(word))
+                score += 2;
+        });
+        questionWords.forEach((word) => {
+            if (sentence.toLowerCase().includes(word))
+                score += 1;
+        });
+        // Length bonus (medium-length sentences are often more informative)
+        const length = sentence.length;
+        if (length > 50 && length < 200)
+            score += 1;
+        return score;
+    }
+    // ========================================================================
+    // Token Estimation and Metrics
+    // ========================================================================
+    estimateTokens(text) {
+        // Rough estimation: ~4 characters per token for English text
+        // ~1.5 tokens per word on average
+        const words = text.split(/\s+/).length;
+        return Math.ceil(words * 1.3); // Conservative estimate
+    }
+    calculateMetrics(prompt, completion, model = "gpt-4") {
+        const promptTokens = this.estimateTokens(prompt);
+        const completionTokens = this.estimateTokens(completion);
+        const totalTokens = promptTokens + completionTokens;
+        // Rough cost estimation (per 1K tokens)
+        const costs = {
+            "gpt-4": { prompt: 0.03, completion: 0.06 },
+            "gpt-3.5-turbo": { prompt: 0.002, completion: 0.002 },
+            "claude-3": { prompt: 0.015, completion: 0.075 },
+        };
+        const modelCosts = costs[model] || costs["gpt-4"];
+        const estimatedCost = (promptTokens / 1000) * modelCosts.prompt +
+            (completionTokens / 1000) * modelCosts.completion;
+        return {
+            promptTokens,
+            completionTokens,
+            totalTokens,
+            estimatedCost,
+            compressionRatio: 1.0, // Would be calculated for compressed content
+        };
+    }
+    // ========================================================================
+    // Cache Management
+    // ========================================================================
+    cleanupExpiredCache() {
+        const now = Date.now();
+        // Clean up expired compressed contexts
+        for (const [id, context] of this.contextCache) {
+            if (context.expiresAt && context.expiresAt < now) {
+                this.contextCache.delete(id);
+            }
+        }
+        // Clean up old chunks (LRU eviction)
+        const chunks = Array.from(this.chunkCache.values()).sort((a, b) => a.lastAccessed - b.lastAccessed);
+        if (chunks.length > 1000) {
+            // Max cache size
+            const toRemove = chunks.slice(0, chunks.length - 1000);
+            toRemove.forEach((chunk) => this.chunkCache.delete(chunk.id));
+        }
+    }
+    getCacheStats() {
+        const compressedContexts = this.contextCache.size;
+        const contextChunks = this.chunkCache.size;
+        let totalTokensSaved = 0;
+        for (const context of this.contextCache.values()) {
+            totalTokensSaved += context.originalSize - context.compressedSize;
+        }
+        return {
+            compressedContexts,
+            contextChunks,
+            totalTokensSaved,
+        };
+    }
+    // ========================================================================
+    // Adaptive Context Window Management
+    // ========================================================================
+    optimizeContextWindow(messages, maxTokens) {
+        let totalTokens = 0;
+        const optimized = [];
+        // Always keep system message if present
+        const systemMessages = messages.filter((m) => m.role === "system");
+        if (systemMessages.length > 0) {
+            optimized.push(...systemMessages);
+            totalTokens += systemMessages.reduce((sum, m) => sum + this.estimateTokens(m.content), 0);
+        }
+        // Add recent messages, compressing older ones if needed
+        const conversationMessages = messages
+            .filter((m) => m.role !== "system")
+            .reverse();
+        for (const message of conversationMessages) {
+            const messageTokens = this.estimateTokens(message.content);
+            if (totalTokens + messageTokens <= maxTokens) {
+                optimized.unshift(message); // Add to beginning to maintain order
+                totalTokens += messageTokens;
+            }
+            else if (message.role === "user") {
+                // Compress user messages if they're too long
+                const compressed = message.content.substring(0, Math.floor(maxTokens * 3)) + "...";
+                const compressedTokens = this.estimateTokens(compressed);
+                if (totalTokens + compressedTokens <= maxTokens) {
+                    optimized.unshift({ ...message, content: compressed });
+                    totalTokens += compressedTokens;
+                }
+            }
+            // Skip assistant messages if we can't fit them
+        }
+        return optimized;
+    }
+    // ========================================================================
+    // Learning and Adaptation
+    // ========================================================================
+    learnFromUsage(metrics, success) {
+        // Adapt compression strategies based on usage patterns
+        if (metrics.compressionRatio > 2.0 && success) {
+            // Good compression maintained success - increase compression aggressiveness
+            this.compressionThreshold = Math.max(500, this.compressionThreshold - 100);
+        }
+        else if (metrics.compressionRatio < 1.2 && !success) {
+            // Poor compression led to failure - reduce compression
+            this.compressionThreshold = Math.min(2000, this.compressionThreshold + 200);
+        }
+    }
+    analyzeEfficiency() {
+        const contexts = Array.from(this.contextCache.values());
+        if (contexts.length === 0) {
+            return {
+                averageCompressionRatio: 1.0,
+                tokenSavingsPercentage: 0,
+                cacheHitRate: 0,
+            };
+        }
+        const avgCompression = contexts.reduce((sum, c) => sum + c.compressionRatio, 0) /
+            contexts.length;
+        const totalOriginal = contexts.reduce((sum, c) => sum + c.originalSize, 0);
+        const totalCompressed = contexts.reduce((sum, c) => sum + c.compressedSize, 0);
+        const savings = totalOriginal > 0
+            ? ((totalOriginal - totalCompressed) / totalOriginal) * 100
+            : 0;
+        return {
+            averageCompressionRatio: avgCompression,
+            tokenSavingsPercentage: savings,
+            cacheHitRate: 0.85, // Placeholder - would track actual cache hits
+        };
+    }
+}
+// ========================================================================
+// Utility Functions
+// ========================================================================
+export function createTokenOptimizer() {
+    return new TokenOptimizer();
+}
+export function estimateTokenCost(tokens, model = "gpt-4") {
+    const costs = {
+        "gpt-4": 0.06,
+        "gpt-3.5-turbo": 0.002,
+        "claude-3": 0.075,
+    };
+    return (tokens / 1000) * (costs[model] || costs["gpt-4"]);
+}
+export function optimizePromptForModel(prompt, _model, maxTokens) {
+    const currentTokens = new TokenOptimizer().estimateTokens(prompt);
+    if (currentTokens <= maxTokens) {
+        return prompt;
+    }
+    // Simple truncation - in practice, would use more sophisticated methods
+    const charsPerToken = 4; // Rough estimate
+    const maxChars = maxTokens * charsPerToken;
+    return prompt.substring(0, maxChars - 3) + "...";
+}
+//# sourceMappingURL=token-optimizer.js.map