smartcontext-proxy 0.1.0

package/src/embedding/ollama.ts

@@ -0,0 +1,68 @@
+import type { EmbeddingAdapter } from './types.js';
+import http from 'node:http';
+import https from 'node:https';
+import { URL } from 'node:url';
+
+export class OllamaEmbeddingAdapter implements EmbeddingAdapter {
+  name = 'ollama';
+  dimensions = 768; // nomic-embed-text default
+
+  constructor(
+    private url: string = 'http://localhost:11434',
+    private model: string = 'nomic-embed-text',
+  ) {}
+
+  async initialize(): Promise<void> {
+    // 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: string[]): Promise<number[][]> {
+    const results: number[][] = [];
+
+    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;
+  }
+
+  private async embedSingle(text: string): Promise<number[]> {
+    const parsed = new URL(`${this.url}/api/embed`);
+    const transport = parsed.protocol === 'https:' ? https : http;
+
+    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();
+    });
+  }
+}

package/src/embedding/types.ts

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

package/src/index.ts

@@ -0,0 +1,176 @@
+#!/usr/bin/env node
+
+import { buildConfig } from './config/auto-detect.js';
+import { ProxyServer } from './proxy/server.js';
+import { OllamaEmbeddingAdapter } from './embedding/ollama.js';
+import { LanceDBAdapter } from './storage/lancedb.js';
+import type { EmbeddingAdapter } from './embedding/types.js';
+import type { StorageAdapter } from './storage/types.js';
+import { writePid, removePid, getPid, stopDaemon, startDaemon, isDaemonChild } from './daemon/process.js';
+import { installService, uninstallService } from './daemon/service.js';
+import http from 'node:http';
+
+const VERSION = '0.1.0';
+
+function parseArgs(args: string[]): Record<string, string | boolean> {
+  const result: Record<string, string | boolean> = {};
+  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(): void {
+  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: number): Promise<void> {
+  return new Promise((resolve) => {
+    http.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(): Promise<void> {
+  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 as string, 10) : 4800;
+
+  if (args.command === 'status') { await showStatus(port); return; }
+  if (args.command === 'stop') { stopDaemon(); return; }
+  if (args.command === 'start') { startDaemon(process.argv.slice(3)); return; }
+  if (args.command === 'restart') { stopDaemon(); await new Promise(r => setTimeout(r, 1000)); startDaemon(process.argv.slice(3)); return; }
+  if (args.command === 'install-service') {
+    const path = installService(port);
+    console.log(`Service installed: ${path}`);
+    return;
+  }
+  if (args.command === 'uninstall-service') {
+    console.log(uninstallService());
+    return;
+  }
+
+  const config = buildConfig({
+    proxy: { port, host: '127.0.0.1' },
+  });
+
+  // Initialize embedding and storage (unless --no-optimize)
+  let embedding: EmbeddingAdapter | undefined;
+  let storage: StorageAdapter | undefined;
+
+  if (!args.noOptimize) {
+    try {
+      const embeddingUrl = (args.embeddingUrl as string) || process.env['OLLAMA_HOST'] || 'http://localhost:11434';
+      const embeddingModel = (args.embeddingModel as string) || 'nomic-embed-text';
+      const dataDir = args.dataDir as string | undefined;
+
+      embedding = new OllamaEmbeddingAdapter(embeddingUrl, embeddingModel);
+      await embedding.initialize();
+
+      storage = new 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 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
+  writePid();
+
+  const shutdown = async () => {
+    console.log('\nShutting down...');
+    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);
+});

package/src/metrics/collector.ts

@@ -0,0 +1,114 @@
+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 class MetricsCollector {
+  private metrics: RequestMetric[] = [];
+  private startTime = Date.now();
+
+  record(metric: RequestMetric): void {
+    this.metrics.push(metric);
+  }
+
+  getRecent(limit: number = 50): RequestMetric[] {
+    return this.metrics.slice(-limit);
+  }
+
+  getStats(): AggregateStats {
+    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: Record<string, ProviderStats> = {};
+    const byModel: Record<string, ModelStats> = {};
+
+    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(): number {
+    return Date.now() - this.startTime;
+  }
+}

package/src/providers/anthropic.ts

@@ -0,0 +1,117 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalMessage, CanonicalRequest, ContentBlock } from '../context/canonical.js';
+
+export class AnthropicAdapter implements ProviderAdapter {
+  name = 'anthropic';
+
+  constructor(public baseUrl: string = 'https://api.anthropic.com') {}
+
+  parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest {
+    const b = body as Record<string, unknown>;
+    const messages: CanonicalMessage[] = [];
+    let systemPrompt: string | undefined;
+
+    // Extract system prompt
+    if (typeof b.system === 'string') {
+      systemPrompt = b.system;
+    } else if (Array.isArray(b.system)) {
+      systemPrompt = (b.system as Array<{ text?: string }>)
+        .map((s) => s.text || '')
+        .join('\n');
+    }
+
+    // Convert messages
+    if (Array.isArray(b.messages)) {
+      for (const msg of b.messages as Array<Record<string, unknown>>) {
+        messages.push(this.parseMessage(msg));
+      }
+    }
+
+    return {
+      messages,
+      systemPrompt,
+      model: (b.model as string) || 'unknown',
+      stream: !!b.stream,
+      maxTokens: b.max_tokens as number | undefined,
+      temperature: b.temperature as number | undefined,
+      tools: b.tools as unknown[] | undefined,
+      rawHeaders: headers,
+      providerAuth: this.extractApiKey(headers),
+    };
+  }
+
+  serializeRequest(canonical: CanonicalRequest): unknown {
+    const body: Record<string, unknown> = {
+      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: string): string {
+    // /v1/anthropic/v1/messages → https://api.anthropic.com/v1/messages
+    const stripped = originalPath.replace(/^\/v1\/anthropic/, '');
+    return `${this.baseUrl}${stripped}`;
+  }
+
+  extractApiKey(headers: Record<string, string>): string {
+    return headers['x-api-key'] || '';
+  }
+
+  contentType(): string {
+    return 'application/json';
+  }
+
+  authHeaders(apiKey: string): Record<string, string> {
+    return {
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    };
+  }
+
+  private parseMessage(msg: Record<string, unknown>): CanonicalMessage {
+    const role = msg.role as string;
+    let content: string | ContentBlock[];
+
+    if (typeof msg.content === 'string') {
+      content = msg.content;
+    } else if (Array.isArray(msg.content)) {
+      content = (msg.content as Array<Record<string, unknown>>).map((block) => {
+        if (block.type === 'text') {
+          return { type: 'text' as const, text: block.text as string };
+        }
+        // Pass through tool_use, tool_result, image blocks as-is
+        return { ...block, type: block.type as ContentBlock['type'] };
+      });
+    } else {
+      content = '';
+    }
+
+    return {
+      role: role as CanonicalMessage['role'],
+      content,
+    };
+  }
+
+  private serializeMessage(msg: CanonicalMessage): Record<string, unknown> {
+    return {
+      role: msg.role,
+      content: msg.content,
+    };
+  }
+}

package/src/providers/google.ts

@@ -0,0 +1,42 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalMessage, CanonicalRequest } from '../context/canonical.js';
+
+export class GoogleAdapter implements ProviderAdapter {
+  name = 'google';
+
+  constructor(public baseUrl: string = 'https://generativelanguage.googleapis.com') {}
+
+  parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest {
+    // Stub: pass through as-is for Phase 1
+    const b = body as Record<string, unknown>;
+    return {
+      messages: [],
+      model: 'unknown',
+      stream: !!b.stream,
+      rawHeaders: headers,
+      providerAuth: this.extractApiKey(headers),
+    };
+  }
+
+  serializeRequest(canonical: CanonicalRequest): unknown {
+    // Stub: not implemented for Phase 1
+    return {};
+  }
+
+  forwardUrl(originalPath: string): string {
+    const stripped = originalPath.replace(/^\/v1\/google/, '');
+    return `${this.baseUrl}${stripped}`;
+  }
+
+  extractApiKey(headers: Record<string, string>): string {
+    return headers['x-goog-api-key'] || '';
+  }
+
+  contentType(): string {
+    return 'application/json';
+  }
+
+  authHeaders(apiKey: string): Record<string, string> {
+    return { 'x-goog-api-key': apiKey };
+  }
+}

package/src/providers/ollama.ts

@@ -0,0 +1,87 @@
+import type { ProviderAdapter } from './types.js';
+import type { CanonicalMessage, CanonicalRequest, ContentBlock } from '../context/canonical.js';
+
+export class OllamaAdapter implements ProviderAdapter {
+  name = 'ollama';
+
+  constructor(public baseUrl: string = 'http://localhost:11434') {}
+
+  parseRequest(body: unknown, headers: Record<string, string>): CanonicalRequest {
+    const b = body as Record<string, unknown>;
+    const messages: CanonicalMessage[] = [];
+    let systemPrompt: string | undefined;
+
+    if (Array.isArray(b.messages)) {
+      for (const msg of b.messages as Array<Record<string, unknown>>) {
+        if (msg.role === 'system') {
+          systemPrompt = msg.content as string;
+          continue;
+        }
+        messages.push({
+          role: msg.role as CanonicalMessage['role'],
+          content: (msg.content as string) || '',
+        });
+      }
+    }
+
+    return {
+      messages,
+      systemPrompt,
+      model: (b.model as string) || 'unknown',
+      stream: b.stream !== false, // Ollama streams by default
+      maxTokens: b.options ? (b.options as Record<string, unknown>).num_predict as number | undefined : undefined,
+      temperature: b.options ? (b.options as Record<string, unknown>).temperature as number | undefined : undefined,
+      rawHeaders: headers,
+      providerAuth: '',
+    };
+  }
+
+  serializeRequest(canonical: CanonicalRequest): unknown {
+    const messages: Array<Record<string, string>> = [];
+
+    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 as ContentBlock[]).filter((b) => b.type === 'text').map((b) => b.text || '').join('\n'),
+      });
+    }
+
+    const body: Record<string, unknown> = {
+      model: canonical.model,
+      messages,
+      stream: canonical.stream,
+    };
+
+    const options: Record<string, unknown> = {};
+    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: string): string {
+    // /v1/ollama/api/chat → http://localhost:11434/api/chat
+    const stripped = originalPath.replace(/^\/v1\/ollama/, '');
+    return `${this.baseUrl}${stripped}`;
+  }
+
+  extractApiKey(headers: Record<string, string>): string {
+    return headers['authorization']?.replace(/^Bearer\s+/i, '') || '';
+  }
+
+  contentType(): string {
+    return 'application/json';
+  }
+
+  authHeaders(apiKey: string): Record<string, string> {
+    if (!apiKey) return {};
+    return { 'Authorization': `Bearer ${apiKey}` };
+  }
+}