smartcontext-proxy 0.1.0

package/dist/context/retriever.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Retriever = void 0;
+/**
+ * Retrieval pipeline:
+ * 1. Embed query
+ * 2. Vector search (top-K candidates)
+ * 3. Apply boosts (recency, file-path)
+ * 4. Dedup near-duplicates
+ * 5. Confidence gate
+ */
+class Retriever {
+    embedding;
+    storage;
+    config;
+    constructor(embedding, storage, config) {
+        this.embedding = embedding;
+        this.storage = storage;
+        this.config = config;
+    }
+    async retrieve(queryText, currentSessionId, mentionedFiles) {
+        // 1. Embed query
+        const embedStart = Date.now();
+        const [queryEmbedding] = await this.embedding.embed([queryText]);
+        const queryEmbeddingMs = Date.now() - embedStart;
+        // 2. Vector search with boosts
+        const searchStart = Date.now();
+        const candidates = await this.storage.search(queryEmbedding, {
+            topK: this.config.tier2_max_chunks * 2,
+            minScore: this.config.tier2_min_score * 0.8, // Lower threshold, filter later
+            sessionBoost: {
+                sessionId: currentSessionId,
+                boost: this.config.recency_boost,
+            },
+            fileBoost: mentionedFiles.length > 0
+                ? { patterns: mentionedFiles, boost: this.config.filepath_boost }
+                : undefined,
+        });
+        const searchMs = Date.now() - searchStart;
+        // 3. Confidence gate — if best score too low, skip retrieval
+        if (candidates.length === 0 || candidates[0].score < this.config.confidence_gate) {
+            return {
+                chunks: [],
+                queryEmbeddingMs,
+                searchMs,
+                candidates: candidates.length,
+                aboveThreshold: 0,
+                afterDedup: 0,
+                topScore: candidates[0]?.score || 0,
+            };
+        }
+        // 4. Filter by threshold
+        const aboveThreshold = candidates.filter((c) => c.score >= this.config.tier2_min_score);
+        // 5. Dedup near-duplicates (by text similarity)
+        const deduped = this.dedup(aboveThreshold);
+        // 6. Ensure minimum chunks
+        const result = deduped.slice(0, this.config.tier2_max_chunks);
+        const minChunks = Math.min(3, aboveThreshold.length);
+        while (result.length < minChunks && aboveThreshold.length > result.length) {
+            const next = aboveThreshold[result.length];
+            if (!result.some((r) => r.id === next.id)) {
+                result.push(next);
+            }
+        }
+        return {
+            chunks: result,
+            queryEmbeddingMs,
+            searchMs,
+            candidates: candidates.length,
+            aboveThreshold: aboveThreshold.length,
+            afterDedup: deduped.length,
+            topScore: result[0]?.score || 0,
+        };
+    }
+    /** Remove near-duplicate chunks (same content, different IDs) */
+    dedup(chunks) {
+        const kept = [];
+        for (const chunk of chunks) {
+            const isDup = kept.some((k) => {
+                // Simple text similarity check
+                const shorter = Math.min(k.text.length, chunk.text.length);
+                const longer = Math.max(k.text.length, chunk.text.length);
+                if (shorter / longer < 0.8)
+                    return false;
+                // Compare first 200 chars
+                const a = k.text.slice(0, 200).toLowerCase();
+                const b = chunk.text.slice(0, 200).toLowerCase();
+                let matches = 0;
+                for (let i = 0; i < Math.min(a.length, b.length); i++) {
+                    if (a[i] === b[i])
+                        matches++;
+                }
+                return matches / Math.max(a.length, b.length) > this.config.dedup_threshold;
+            });
+            if (!isDup) {
+                kept.push(chunk);
+            }
+        }
+        return kept;
+    }
+}
+exports.Retriever = Retriever;
+//# sourceMappingURL=retriever.js.map

package/dist/daemon/process.d.ts

@@ -0,0 +1,6 @@
+export declare function getPid(): number | null;
+export declare function writePid(): void;
+export declare function removePid(): void;
+export declare function startDaemon(args: string[]): number;
+export declare function stopDaemon(): boolean;
+export declare function isDaemonChild(): boolean;

package/dist/daemon/process.js

