smartcontext-proxy 0.1.0

package/dist/config/defaults.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.DEFAULT_CONFIG = {
+    proxy: {
+        port: 4800,
+        host: '127.0.0.1',
+    },
+    providers: {},
+    context: {
+        tier1_exchanges: 3,
+        tier2_max_chunks: 10,
+        tier2_min_score: 0.55,
+        tier3_token_reserve: 500,
+        recency_boost: 0.15,
+        filepath_boost: 0.20,
+        dedup_threshold: 0.92,
+        confidence_gate: 0.55,
+        response_reserve_tokens: 8192,
+    },
+    logging: {
+        level: 'info',
+        raw_logs: true,
+        metrics: true,
+        debug_headers: false,
+    },
+};
+//# sourceMappingURL=defaults.js.map

package/dist/config/schema.d.ts

@@ -0,0 +1,30 @@
+export interface SmartContextConfig {
+    proxy: {
+        port: number;
+        host: string;
+    };
+    providers: Record<string, ProviderConfig>;
+    context: ContextConfig;
+    logging: LoggingConfig;
+}
+export interface ProviderConfig {
+    apiKey: string;
+    baseUrl?: string;
+}
+export interface ContextConfig {
+    tier1_exchanges: number;
+    tier2_max_chunks: number;
+    tier2_min_score: number;
+    tier3_token_reserve: number;
+    recency_boost: number;
+    filepath_boost: number;
+    dedup_threshold: number;
+    confidence_gate: number;
+    response_reserve_tokens: number;
+}
+export interface LoggingConfig {
+    level: 'error' | 'warn' | 'info' | 'debug';
+    raw_logs: boolean;
+    metrics: boolean;
+    debug_headers: boolean;
+}

package/dist/config/schema.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=schema.js.map

package/dist/context/budget.d.ts

@@ -0,0 +1,25 @@
+import type { ScoredChunk } from '../storage/types.js';
+import type { CanonicalMessage } from './canonical.js';
+export interface BudgetAllocation {
+    systemPromptTokens: number;
+    tier1Tokens: number;
+    tier2Budget: number;
+    tier3Reserve: number;
+    responseReserve: number;
+    totalAvailable: number;
+}
+export interface PackedContext {
+    systemPrompt?: string;
+    tier1Messages: CanonicalMessage[];
+    tier2Chunks: ScoredChunk[];
+    tier3Summary?: string;
+    allocation: BudgetAllocation;
+    originalTokens: number;
+    optimizedTokens: number;
+    savingsPercent: number;
+}
+export declare function getModelContextLimit(model: string): number;
+/**
+ * Allocate token budget across tiers and pack context.
+ */
+export declare function packContext(systemPrompt: string | undefined, messages: CanonicalMessage[], retrievedChunks: ScoredChunk[], model: string, tier1Exchanges: number, tier3Reserve: number, responseReserve: number): PackedContext;

