smartcontext-proxy 0.1.0

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

package/dist/src/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/src/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/src/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/src/daemon/service.d.ts

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

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