@@ -0,0 +1,76 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPid = getPid;
+exports.writePid = writePid;
+exports.removePid = removePid;
+exports.startDaemon = startDaemon;
+exports.stopDaemon = stopDaemon;
+exports.isDaemonChild = isDaemonChild;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const PID_FILE = node_path_1.default.join(process.env['HOME'] || '.', '.smartcontext', 'smartcontext.pid');
+const LOG_FILE = node_path_1.default.join(process.env['HOME'] || '.', '.smartcontext', 'logs', 'proxy.log');
+function getPid() {
+    try {
+        const pid = parseInt(node_fs_1.default.readFileSync(PID_FILE, 'utf-8').trim(), 10);
+        // Check if process is alive
+        process.kill(pid, 0);
+        return pid;
+    }
+    catch {
+        // Clean up stale PID file
+        try {
+            node_fs_1.default.unlinkSync(PID_FILE);
+        }
+        catch { }
+        return null;
+    }
+}
+function writePid() {
+    const dir = node_path_1.default.dirname(PID_FILE);
+    node_fs_1.default.mkdirSync(dir, { recursive: true });
+    node_fs_1.default.writeFileSync(PID_FILE, String(process.pid));
+}
+function removePid() {
+    try {
+        node_fs_1.default.unlinkSync(PID_FILE);
+    }
+    catch { }
+}
+function startDaemon(args) {
+    const existingPid = getPid();
+    if (existingPid) {
+        console.log(`Already running (PID ${existingPid})`);
+        return existingPid;
+    }
+    const logDir = node_path_1.default.dirname(LOG_FILE);
+    node_fs_1.default.mkdirSync(logDir, { recursive: true });
+    const out = node_fs_1.default.openSync(LOG_FILE, 'a');
+    const err = node_fs_1.default.openSync(LOG_FILE, 'a');
+    const child = (0, node_child_process_1.spawn)(process.execPath, [__filename, ...args, '--daemon-child'], {
+        detached: true,
+        stdio: ['ignore', out, err],
+    });
+    child.unref();
+    console.log(`Started (PID ${child.pid})`);
+    return child.pid;
+}
+function stopDaemon() {
+    const pid = getPid();
+    if (!pid) {
+        console.log('Not running');
+        return false;
+    }
+    process.kill(pid, 'SIGTERM');
+    removePid();
+    console.log(`Stopped (PID ${pid})`);
+    return true;
+}
+function isDaemonChild() {
+    return process.argv.includes('--daemon-child');
+}
+//# sourceMappingURL=process.js.map

package/dist/daemon/service.d.ts

@@ -0,0 +1,2 @@
+export declare function installService(port: number): string;
+export declare function uninstallService(): string;

package/dist/daemon/service.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installService = installService;
+exports.uninstallService = uninstallService;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+function installService(port) {
+    if (process.platform === 'darwin') {
+        return installLaunchAgent(port);
+    }
+    return installSystemd(port);
+}
+function uninstallService() {
+    if (process.platform === 'darwin') {
+        return uninstallLaunchAgent();
+    }
+    return uninstallSystemd();
+}
+function installLaunchAgent(port) {
+    const plistDir = node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'LaunchAgents');
+    const plistPath = node_path_1.default.join(plistDir, 'com.smartcontext.proxy.plist');
+    const logDir = node_path_1.default.join(node_os_1.default.homedir(), '.smartcontext', 'logs');
+    node_fs_1.default.mkdirSync(plistDir, { recursive: true });
+    node_fs_1.default.mkdirSync(logDir, { recursive: true });
+    const nodePath = process.execPath;
+    const scriptPath = node_path_1.default.resolve(node_path_1.default.join(__dirname, '..', 'index.js'));
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>com.smartcontext.proxy</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${scriptPath}</string>
+    <string>--port</string>
+    <string>${port}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logDir}/proxy.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logDir}/proxy.err.log</string>
+</dict>
+</plist>`;
+    node_fs_1.default.writeFileSync(plistPath, plist);
+    return plistPath;
+}
+function uninstallLaunchAgent() {
+    const plistPath = node_path_1.default.join(node_os_1.default.homedir(), 'Library', 'LaunchAgents', 'com.smartcontext.proxy.plist');
+    try {
+        node_fs_1.default.unlinkSync(plistPath);
+        return `Removed ${plistPath}`;
+    }
+    catch {
+        return 'No service file found';
+    }
+}
+function installSystemd(port) {
+    const serviceDir = node_path_1.default.join(node_os_1.default.homedir(), '.config', 'systemd', 'user');
+    const servicePath = node_path_1.default.join(serviceDir, 'smartcontext-proxy.service');
+    node_fs_1.default.mkdirSync(serviceDir, { recursive: true });
+    const nodePath = process.execPath;
+    const scriptPath = node_path_1.default.resolve(node_path_1.default.join(__dirname, '..', 'index.js'));
+    const service = `[Unit]
+Description=SmartContext Proxy
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${nodePath} ${scriptPath} --port ${port}
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+    node_fs_1.default.writeFileSync(servicePath, service);
+    return servicePath;
+}
+function uninstallSystemd() {
+    const servicePath = node_path_1.default.join(node_os_1.default.homedir(), '.config', 'systemd', 'user', 'smartcontext-proxy.service');
+    try {
+        node_fs_1.default.unlinkSync(servicePath);
+        return `Removed ${servicePath}`;
+    }
+    catch {
+        return 'No service file found';
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/embedding/ollama.d.ts

@@ -0,0 +1,11 @@
+import type { EmbeddingAdapter } from './types.js';
+export declare class OllamaEmbeddingAdapter implements EmbeddingAdapter {
+    private url;
+    private model;
+    name: string;
+    dimensions: number;
+    constructor(url?: string, model?: string);
+    initialize(): Promise<void>;
+    embed(texts: string[]): Promise<number[][]>;
+    private embedSingle;
+}

package/dist/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/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/embedding/types.js

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

package/dist/index.d.ts

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

package/dist/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/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;
+}