package/dist/context/budget.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModelContextLimit = getModelContextLimit;
+exports.packContext = packContext;
+const canonical_js_1 = require("./canonical.js");
+const chunker_js_1 = require("./chunker.js");
+/** Known model context window sizes */
+const MODEL_CONTEXT_LIMITS = {
+    'claude-opus-4-6': 200000,
+    'claude-sonnet-4-6': 200000,
+    'claude-haiku-4-5-20251001': 200000,
+    'claude-3-5-sonnet-20241022': 200000,
+    'gpt-4o': 128000,
+    'gpt-4o-mini': 128000,
+    'gpt-4-turbo': 128000,
+    'o1': 200000,
+    'o1-mini': 128000,
+};
+const DEFAULT_CONTEXT_LIMIT = 128000;
+function getModelContextLimit(model) {
+    // Check exact match
+    if (MODEL_CONTEXT_LIMITS[model])
+        return MODEL_CONTEXT_LIMITS[model];
+    // Check prefix match
+    for (const [key, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+        if (model.startsWith(key))
+            return limit;
+    }
+    return DEFAULT_CONTEXT_LIMIT;
+}
+/**
+ * Allocate token budget across tiers and pack context.
+ */
+function packContext(systemPrompt, messages, retrievedChunks, model, tier1Exchanges, tier3Reserve, responseReserve) {
+    const contextLimit = getModelContextLimit(model);
+    // Calculate original tokens
+    const originalTokens = (0, chunker_js_1.estimateTokens)(systemPrompt || '') +
+        messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+    const systemPromptTokens = (0, chunker_js_1.estimateTokens)(systemPrompt || '');
+    // Extract Tier 1: last N exchanges (user+assistant pairs)
+    const tier1Messages = [];
+    let exchangeCount = 0;
+    for (let i = messages.length - 1; i >= 0 && exchangeCount < tier1Exchanges; i--) {
+        tier1Messages.unshift(messages[i]);
+        if (messages[i].role === 'user')
+            exchangeCount++;
+    }
+    const tier1Tokens = tier1Messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+    // Calculate available budget for Tier 2
+    const totalAvailable = contextLimit - systemPromptTokens - responseReserve;
+    const tier2Budget = Math.max(0, totalAvailable - tier1Tokens - tier3Reserve);
+    // Pack Tier 2 chunks greedily by score
+    const tier2Chunks = [];
+    let tier2Used = 0;
+    for (const chunk of retrievedChunks) {
+        if (tier2Used + chunk.metadata.tokenCount <= tier2Budget) {
+            tier2Chunks.push(chunk);
+            tier2Used += chunk.metadata.tokenCount;
+        }
+    }
+    // Tier 3: summary placeholder (will be filled by summary system later)
+    const tier3Summary = undefined;
+    const optimizedTokens = systemPromptTokens + tier1Tokens + tier2Used;
+    const allocation = {
+        systemPromptTokens,
+        tier1Tokens,
+        tier2Budget,
+        tier3Reserve,
+        responseReserve,
+        totalAvailable,
+    };
+    return {
+        systemPrompt,
+        tier1Messages,
+        tier2Chunks,
+        tier3Summary,
+        allocation,
+        originalTokens,
+        optimizedTokens,
+        savingsPercent: originalTokens > 0
+            ? Math.round((1 - optimizedTokens / originalTokens) * 100)
+            : 0,
+    };
+}
+//# sourceMappingURL=budget.js.map

package/dist/context/canonical.d.ts

@@ -0,0 +1,39 @@
+export interface ContentBlock {
+    type: 'text' | 'image' | 'tool_use' | 'tool_result';
+    text?: string;
+    [key: string]: unknown;
+}
+export interface CanonicalMessage {
+    role: 'system' | 'user' | 'assistant' | 'tool';
+    content: string | ContentBlock[];
+    timestamp?: number;
+    metadata?: {
+        provider?: string;
+        model?: string;
+        tokens?: number;
+        files?: string[];
+        tools?: string[];
+        sessionId?: string;
+    };
+}
+export interface CanonicalRequest {
+    messages: CanonicalMessage[];
+    systemPrompt?: string;
+    model: string;
+    stream: boolean;
+    maxTokens?: number;
+    temperature?: number;
+    tools?: unknown[];
+    rawHeaders: Record<string, string>;
+    providerAuth: string;
+}
+export interface CanonicalResponse {
+    content: string | ContentBlock[];
+    model: string;
+    stopReason?: string;
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+}
+export declare function getTextContent(msg: CanonicalMessage): string;

package/dist/context/canonical.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextContent = getTextContent;
+function getTextContent(msg) {
+    if (typeof msg.content === 'string')
+        return msg.content;
+    return msg.content
+        .filter((b) => b.type === 'text' && b.text)
+        .map((b) => b.text)
+        .join('\n');
+}
+//# sourceMappingURL=canonical.js.map

package/dist/context/chunker.d.ts

@@ -0,0 +1,9 @@
+import type { CanonicalMessage } from './canonical.js';
+import type { Chunk } from '../storage/types.js';
+export declare function estimateTokens(text: string): number;
+/**
+ * Chunk a conversation into indexable units.
+ * Each chunk = one user-assistant exchange pair.
+ * Long responses are split at paragraph boundaries.
+ */
+export declare function chunkConversation(messages: CanonicalMessage[], sessionId: string, baseTimestamp?: number): Chunk[];

package/dist/context/chunker.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateTokens = estimateTokens;
+exports.chunkConversation = chunkConversation;
+const canonical_js_1 = require("./canonical.js");
+const node_crypto_1 = require("node:crypto");
+const AVG_CHARS_PER_TOKEN = 4;
+const MAX_CHUNK_TOKENS = 2000;
+function estimateTokens(text) {
+    return Math.ceil(text.length / AVG_CHARS_PER_TOKEN);
+}
+/** Extract file paths mentioned in text */
+function extractFilePaths(text) {
+    const patterns = [
+        /(?:^|\s)((?:\/[\w.-]+)+(?:\.\w+)?)/gm,
+        /(?:^|\s)((?:[\w.-]+\/)+[\w.-]+(?:\.\w+)?)/gm,
+        /`([^`]*\/[^`]*\.\w+)`/g,
+    ];
+    const files = new Set();
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const p = match[1].trim();
+            if (p.length > 3 && p.includes('/') && !p.startsWith('http')) {
+                files.add(p);
+            }
+        }
+    }
+    return Array.from(files);
+}
+/** Extract tool names from text */
+function extractTools(text) {
+    const tools = new Set();
+    const patterns = [
+        /tool[_\s]?(?:use|call|result)[:\s]+(\w+)/gi,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            tools.add(match[1]);
+        }
+    }
+    return Array.from(tools);
+}
+/**
+ * Chunk a conversation into indexable units.
+ * Each chunk = one user-assistant exchange pair.
+ * Long responses are split at paragraph boundaries.
+ */
+function chunkConversation(messages, sessionId, baseTimestamp) {
+    const chunks = [];
+    let exchangeIndex = 0;
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i];
+        if (msg.role !== 'user')
+            continue;
+        const userText = (0, canonical_js_1.getTextContent)(msg);
+        let assistantText = '';
+        for (let j = i + 1; j < messages.length; j++) {
+            if (messages[j].role === 'assistant') {
+                assistantText = (0, canonical_js_1.getTextContent)(messages[j]);
+                break;
+            }
+        }
+        const fullText = `User: ${userText}\n\nAssistant: ${assistantText}`;
+        const tokens = estimateTokens(fullText);
+        const files = extractFilePaths(fullText);
+        const tools = extractTools(fullText);
+        const summary = userText.slice(0, 100);
+        const timestamp = baseTimestamp ? baseTimestamp + exchangeIndex * 1000 : Date.now();
+        if (tokens <= MAX_CHUNK_TOKENS) {
+            chunks.push({
+                id: (0, node_crypto_1.randomUUID)(),
+                text: fullText,
+                embedding: [],
+                sessionId,
+                timestamp,
+                metadata: { files, tools, summary, tokenCount: tokens, exchangeIndex },
+            });
+        }
+        else {
+            const paragraphs = splitIntoParagraphs(fullText);
+            let current = '';
+            let partIndex = 0;
+            for (const para of paragraphs) {
+                if (estimateTokens(current + para) > MAX_CHUNK_TOKENS && current.length > 0) {
+                    chunks.push({
+                        id: (0, node_crypto_1.randomUUID)(),
+                        text: current.trim(),
+                        embedding: [],
+                        sessionId,
+                        timestamp,
+                        metadata: {
+                            files: extractFilePaths(current),
+                            tools: extractTools(current),
+                            summary: `${summary} (part ${partIndex + 1})`,
+                            tokenCount: estimateTokens(current),
+                            exchangeIndex,
+                        },
+                    });
+                    current = '';
+                    partIndex++;
+                }
+                current += para + '\n\n';
+            }
+            if (current.trim()) {
+                chunks.push({
+                    id: (0, node_crypto_1.randomUUID)(),
+                    text: current.trim(),
+                    embedding: [],
+                    sessionId,
+                    timestamp,
+                    metadata: {
+                        files: extractFilePaths(current),
+                        tools: extractTools(current),
+                        summary: `${summary} (part ${partIndex + 1})`,
+                        tokenCount: estimateTokens(current),
+                        exchangeIndex,
+                    },
+                });
+            }
+        }
+        exchangeIndex++;
+    }
+    return chunks;
+}
+function splitIntoParagraphs(text) {
+    const parts = [];
+    let inCodeBlock = false;
+    let current = '';
+    for (const line of text.split('\n')) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+        }
+        if (!inCodeBlock && line.trim() === '' && current.trim()) {
+            parts.push(current.trim());
+            current = '';
+        }
+        else {
+            current += line + '\n';
+        }
+    }
+    if (current.trim()) {
+        parts.push(current.trim());
+    }
+    return parts;
+}
+//# sourceMappingURL=chunker.js.map

