smartcontext-proxy 0.1.0

package/dist/src/embedding/ollama.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaEmbeddingAdapter = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const node_https_1 = __importDefault(require("node:https"));
+const node_url_1 = require("node:url");
+class OllamaEmbeddingAdapter {
+    url;
+    model;
+    name = 'ollama';
+    dimensions = 768; // nomic-embed-text default
+    constructor(url = 'http://localhost:11434', model = 'nomic-embed-text') {
+        this.url = url;
+        this.model = model;
+    }
+    async initialize() {
+        // Verify Ollama is reachable and model exists
+        try {
+            await this.embed(['test']);
+        }
+        catch (err) {
+            throw new Error(`Ollama embedding unavailable at ${this.url}: ${err}`);
+        }
+    }
+    async embed(texts) {
+        const results = [];
+        for (const text of texts) {
+            const embedding = await this.embedSingle(text);
+            results.push(embedding);
+            if (embedding.length !== this.dimensions) {
+                this.dimensions = embedding.length; // auto-detect dimensions
+            }
+        }
+        return results;
+    }
+    async embedSingle(text) {
+        const parsed = new node_url_1.URL(`${this.url}/api/embed`);
+        const transport = parsed.protocol === 'https:' ? node_https_1.default : node_http_1.default;
+        const body = JSON.stringify({ model: this.model, input: text });
+        return new Promise((resolve, reject) => {
+            const req = transport.request(parsed, { method: 'POST', headers: { 'Content-Type': 'application/json' } }, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.embeddings?.[0]) {
+                            resolve(parsed.embeddings[0]);
+                        }
+                        else if (parsed.embedding) {
+                            resolve(parsed.embedding);
+                        }
+                        else {
+                            reject(new Error(`Unexpected Ollama response: ${data.slice(0, 200)}`));
+                        }
+                    }
+                    catch (e) {
+                        reject(new Error(`Failed to parse Ollama response: ${e}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(body);
+            req.end();
+        });
+    }
+}
+exports.OllamaEmbeddingAdapter = OllamaEmbeddingAdapter;
+//# sourceMappingURL=ollama.js.map

package/dist/src/embedding/types.d.ts

@@ -0,0 +1,6 @@
+export interface EmbeddingAdapter {
+    name: string;
+    dimensions: number;
+    embed(texts: string[]): Promise<number[][]>;
+    initialize(): Promise<void>;
+}

package/dist/src/embedding/types.js

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

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const auto_detect_js_1 = require("./config/auto-detect.js");
+const server_js_1 = require("./proxy/server.js");
+const ollama_js_1 = require("./embedding/ollama.js");
+const lancedb_js_1 = require("./storage/lancedb.js");
+const process_js_1 = require("./daemon/process.js");
+const service_js_1 = require("./daemon/service.js");
+const node_http_1 = __importDefault(require("node:http"));
+const VERSION = '0.1.0';
+function parseArgs(args) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--port' || arg === '-p')
+            result.port = args[++i];
+        else if (arg === '--config' || arg === '-c')
+            result.config = args[++i];
+        else if (arg === '--help' || arg === '-h')
+            result.help = true;
+        else if (arg === '--version' || arg === '-v')
+            result.version = true;
+        else if (arg === '--no-optimize')
+            result.noOptimize = true;
+        else if (arg === '--embedding-url')
+            result.embeddingUrl = args[++i];
+        else if (arg === '--embedding-model')
+            result.embeddingModel = args[++i];
+        else if (arg === '--data-dir')
+            result.dataDir = args[++i];
+        else if (!arg.startsWith('-'))
+            result.command = arg;
+    }
+    return result;
+}
+function printHelp() {
+    console.log(`
+SmartContext Proxy v${VERSION}
+Intelligent context window optimization for LLM APIs
+
+Usage:
+  smartcontext-proxy [options]
+  smartcontext-proxy status          Show proxy status
+
+Options:
+  --port, -p <port>           Proxy port (default: 4800)
+  --config, -c <file>         Config file path
+  --no-optimize               Run in transparent proxy mode (no context optimization)
+  --embedding-url <url>       Ollama URL for embeddings (default: http://localhost:11434)
+  --embedding-model <model>   Embedding model (default: nomic-embed-text)
+  --data-dir <path>           Data directory (default: ~/.smartcontext/data)
+  --help, -h                  Show help
+  --version, -v               Show version
+
+Client Integration:
+  ANTHROPIC_API_URL=http://localhost:4800/v1/anthropic
+  OPENAI_BASE_URL=http://localhost:4800/v1/openai
+  OLLAMA_HOST=http://localhost:4800/v1/ollama
+
+API:
+  GET  /health          Health check
+  GET  /_sc/status      Proxy status
+  GET  /_sc/stats       Aggregate metrics
+  GET  /_sc/feed        Recent requests
+  POST /_sc/pause       Pause optimization
+  POST /_sc/resume      Resume optimization
+`);
+}
+async function showStatus(port) {
+    return new Promise((resolve) => {
+        node_http_1.default.get(`http://127.0.0.1:${port}/_sc/status`, (res) => {
+            let data = '';
+            res.on('data', (chunk) => (data += chunk));
+            res.on('end', () => {
+                try {
+                    const status = JSON.parse(data);
+                    console.log(`SmartContext Proxy: ${status.state}`);
+                    console.log(`  Uptime: ${Math.round(status.uptime / 1000)}s`);
+                    console.log(`  Requests: ${status.requests}`);
+                    console.log(`  Mode: ${status.mode}`);
+                }
+                catch {
+                    console.log('Could not parse status response');
+                }
+                resolve();
+            });
+        }).on('error', () => {
+            console.log(`SmartContext Proxy: not running on port ${port}`);
+            resolve();
+        });
+    });
+}
+async function main() {
+    const args = parseArgs(process.argv.slice(2));
+    if (args.version) {
+        console.log(VERSION);
+        return;
+    }
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    const port = args.port ? parseInt(args.port, 10) : 4800;
+    if (args.command === 'status') {
+        await showStatus(port);
+        return;
+    }
+    if (args.command === 'stop') {
+        (0, process_js_1.stopDaemon)();
+        return;
+    }
+    if (args.command === 'start') {
+        (0, process_js_1.startDaemon)(process.argv.slice(3));
+        return;
+    }
+    if (args.command === 'restart') {
+        (0, process_js_1.stopDaemon)();
+        await new Promise(r => setTimeout(r, 1000));
+        (0, process_js_1.startDaemon)(process.argv.slice(3));
+        return;
+    }
+    if (args.command === 'install-service') {
+        const path = (0, service_js_1.installService)(port);
+        console.log(`Service installed: ${path}`);
+        return;
+    }
+    if (args.command === 'uninstall-service') {
+        console.log((0, service_js_1.uninstallService)());
+        return;
+    }
+    const config = (0, auto_detect_js_1.buildConfig)({
+        proxy: { port, host: '127.0.0.1' },
+    });
+    // Initialize embedding and storage (unless --no-optimize)
+    let embedding;
+    let storage;
+    if (!args.noOptimize) {
+        try {
+            const embeddingUrl = args.embeddingUrl || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+            const embeddingModel = args.embeddingModel || 'nomic-embed-text';
+            const dataDir = args.dataDir;
+            embedding = new ollama_js_1.OllamaEmbeddingAdapter(embeddingUrl, embeddingModel);
+            await embedding.initialize();
+            storage = new lancedb_js_1.LanceDBAdapter(dataDir);
+            await storage.initialize();
+            console.log(`  Embedding: ${embeddingModel} @ ${embeddingUrl}`);
+            console.log(`  Storage: LanceDB`);
+        }
+        catch (err) {
+            console.log(`  Optimization unavailable: ${err}`);
+            console.log(`  Running in transparent proxy mode`);
+            embedding = undefined;
+            storage = undefined;
+        }
+    }
+    const server = new server_js_1.ProxyServer(config, embedding, storage);
+    const providers = server.getProviderNames();
+    const mode = embedding && storage ? 'optimizing' : 'transparent';
+    await server.start();
+    console.log(`
+  ┌─────────────────────────────────────────────┐
+  │  SmartContext Proxy v${VERSION}                  │
+  │  http://${config.proxy.host}:${config.proxy.port}                    │
+  │                                             │
+  │  Providers: ${providers.join(', ').padEnd(31)}│
+  │  Mode: ${mode.padEnd(36)}│
+  └─────────────────────────────────────────────┘
+`);
+    // Write PID file
+    (0, process_js_1.writePid)();
+    const shutdown = async () => {
+        console.log('\nShutting down...');
+        (0, process_js_1.removePid)();
+        await server.stop();
+        if (storage)
+            await storage.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+main().catch((err) => {
+    console.error('Fatal:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=index.js.map

package/dist/src/metrics/collector.d.ts

@@ -0,0 +1,43 @@
+export interface RequestMetric {
+    id: number;
+    timestamp: number;
+    provider: string;
+    model: string;
+    streaming: boolean;
+    originalTokens: number;
+    optimizedTokens: number;
+    savingsPercent: number;
+    latencyOverheadMs: number;
+    chunksRetrieved: number;
+    topScore: number;
+    passThrough: boolean;
+    reason?: string;
+}
+export interface AggregateStats {
+    totalRequests: number;
+    totalOriginalTokens: number;
+    totalOptimizedTokens: number;
+    totalSavingsPercent: number;
+    avgLatencyOverheadMs: number;
+    avgChunksRetrieved: number;
+    byProvider: Record<string, ProviderStats>;
+    byModel: Record<string, ModelStats>;
+}
+export interface ProviderStats {
+    requests: number;
+    tokensSaved: number;
+    savingsPercent: number;
+}
+export interface ModelStats {
+    requests: number;
+    tokensSaved: number;
+    savingsPercent: number;
+}
+export declare class MetricsCollector {
+    private metrics;
+    private startTime;
+    record(metric: RequestMetric): void;
+    getRecent(limit?: number): RequestMetric[];
+    getStats(): AggregateStats;
+    getUptime(): number;
+}

package/dist/src/metrics/collector.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetricsCollector = void 0;
+class MetricsCollector {
+    metrics = [];
+    startTime = Date.now();
+    record(metric) {
+        this.metrics.push(metric);
+    }
+    getRecent(limit = 50) {
+        return this.metrics.slice(-limit);
+    }
+    getStats() {
+        const total = this.metrics.length;
+        if (total === 0) {
+            return {
+                totalRequests: 0,
+                totalOriginalTokens: 0,
+                totalOptimizedTokens: 0,
+                totalSavingsPercent: 0,
+                avgLatencyOverheadMs: 0,
+                avgChunksRetrieved: 0,
+                byProvider: {},
+                byModel: {},
+            };
+        }
+        let totalOriginal = 0;
+        let totalOptimized = 0;
+        let totalLatency = 0;
+        let totalChunks = 0;
+        const byProvider = {};
+        const byModel = {};
+        for (const m of this.metrics) {
+            totalOriginal += m.originalTokens;
+            totalOptimized += m.optimizedTokens;
+            totalLatency += m.latencyOverheadMs;
+            totalChunks += m.chunksRetrieved;
+            // By provider
+            if (!byProvider[m.provider])
+                byProvider[m.provider] = { requests: 0, tokensSaved: 0, savingsPercent: 0 };
+            byProvider[m.provider].requests++;
+            byProvider[m.provider].tokensSaved += m.originalTokens - m.optimizedTokens;
+            // By model
+            if (!byModel[m.model])
+                byModel[m.model] = { requests: 0, tokensSaved: 0, savingsPercent: 0 };
+            byModel[m.model].requests++;
+            byModel[m.model].tokensSaved += m.originalTokens - m.optimizedTokens;
+        }
+        // Calculate percentages
+        for (const stats of Object.values(byProvider)) {
+            stats.savingsPercent = totalOriginal > 0 ? Math.round((stats.tokensSaved / totalOriginal) * 100) : 0;
+        }
+        for (const stats of Object.values(byModel)) {
+            stats.savingsPercent = totalOriginal > 0 ? Math.round((stats.tokensSaved / totalOriginal) * 100) : 0;
+        }
+        return {
+            totalRequests: total,
+            totalOriginalTokens: totalOriginal,
+            totalOptimizedTokens: totalOptimized,
+            totalSavingsPercent: totalOriginal > 0 ? Math.round((1 - totalOptimized / totalOriginal) * 100) : 0,
+            avgLatencyOverheadMs: Math.round(totalLatency / total),
+            avgChunksRetrieved: Math.round(totalChunks / total * 10) / 10,
+            byProvider,
+            byModel,
+        };
+    }
+    getUptime() {
+        return Date.now() - this.startTime;
+    }
+}
+exports.MetricsCollector = MetricsCollector;
+//# sourceMappingURL=collector.js.map

package/dist/src/providers/anthropic.d.ts

@@ -0,0 +1,15 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class AnthropicAdapter implements ProviderAdapter {
+    baseUrl: string;
+    name: string;
+    constructor(baseUrl?: string);
+    parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest;
+    serializeRequest(canonical: CanonicalRequest): unknown;
+    forwardUrl(originalPath: string): string;
+    extractApiKey(headers: Record<string, string>): string;
+    contentType(): string;
+    authHeaders(apiKey: string): Record<string, string>;
+    private parseMessage;
+    private serializeMessage;
+}

package/dist/src/providers/anthropic.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnthropicAdapter = void 0;
+class AnthropicAdapter {
+    baseUrl;
+    name = 'anthropic';
+    constructor(baseUrl = 'https://api.anthropic.com') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        const b = body;
+        const messages = [];
+        let systemPrompt;
+        // Extract system prompt
+        if (typeof b.system === 'string') {
+            systemPrompt = b.system;
+        }
+        else if (Array.isArray(b.system)) {
+            systemPrompt = b.system
+                .map((s) => s.text || '')
+                .join('\n');
+        }
+        // Convert messages
+        if (Array.isArray(b.messages)) {
+            for (const msg of b.messages) {
+                messages.push(this.parseMessage(msg));
+            }
+        }
+        return {
+            messages,
+            systemPrompt,
+            model: b.model || 'unknown',
+            stream: !!b.stream,
+            maxTokens: b.max_tokens,
+            temperature: b.temperature,
+            tools: b.tools,
+            rawHeaders: headers,
+            providerAuth: this.extractApiKey(headers),
+        };
+    }
+    serializeRequest(canonical) {
+        const body = {
+            model: canonical.model,
+            messages: canonical.messages.map((m) => this.serializeMessage(m)),
+            stream: canonical.stream,
+        };
+        if (canonical.systemPrompt) {
+            body.system = canonical.systemPrompt;
+        }
+        if (canonical.maxTokens) {
+            body.max_tokens = canonical.maxTokens;
+        }
+        if (canonical.temperature !== undefined) {
+            body.temperature = canonical.temperature;
+        }
+        if (canonical.tools) {
+            body.tools = canonical.tools;
+        }
+        return body;
+    }
+    forwardUrl(originalPath) {
+        // /v1/anthropic/v1/messages → https://api.anthropic.com/v1/messages
+        const stripped = originalPath.replace(/^\/v1\/anthropic/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['x-api-key'] || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        return {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+        };
+    }
+    parseMessage(msg) {
+        const role = msg.role;
+        let content;
+        if (typeof msg.content === 'string') {
+            content = msg.content;
+        }
+        else if (Array.isArray(msg.content)) {
+            content = msg.content.map((block) => {
+                if (block.type === 'text') {
+                    return { type: 'text', text: block.text };
+                }
+                // Pass through tool_use, tool_result, image blocks as-is
+                return { ...block, type: block.type };
+            });
+        }
+        else {
+            content = '';
+        }
+        return {
+            role: role,
+            content,
+        };
+    }
+    serializeMessage(msg) {
+        return {
+            role: msg.role,
+            content: msg.content,
+        };
+    }
+}
+exports.AnthropicAdapter = AnthropicAdapter;
+//# sourceMappingURL=anthropic.js.map

package/dist/src/providers/google.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class GoogleAdapter implements ProviderAdapter {
+    baseUrl: string;
+    name: string;
+    constructor(baseUrl?: string);
+    parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest;
+    serializeRequest(canonical: CanonicalRequest): unknown;
+    forwardUrl(originalPath: string): string;
+    extractApiKey(headers: Record<string, string>): string;
+    contentType(): string;
+    authHeaders(apiKey: string): Record<string, string>;
+}

package/dist/src/providers/google.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAdapter = void 0;
+class GoogleAdapter {
+    baseUrl;
+    name = 'google';
+    constructor(baseUrl = 'https://generativelanguage.googleapis.com') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        // Stub: pass through as-is for Phase 1
+        const b = body;
+        return {
+            messages: [],
+            model: 'unknown',
+            stream: !!b.stream,
+            rawHeaders: headers,
+            providerAuth: this.extractApiKey(headers),
+        };
+    }
+    serializeRequest(canonical) {
+        // Stub: not implemented for Phase 1
+        return {};
+    }
+    forwardUrl(originalPath) {
+        const stripped = originalPath.replace(/^\/v1\/google/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['x-goog-api-key'] || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        return { 'x-goog-api-key': apiKey };
+    }
+}
+exports.GoogleAdapter = GoogleAdapter;
+//# sourceMappingURL=google.js.map

package/dist/src/providers/ollama.d.ts

@@ -0,0 +1,13 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalRequest } from '../context/canonical.js';
+export declare class OllamaAdapter implements ProviderAdapter {
+    baseUrl: string;
+    name: string;
+    constructor(baseUrl?: string);
+    parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest;
+    serializeRequest(canonical: CanonicalRequest): unknown;
+    forwardUrl(originalPath: string): string;
+    extractApiKey(headers: Record<string, string>): string;
+    contentType(): string;
+    authHeaders(apiKey: string): Record<string, string>;
+}

package/dist/src/providers/ollama.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OllamaAdapter = void 0;
+class OllamaAdapter {
+    baseUrl;
+    name = 'ollama';
+    constructor(baseUrl = 'http://localhost:11434') {
+        this.baseUrl = baseUrl;
+    }
+    parseRequest(body, headers) {
+        const b = body;
+        const messages = [];
+        let systemPrompt;
+        if (Array.isArray(b.messages)) {
+            for (const msg of b.messages) {
+                if (msg.role === 'system') {
+                    systemPrompt = msg.content;
+                    continue;
+                }
+                messages.push({
+                    role: msg.role,
+                    content: msg.content || '',
+                });
+            }
+        }
+        return {
+            messages,
+            systemPrompt,
+            model: b.model || 'unknown',
+            stream: b.stream !== false, // Ollama streams by default
+            maxTokens: b.options ? b.options.num_predict : undefined,
+            temperature: b.options ? b.options.temperature : undefined,
+            rawHeaders: headers,
+            providerAuth: '',
+        };
+    }
+    serializeRequest(canonical) {
+        const messages = [];
+        if (canonical.systemPrompt) {
+            messages.push({ role: 'system', content: canonical.systemPrompt });
+        }
+        for (const msg of canonical.messages) {
+            messages.push({
+                role: msg.role,
+                content: typeof msg.content === 'string'
+                    ? msg.content
+                    : msg.content.filter((b) => b.type === 'text').map((b) => b.text || '').join('\n'),
+            });
+        }
+        const body = {
+            model: canonical.model,
+            messages,
+            stream: canonical.stream,
+        };
+        const options = {};
+        if (canonical.maxTokens)
+            options.num_predict = canonical.maxTokens;
+        if (canonical.temperature !== undefined)
+            options.temperature = canonical.temperature;
+        if (Object.keys(options).length > 0)
+            body.options = options;
+        return body;
+    }
+    forwardUrl(originalPath) {
+        // /v1/ollama/api/chat → http://localhost:11434/api/chat
+        const stripped = originalPath.replace(/^\/v1\/ollama/, '');
+        return `${this.baseUrl}${stripped}`;
+    }
+    extractApiKey(headers) {
+        return headers['authorization']?.replace(/^Bearer\s+/i, '') || '';
+    }
+    contentType() {
+        return 'application/json';
+    }
+    authHeaders(apiKey) {
+        if (!apiKey)
+            return {};
+        return { 'Authorization': `Bearer ${apiKey}` };
+    }
+}
+exports.OllamaAdapter = OllamaAdapter;
+//# sourceMappingURL=ollama.js.map