smartcontext-proxy 0.1.0

package/src/context/canonical.ts

@@ -0,0 +1,50 @@
+export interface ContentBlock {
+  type: 'text' | 'image' | 'tool_use' | 'tool_result';
+  text?: string;
+  // Pass-through fields for non-text content
+  [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 function getTextContent(msg: CanonicalMessage): string {
+  if (typeof msg.content === 'string') return msg.content;
+  return msg.content
+    .filter((b) => b.type === 'text' && b.text)
+    .map((b) => b.text!)
+    .join('\n');
+}

package/src/context/chunker.ts

@@ -0,0 +1,165 @@
+import type { CanonicalMessage } from './canonical.js';
+import { getTextContent } from './canonical.js';
+import type { Chunk } from '../storage/types.js';
+import { randomUUID } from 'node:crypto';
+
+const AVG_CHARS_PER_TOKEN = 4;
+const MAX_CHUNK_TOKENS = 2000;
+
+export function estimateTokens(text: string): number {
+  return Math.ceil(text.length / AVG_CHARS_PER_TOKEN);
+}
+
+/** Extract file paths mentioned in text */
+function extractFilePaths(text: string): string[] {
+  const patterns = [
+    /(?:^|\s)((?:\/[\w.-]+)+(?:\.\w+)?)/gm,
+    /(?:^|\s)((?:[\w.-]+\/)+[\w.-]+(?:\.\w+)?)/gm,
+    /`([^`]*\/[^`]*\.\w+)`/g,
+  ];
+
+  const files = new Set<string>();
+  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: string): string[] {
+  const tools = new Set<string>();
+  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.
+ */
+export function chunkConversation(
+  messages: CanonicalMessage[],
+  sessionId: string,
+  baseTimestamp?: number,
+): Chunk[] {
+  const chunks: Chunk[] = [];
+  let exchangeIndex = 0;
+
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== 'user') continue;
+
+    const userText = getTextContent(msg);
+    let assistantText = '';
+    for (let j = i + 1; j < messages.length; j++) {
+      if (messages[j].role === 'assistant') {
+        assistantText = 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: 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: 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: 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: string): string[] {
+  const parts: string[] = [];
+  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;
+}

package/src/context/optimizer.ts

@@ -0,0 +1,201 @@
+import type { CanonicalRequest, CanonicalMessage } from './canonical.js';
+import { getTextContent } from './canonical.js';
+import { chunkConversation, estimateTokens } from './chunker.js';
+import { Retriever, type RetrievalResult } from './retriever.js';
+import { packContext, 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';
+import { randomUUID } from 'node:crypto';
+
+export interface OptimizationResult {
+  optimizedMessages: CanonicalMessage[];
+  systemPrompt?: string;
+  packed: PackedContext;
+  retrieval: RetrievalResult | null;
+  passThrough: boolean;
+  reason?: string;
+}
+
+export class ContextOptimizer {
+  private retriever: Retriever;
+
+  constructor(
+    private embedding: EmbeddingAdapter,
+    private storage: StorageAdapter,
+    private config: ContextConfig,
+  ) {
+    this.retriever = new Retriever(embedding, storage, config);
+  }
+
+  /**
+   * Optimize context for a request.
+   * Returns pass-through if optimization isn't beneficial.
+   */
+  async optimize(request: CanonicalRequest): Promise<OptimizationResult> {
+    const { messages, systemPrompt, model } = request;
+
+    // Calculate original size
+    const originalTokens =
+      estimateTokens(systemPrompt || '') +
+      messages.reduce((sum, m) => sum + estimateTokens(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: estimateTokens(systemPrompt || ''),
+            tier1Tokens: originalTokens - 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 ? 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: RetrievalResult;
+    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: estimateTokens(systemPrompt || ''),
+            tier1Tokens: originalTokens - 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 = 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: CanonicalMessage[] = [];
+
+    // 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: CanonicalMessage[],
+    sessionId: string,
+  ): Promise<void> {
+    const chunks = 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);
+  }
+}
+
+function simpleHash(str: string): string {
+  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);
+}

package/src/context/retriever.ts

@@ -0,0 +1,123 @@
+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 class Retriever {
+  constructor(
+    private embedding: EmbeddingAdapter,
+    private storage: StorageAdapter,
+    private config: ContextConfig,
+  ) {}
+
+  async retrieve(
+    queryText: string,
+    currentSessionId: string,
+    mentionedFiles: string[],
+  ): Promise<RetrievalResult> {
+    // 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) */
+  private dedup(chunks: ScoredChunk[]): ScoredChunk[] {
+    const kept: ScoredChunk[] = [];
+
+    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;
+  }
+}

package/src/daemon/process.ts

@@ -0,0 +1,70 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+const PID_FILE = path.join(process.env['HOME'] || '.', '.smartcontext', 'smartcontext.pid');
+const LOG_FILE = path.join(process.env['HOME'] || '.', '.smartcontext', 'logs', 'proxy.log');
+
+export function getPid(): number | null {
+  try {
+    const pid = parseInt(fs.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 { fs.unlinkSync(PID_FILE); } catch {}
+    return null;
+  }
+}
+
+export function writePid(): void {
+  const dir = path.dirname(PID_FILE);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(PID_FILE, String(process.pid));
+}
+
+export function removePid(): void {
+  try { fs.unlinkSync(PID_FILE); } catch {}
+}
+
+export function startDaemon(args: string[]): number {
+  const existingPid = getPid();
+  if (existingPid) {
+    console.log(`Already running (PID ${existingPid})`);
+    return existingPid;
+  }
+
+  const logDir = path.dirname(LOG_FILE);
+  fs.mkdirSync(logDir, { recursive: true });
+
+  const out = fs.openSync(LOG_FILE, 'a');
+  const err = fs.openSync(LOG_FILE, 'a');
+
+  const child = spawn(process.execPath, [__filename, ...args, '--daemon-child'], {
+    detached: true,
+    stdio: ['ignore', out, err],
+  });
+
+  child.unref();
+
+  console.log(`Started (PID ${child.pid})`);
+  return child.pid!;
+}
+
+export function stopDaemon(): boolean {
+  const pid = getPid();
+  if (!pid) {
+    console.log('Not running');
+    return false;
+  }
+
+  process.kill(pid, 'SIGTERM');
+  removePid();
+  console.log(`Stopped (PID ${pid})`);
+  return true;
+}
+
+export function isDaemonChild(): boolean {
+  return process.argv.includes('--daemon-child');
+}

package/src/daemon/service.ts

@@ -0,0 +1,103 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function installService(port: number): string {
+  if (process.platform === 'darwin') {
+    return installLaunchAgent(port);
+  }
+  return installSystemd(port);
+}
+
+export function uninstallService(): string {
+  if (process.platform === 'darwin') {
+    return uninstallLaunchAgent();
+  }
+  return uninstallSystemd();
+}
+
+function installLaunchAgent(port: number): string {
+  const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(plistDir, 'com.smartcontext.proxy.plist');
+  const logDir = path.join(os.homedir(), '.smartcontext', 'logs');
+
+  fs.mkdirSync(plistDir, { recursive: true });
+  fs.mkdirSync(logDir, { recursive: true });
+
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(path.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>`;
+
+  fs.writeFileSync(plistPath, plist);
+  return plistPath;
+}
+
+function uninstallLaunchAgent(): string {
+  const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'com.smartcontext.proxy.plist');
+  try {
+    fs.unlinkSync(plistPath);
+    return `Removed ${plistPath}`;
+  } catch {
+    return 'No service file found';
+  }
+}
+
+function installSystemd(port: number): string {
+  const serviceDir = path.join(os.homedir(), '.config', 'systemd', 'user');
+  const servicePath = path.join(serviceDir, 'smartcontext-proxy.service');
+
+  fs.mkdirSync(serviceDir, { recursive: true });
+
+  const nodePath = process.execPath;
+  const scriptPath = path.resolve(path.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
+`;
+
+  fs.writeFileSync(servicePath, service);
+  return servicePath;
+}
+
+function uninstallSystemd(): string {
+  const servicePath = path.join(os.homedir(), '.config', 'systemd', 'user', 'smartcontext-proxy.service');
+  try {
+    fs.unlinkSync(servicePath);
+    return `Removed ${servicePath}`;
+  } catch {
+    return 'No service file found';
+  }
+}