package/dist/context/optimizer.d.ts

@@ -0,0 +1,31 @@
+import type { CanonicalRequest, CanonicalMessage } from './canonical.js';
+import { type RetrievalResult } from './retriever.js';
+import { type PackedContext } from './budget.js';
+import type { EmbeddingAdapter } from '../embedding/types.js';
+import type { StorageAdapter } from '../storage/types.js';
+import type { ContextConfig } from '../config/schema.js';
+export interface OptimizationResult {
+    optimizedMessages: CanonicalMessage[];
+    systemPrompt?: string;
+    packed: PackedContext;
+    retrieval: RetrievalResult | null;
+    passThrough: boolean;
+    reason?: string;
+}
+export declare class ContextOptimizer {
+    private embedding;
+    private storage;
+    private config;
+    private retriever;
+    constructor(embedding: EmbeddingAdapter, storage: StorageAdapter, config: ContextConfig);
+    /**
+     * Optimize context for a request.
+     * Returns pass-through if optimization isn't beneficial.
+     */
+    optimize(request: CanonicalRequest): Promise<OptimizationResult>;
+    /**
+     * Index a completed exchange for future retrieval.
+     * Called asynchronously after response completes.
+     */
+    indexExchange(messages: CanonicalMessage[], sessionId: string): Promise<void>;
+}

package/dist/context/optimizer.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContextOptimizer = void 0;
+const canonical_js_1 = require("./canonical.js");
+const chunker_js_1 = require("./chunker.js");
+const retriever_js_1 = require("./retriever.js");
+const budget_js_1 = require("./budget.js");
+class ContextOptimizer {
+    embedding;
+    storage;
+    config;
+    retriever;
+    constructor(embedding, storage, config) {
+        this.embedding = embedding;
+        this.storage = storage;
+        this.config = config;
+        this.retriever = new retriever_js_1.Retriever(embedding, storage, config);
+    }
+    /**
+     * Optimize context for a request.
+     * Returns pass-through if optimization isn't beneficial.
+     */
+    async optimize(request) {
+        const { messages, systemPrompt, model } = request;
+        // Calculate original size
+        const originalTokens = (0, chunker_js_1.estimateTokens)(systemPrompt || '') +
+            messages.reduce((sum, m) => sum + (0, chunker_js_1.estimateTokens)((0, canonical_js_1.getTextContent)(m)), 0);
+        // Don't optimize short conversations (< tier1 threshold)
+        const exchangeCount = messages.filter((m) => m.role === 'user').length;
+        if (exchangeCount <= this.config.tier1_exchanges) {
+            return {
+                optimizedMessages: messages,
+                systemPrompt,
+                packed: {
+                    systemPrompt,
+                    tier1Messages: messages,
+                    tier2Chunks: [],
+                    allocation: {
+                        systemPromptTokens: (0, chunker_js_1.estimateTokens)(systemPrompt || ''),
+                        tier1Tokens: originalTokens - (0, chunker_js_1.estimateTokens)(systemPrompt || ''),
+                        tier2Budget: 0,
+                        tier3Reserve: 0,
+                        responseReserve: this.config.response_reserve_tokens,
+                        totalAvailable: originalTokens,
+                    },
+                    originalTokens,
+                    optimizedTokens: originalTokens,
+                    savingsPercent: 0,
+                },
+                retrieval: null,
+                passThrough: true,
+                reason: 'conversation too short for optimization',
+            };
+        }
+        // Extract query from last user message
+        const lastUserMsg = [...messages].reverse().find((m) => m.role === 'user');
+        const queryText = lastUserMsg ? (0, canonical_js_1.getTextContent)(lastUserMsg) : '';
+        // Extract mentioned file paths from query
+        const filePathPattern = /(?:[\w.-]+\/)+[\w.-]+(?:\.\w+)?/g;
+        const mentionedFiles = queryText.match(filePathPattern) || [];
+        // Generate session ID from system prompt hash (stable across requests)
+        const sessionId = request.rawHeaders['x-smartcontext-session'] ||
+            `session-${simpleHash(systemPrompt || 'default')}`;
+        // Retrieve relevant chunks
+        let retrieval;
+        try {
+            retrieval = await this.retriever.retrieve(queryText, sessionId, mentionedFiles);
+        }
+        catch (err) {
+            // Graceful degradation: retrieval failed, pass through
+            return {
+                optimizedMessages: messages,
+                systemPrompt,
+                packed: {
+                    systemPrompt,
+                    tier1Messages: messages,
+                    tier2Chunks: [],
+                    allocation: {
+                        systemPromptTokens: (0, chunker_js_1.estimateTokens)(systemPrompt || ''),
+                        tier1Tokens: originalTokens - (0, chunker_js_1.estimateTokens)(systemPrompt || ''),
+                        tier2Budget: 0,
+                        tier3Reserve: 0,
+                        responseReserve: this.config.response_reserve_tokens,
+                        totalAvailable: originalTokens,
+                    },
+                    originalTokens,
+                    optimizedTokens: originalTokens,
+                    savingsPercent: 0,
+                },
+                retrieval: null,
+                passThrough: true,
+                reason: `retrieval failed: ${err}`,
+            };
+        }
+        // Pack context with budget allocation
+        const packed = (0, budget_js_1.packContext)(systemPrompt, messages, retrieval.chunks, model, this.config.tier1_exchanges, this.config.tier3_token_reserve, this.config.response_reserve_tokens);
+        // If savings < 10%, not worth the risk — pass through
+        if (packed.savingsPercent < 10) {
+            return {
+                optimizedMessages: messages,
+                systemPrompt,
+                packed,
+                retrieval,
+                passThrough: true,
+                reason: `savings too low (${packed.savingsPercent}%)`,
+            };
+        }
+        // Assemble optimized messages
+        const optimizedMessages = [];
+        // Add retrieved context as a system-injected context block
+        if (packed.tier2Chunks.length > 0) {
+            const contextBlock = packed.tier2Chunks
+                .map((c) => `[Context from ${new Date(c.timestamp).toISOString().slice(0, 19)}]\n${c.text}`)
+                .join('\n\n---\n\n');
+            optimizedMessages.push({
+                role: 'user',
+                content: `[Retrieved context from previous exchanges]\n\n${contextBlock}`,
+                metadata: { provider: 'smartcontext' },
+            });
+            optimizedMessages.push({
+                role: 'assistant',
+                content: 'I have reviewed the retrieved context from our previous exchanges. I\'ll use this information to provide more informed responses.',
+                metadata: { provider: 'smartcontext' },
+            });
+        }
+        // Add Tier 1 messages (last N exchanges, verbatim)
+        optimizedMessages.push(...packed.tier1Messages);
+        return {
+            optimizedMessages,
+            systemPrompt,
+            packed,
+            retrieval,
+            passThrough: false,
+        };
+    }
+    /**
+     * Index a completed exchange for future retrieval.
+     * Called asynchronously after response completes.
+     */
+    async indexExchange(messages, sessionId) {
+        const chunks = (0, chunker_js_1.chunkConversation)(messages, sessionId);
+        if (chunks.length === 0)
+            return;
+        // Embed all chunks
+        const texts = chunks.map((c) => c.text);
+        const embeddings = await this.embedding.embed(texts);
+        for (let i = 0; i < chunks.length; i++) {
+            chunks[i].embedding = embeddings[i];
+        }
+        await this.storage.upsertChunks(chunks);
+    }
+}
+exports.ContextOptimizer = ContextOptimizer;
+function simpleHash(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = ((hash << 5) - hash) + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(36);
+}
+//# sourceMappingURL=optimizer.js.map

package/dist/context/retriever.d.ts

@@ -0,0 +1,29 @@
+import type { EmbeddingAdapter } from '../embedding/types.js';
+import type { StorageAdapter, ScoredChunk } from '../storage/types.js';
+import type { ContextConfig } from '../config/schema.js';
+export interface RetrievalResult {
+    chunks: ScoredChunk[];
+    queryEmbeddingMs: number;
+    searchMs: number;
+    candidates: number;
+    aboveThreshold: number;
+    afterDedup: number;
+    topScore: number;
+}
+/**
+ * Retrieval pipeline:
+ * 1. Embed query
+ * 2. Vector search (top-K candidates)
+ * 3. Apply boosts (recency, file-path)
+ * 4. Dedup near-duplicates
+ * 5. Confidence gate
+ */
+export declare class Retriever {
+    private embedding;
+    private storage;
+    private config;
+    constructor(embedding: EmbeddingAdapter, storage: StorageAdapter, config: ContextConfig);
+    retrieve(queryText: string, currentSessionId: string, mentionedFiles: string[]): Promise<RetrievalResult>;
+    /** Remove near-duplicate chunks (same content, different IDs) */
+    private dedup;
+}