n2-soul 4.1.0

package/lib/kv-cache/backup.js

@@ -0,0 +1,357 @@
+// Soul KV-Cache — Backup/Restore engine. sqlite-store 호환 DB 백업.
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * KV-Cache Backup Manager.
+ * Backs up snapshots + embeddings into sqlite-store 호환 DB.
+ * 백업 DB는 SqliteStore로 바로 열어서 사용 가능 (동일 스키마).
+ *
+ * Backup structure:
+ *   {backupDir}/{project}/
+ *     backup-YYYY-MM-DD.sqlite    — 바로 로드 가능한 DB
+ *     manifest.json                — 백업 히스토리
+ */
+class BackupManager {
+    /**
+     * @param {string} dataDir - Soul data directory (config.DATA_DIR)
+     * @param {object} config - backup config section
+     */
+    constructor(dataDir, config = {}) {
+        this.dataDir = dataDir;
+        this.backupDir = config.dir || path.join(dataDir, 'kv-cache', 'backups');
+        this.keepCount = config.keepCount || 7;
+        this.incremental = config.incremental !== false;
+        this._SQL = null;
+    }
+
+    /**
+     * Lazy-init sql.js (shared with sqlite-store).
+     * @returns {Promise<object>}
+     */
+    async _initSql() {
+        if (this._SQL) return this._SQL;
+        const { initSqlJs } = require('./sqlite-store');
+        this._SQL = await initSqlJs();
+        return this._SQL;
+    }
+
+    /**
+     * Backup: dump all project data into a sqlite-store 호환 DB.
+     * JSON 백엔드 → snapshots 폴더에서 읽고 DB에 INSERT.
+     * SQLite 백엔드 → .sqlite 파일 직접 복사 (가장 빠름).
+     *
+     * @param {string} project
+     * @param {object} options
+     * @param {boolean} options.full - 강제 전체 백업
+     * @returns {Promise<object>}
+     */
+    async backup(project, options = {}) {
+        const projectBackupDir = path.join(this.backupDir, project);
+        if (!fs.existsSync(projectBackupDir)) fs.mkdirSync(projectBackupDir, { recursive: true });
+
+        const manifest = this._loadManifest(project);
+
+        // 1) SQLite 백엔드: .sqlite 파일 직접 복사 (instant)
+        const sqlitePath = path.join(this.dataDir, 'kv-cache', 'sqlite', `${project}.sqlite`);
+        if (fs.existsSync(sqlitePath)) {
+            return this._backupByCopy(project, sqlitePath, manifest, options);
+        }
+
+        // 2) JSON 백엔드: snapshots → DB로 변환
+        return this._backupFromJson(project, manifest, options);
+    }
+
+    /**
+     * SQLite 백엔드 백업: 파일 복사 (동일 스키마, 바로 로드 가능).
+     */
+    _backupByCopy(project, sqlitePath, manifest, options) {
+        // Incremental check
+        if (!options.full && manifest.lastBackup) {
+            const lastTime = new Date(manifest.lastBackup).getTime();
+            const stat = fs.statSync(sqlitePath);
+            if (stat.mtimeMs <= lastTime) {
+                return { backupId: null, snapshots: 0, sizeBytes: 0, type: 'skip', message: 'No changes' };
+            }
+        }
+
+        const backupId = this._makeBackupId();
+        const destPath = path.join(this.backupDir, project, `backup-${backupId}.sqlite`);
+        fs.copyFileSync(sqlitePath, destPath);
+        const stat = fs.statSync(destPath);
+
+        const entry = { id: backupId, type: 'copy', timestamp: new Date().toISOString(), sizeBytes: stat.size };
+        manifest.backups.push(entry);
+        manifest.lastBackup = entry.timestamp;
+        this._saveManifest(project, manifest);
+        this._cleanup(project);
+
+        return {
+            backupId, type: 'copy', sizeBytes: stat.size,
+            sizeFormatted: this._formatBytes(stat.size),
+            path: destPath,
+        };
+    }
+
+    /**
+     * JSON 백엔드 백업: snapshots 폴더 → sqlite-store 호환 DB로 변환.
+     */
+    async _backupFromJson(project, manifest, options) {
+        const SQL = await this._initSql();
+        const snapDir = path.join(this.dataDir, 'kv-cache', 'snapshots', project);
+
+        if (!fs.existsSync(snapDir)) {
+            return { backupId: null, snapshots: 0, sizeBytes: 0, type: 'empty', error: 'No snapshots' };
+        }
+
+        // Collect JSON files (recursive — JSON backend uses {project}/{date}/*.json)
+        const snapFiles = [];
+        const scanDir = (dir) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                if (entry.isDirectory()) {
+                    scanDir(path.join(dir, entry.name));
+                } else if (entry.name.endsWith('.json')) {
+                    snapFiles.push(path.join(dir, entry.name));
+                }
+            }
+        };
+        scanDir(snapDir);
+
+        if (snapFiles.length === 0) {
+            return { backupId: null, snapshots: 0, sizeBytes: 0, type: 'empty', error: 'No snapshots' };
+        }
+
+        // Incremental check
+        if (!options.full && manifest.lastBackup) {
+            const lastTime = new Date(manifest.lastBackup).getTime();
+            const hasChanges = snapFiles.some(f => {
+                try { return fs.statSync(f).mtimeMs > lastTime; } catch (e) { return true; }
+            });
+            if (!hasChanges) {
+                return { backupId: null, snapshots: 0, sizeBytes: 0, type: 'skip', message: 'No changes' };
+            }
+        }
+
+        // Create DB with sqlite-store 호환 스키마
+        const db = new SQL.Database();
+        db.run(`
+            CREATE TABLE IF NOT EXISTS snapshots (
+                id TEXT PRIMARY KEY,
+                agent_name TEXT NOT NULL,
+                agent_type TEXT DEFAULT 'external',
+                model TEXT,
+                started_at TEXT,
+                ended_at TEXT,
+                turn_count INTEGER DEFAULT 0,
+                token_estimate INTEGER DEFAULT 0,
+                keys TEXT DEFAULT '[]',
+                context TEXT DEFAULT '{}',
+                parent_session_id TEXT,
+                project_name TEXT NOT NULL,
+                created_at TEXT DEFAULT (datetime('now'))
+            )
+        `);
+        db.run(`CREATE INDEX IF NOT EXISTS idx_snapshots_project ON snapshots(project_name, ended_at DESC)`);
+
+        // Embeddings table (bonus — also backed up)
+        db.run(`
+            CREATE TABLE IF NOT EXISTS embeddings (
+                snapshot_id TEXT PRIMARY KEY,
+                vector BLOB NOT NULL
+            )
+        `);
+
+        // Insert snapshots
+        const stmt = db.prepare(`
+            INSERT OR REPLACE INTO snapshots
+            (id, agent_name, agent_type, model, started_at, ended_at,
+             turn_count, token_estimate, keys, context, parent_session_id, project_name)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+
+        let snapCount = 0;
+        for (const filePath of snapFiles) {
+            try {
+                const raw = fs.readFileSync(filePath, 'utf-8');
+                const s = JSON.parse(raw);
+                stmt.run([
+                    s.id, s.agentName || 'unknown', s.agentType || 'external', s.model || null,
+                    s.startedAt || null, s.endedAt || null,
+                    s.turnCount || 0, s.tokenEstimate || 0,
+                    JSON.stringify(s.keys || []), JSON.stringify(s.context || {}),
+                    s.parentSessionId || null, s.projectName || project,
+                ]);
+                snapCount++;
+            } catch (e) { /* skip corrupt */ }
+        }
+        stmt.free();
+
+        // Insert embeddings
+        const embDir = path.join(this.dataDir, 'kv-cache', 'embeddings', project);
+        let embCount = 0;
+        if (fs.existsSync(embDir)) {
+            const embStmt = db.prepare('INSERT OR REPLACE INTO embeddings (snapshot_id, vector) VALUES (?, ?)');
+            for (const file of fs.readdirSync(embDir).filter(f => f.endsWith('.json'))) {
+                try {
+                    const vec = fs.readFileSync(path.join(embDir, file), 'utf-8');
+                    embStmt.run([path.basename(file, '.json'), vec]);
+                    embCount++;
+                } catch (e) { /* skip */ }
+            }
+            embStmt.free();
+        }
+
+        // Write DB to disk
+        const backupId = this._makeBackupId();
+        const destPath = path.join(this.backupDir, project, `backup-${backupId}.sqlite`);
+        const dbData = db.export();
+        const buffer = Buffer.from(dbData);
+        fs.writeFileSync(destPath, buffer);
+        db.close();
+
+        const entry = {
+            id: backupId, type: 'full', timestamp: new Date().toISOString(),
+            snapshots: snapCount, embeddings: embCount, sizeBytes: buffer.length,
+        };
+        manifest.backups.push(entry);
+        manifest.lastBackup = entry.timestamp;
+        this._saveManifest(project, manifest);
+        this._cleanup(project);
+
+        return {
+            backupId, snapshots: snapCount, embeddings: embCount,
+            sizeBytes: buffer.length, sizeFormatted: this._formatBytes(buffer.length),
+            type: 'full', path: destPath,
+        };
+    }
+
+    /**
+     * Restore from backup. 백업 DB를 sqlite-store 위치에 복사하거나,
+     * JSON 백엔드면 DB에서 읽어서 JSON으로 복원.
+     *
+     * @param {string} project
+     * @param {string} backupId
+     * @param {object} options
+     * @param {string} options.target - 'sqlite' | 'json' (default: 'json')
+     * @returns {Promise<object>}
+     */
+    async restore(project, backupId = null, options = {}) {
+        const manifest = this._loadManifest(project);
+        if (!backupId) {
+            if (manifest.backups.length === 0) return { error: 'No backups found', restored: 0 };
+            backupId = manifest.backups[manifest.backups.length - 1].id;
+        }
+
+        const dbPath = path.join(this.backupDir, project, `backup-${backupId}.sqlite`);
+        if (!fs.existsSync(dbPath)) return { error: `Backup not found: ${backupId}`, restored: 0 };
+
+        const target = options.target || 'json';
+
+        if (target === 'sqlite') {
+            // Direct copy to sqlite-store location
+            const destDir = path.join(this.dataDir, 'kv-cache', 'sqlite');
+            if (!fs.existsSync(destDir)) fs.mkdirSync(destDir, { recursive: true });
+            fs.copyFileSync(dbPath, path.join(destDir, `${project}.sqlite`));
+            return { restored: 'full', backupId, target: 'sqlite' };
+        }
+
+        // JSON restore: extract from DB back to snapshot files
+        const SQL = await this._initSql();
+        const dbData = fs.readFileSync(dbPath);
+        const db = new SQL.Database(dbData);
+
+        const snapDir = path.join(this.dataDir, 'kv-cache', 'snapshots', project);
+        if (!fs.existsSync(snapDir)) fs.mkdirSync(snapDir, { recursive: true });
+
+        let restoredSnaps = 0;
+        const snapRows = db.exec('SELECT * FROM snapshots');
+        if (snapRows.length > 0) {
+            const cols = snapRows[0].columns;
+            for (const row of snapRows[0].values) {
+                const obj = {};
+                cols.forEach((c, i) => { obj[c] = row[i]; });
+                const session = {
+                    id: obj.id, agentName: obj.agent_name, agentType: obj.agent_type,
+                    model: obj.model, startedAt: obj.started_at, endedAt: obj.ended_at,
+                    turnCount: obj.turn_count, tokenEstimate: obj.token_estimate,
+                    keys: JSON.parse(obj.keys || '[]'), context: JSON.parse(obj.context || '{}'),
+                    parentSessionId: obj.parent_session_id, projectName: obj.project_name,
+                };
+                fs.writeFileSync(path.join(snapDir, `${session.id}.json`), JSON.stringify(session, null, 2));
+                restoredSnaps++;
+            }
+        }
+
+        // Embeddings
+        const embDir = path.join(this.dataDir, 'kv-cache', 'embeddings', project);
+        if (!fs.existsSync(embDir)) fs.mkdirSync(embDir, { recursive: true });
+        let restoredEmbs = 0;
+        const embRows = db.exec('SELECT snapshot_id, vector FROM embeddings');
+        if (embRows.length > 0) {
+            for (const row of embRows[0].values) {
+                fs.writeFileSync(path.join(embDir, `${row[0]}.json`), row[1]);
+                restoredEmbs++;
+            }
+        }
+
+        db.close();
+        return { restored: restoredSnaps, embeddings: restoredEmbs, backupId, target: 'json' };
+    }
+
+    /** List backup history. */
+    list(project) {
+        return this._loadManifest(project).backups.map(b => ({
+            ...b, sizeFormatted: this._formatBytes(b.sizeBytes),
+        }));
+    }
+
+    /** Backup status summary. */
+    status(project) {
+        const manifest = this._loadManifest(project);
+        const totalSize = manifest.backups.reduce((s, b) => s + (b.sizeBytes || 0), 0);
+        return {
+            project, totalBackups: manifest.backups.length,
+            lastBackup: manifest.lastBackup, totalBackupSize: this._formatBytes(totalSize),
+            keepCount: this.keepCount,
+        };
+    }
+
+    // ── Helpers ──
+
+    _cleanup(project) {
+        const manifest = this._loadManifest(project);
+        const dir = path.join(this.backupDir, project);
+        let deleted = 0;
+        while (manifest.backups.length > this.keepCount) {
+            const old = manifest.backups.shift();
+            try { fs.unlinkSync(path.join(dir, `backup-${old.id}.sqlite`)); deleted++; } catch (e) { }
+        }
+        if (deleted > 0) this._saveManifest(project, manifest);
+        return { deleted };
+    }
+
+    _makeBackupId() {
+        return new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+    }
+
+    _loadManifest(project) {
+        const p = path.join(this.backupDir, project, 'manifest.json');
+        try { if (fs.existsSync(p)) return JSON.parse(fs.readFileSync(p, 'utf-8')); } catch (e) { }
+        return { backups: [], lastBackup: null };
+    }
+
+    _saveManifest(project, manifest) {
+        const dir = path.join(this.backupDir, project);
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    }
+
+    _formatBytes(bytes) {
+        if (!bytes) return '0 B';
+        const u = ['B', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(1024));
+        return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${u[i]}`;
+    }
+}
+
+module.exports = { BackupManager };

package/lib/kv-cache/compressor.js

@@ -0,0 +1,130 @@
+// Soul KV-Cache — Context compressor. Reduces documents to key-value pairs.
+const { extractKeywords } = require('./agent-adapter');
+
+/**
+ * Compresses full text into a structured KV representation.
+ * No LLM call — uses pattern-based extractive summarization.
+ *
+ * @param {string} text - Full document text
+ * @param {number} targetTokens - Target compressed size in estimated tokens
+ * @returns {{ keys: string[], compressed: string, ratio: number }}
+ */
+function compress(text, targetTokens = 1000) {
+    if (!text || text.length === 0) {
+        return { keys: [], compressed: '', ratio: 1 };
+    }
+
+    const keys = extractKeywords(text, 15);
+    const sentences = splitSentences(text);
+    const scored = scoreSentences(sentences, keys);
+
+    // Select top sentences until we hit token budget
+    const maxChars = targetTokens * 3; // conservative char-to-token ratio
+    let charCount = 0;
+    const selected = [];
+
+    for (const item of scored) {
+        if (charCount + item.sentence.length > maxChars) break;
+        selected.push(item);
+        charCount += item.sentence.length;
+    }
+
+    // Re-order by original position for readability
+    selected.sort((a, b) => a.index - b.index);
+    const compressed = selected.map(s => s.sentence).join(' ');
+
+    return {
+        keys,
+        compressed,
+        ratio: text.length > 0 ? Math.round((compressed.length / text.length) * 100) / 100 : 1,
+    };
+}
+
+/**
+ * Decompresses a snapshot context into readable format.
+ *
+ * @param {object} snapshot - KV-Cache session object
+ * @returns {string} Human-readable context
+ */
+function decompress(snapshot) {
+    if (!snapshot) return '';
+
+    const parts = [];
+
+    if (snapshot.keys?.length > 0) {
+        parts.push(`Keywords: ${snapshot.keys.join(', ')}`);
+    }
+    if (snapshot.context?.summary) {
+        parts.push(`Summary: ${snapshot.context.summary}`);
+    }
+    if (snapshot.context?.decisions?.length > 0) {
+        parts.push(`Decisions:\n${snapshot.context.decisions.map(d => `  - ${d}`).join('\n')}`);
+    }
+    if (snapshot.context?.todo?.length > 0) {
+        parts.push(`TODO:\n${snapshot.context.todo.map(t => `  - ${t}`).join('\n')}`);
+    }
+
+    return parts.join('\n\n');
+}
+
+/**
+ * Splits text into sentences. Handles Korean and English.
+ *
+ * @param {string} text
+ * @returns {string[]}
+ */
+function splitSentences(text) {
+    // First split by line breaks (most reliable for Korean docs)
+    const byLines = text.split(/\n+/).map(s => s.trim()).filter(s => s.length > 5);
+
+    // Then split long lines by sentence boundaries
+    const result = [];
+    for (const line of byLines) {
+        if (line.length < 150) {
+            result.push(line);
+            continue;
+        }
+        // Korean sentence enders: 다/요/함/음/됨/습니다/입니다/했다/됐다/이다/한다
+        // English: .!?
+        const parts = line.split(/(?<=[.!?])\s+|(?<=(?:습니다|입니다|했다|됐다|한다|됩니다|합니다|있다|없다|이다|된다|한다|해야|할것|하자|함\.|음\.|됨\.))\s*/);
+        for (const p of parts) {
+            const trimmed = p.trim();
+            if (trimmed.length > 5) result.push(trimmed);
+        }
+    }
+    return result;
+}
+
+/**
+ * Scores sentences by keyword relevance.
+ *
+ * @param {string[]} sentences
+ * @param {string[]} keywords
+ * @returns {{ sentence: string, score: number, index: number }[]}
+ */
+function scoreSentences(sentences, keywords) {
+    const scored = sentences.map((sentence, index) => {
+        const lower = sentence.toLowerCase();
+        let score = 0;
+
+        for (const kw of keywords) {
+            const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const matches = (lower.match(new RegExp(escaped, 'g')) || []).length;
+            score += matches;
+        }
+
+        // Bonus for first/last sentences (usually most informative)
+        if (index === 0) score += 2;
+        if (index === sentences.length - 1) score += 1;
+
+        // Bonus for shorter sentences (more likely to be conclusions)
+        if (sentence.length < 100) score += 0.5;
+
+        return { sentence, score, index };
+    });
+
+    // Sort by score descending
+    return scored.sort((a, b) => b.score - a.score);
+}
+
+module.exports = { compress, decompress, splitSentences, scoreSentences };

package/lib/kv-cache/embedding.js

@@ -0,0 +1,205 @@
+// Soul KV-Cache — Embedding engine. Generates and searches vector embeddings via Ollama.
+const http = require('http');
+
+/**
+ * Embedding engine for semantic search via Ollama local API.
+ * Converts text to vector embeddings and computes cosine similarity.
+ *
+ * Supported models: nomic-embed-text (recommended), qwen3, llama3, etc.
+ * Any Ollama model that supports /api/embeddings endpoint works.
+ */
+class EmbeddingEngine {
+    /**
+     * @param {object} config - Embedding config from config.KV_CACHE.embedding
+     * @param {string} config.model - Ollama model name
+     * @param {string} config.endpoint - Ollama endpoint (default: http://127.0.0.1:11434)
+     */
+    constructor(config = {}) {
+        this.model = config.model || 'nomic-embed-text';
+        this.endpoint = config.endpoint || 'http://127.0.0.1:11434';
+        this.dimensions = null; // Set after first embedding call
+        this._available = null; // Cached availability check
+    }
+
+    /**
+     * Check if Ollama is available and the model supports embeddings.
+     * @returns {Promise<boolean>}
+     */
+    async isAvailable() {
+        if (this._available !== null) return this._available;
+        try {
+            const vec = await this.embed('test');
+            this._available = vec.length > 0;
+            this.dimensions = vec.length;
+            return this._available;
+        } catch (e) {
+            this._available = false;
+            return false;
+        }
+    }
+
+    /**
+     * Generate embedding vector for text.
+     *
+     * @param {string} text - Input text
+     * @returns {Promise<number[]>} Embedding vector
+     */
+    async embed(text) {
+        if (!text || text.trim().length === 0) return [];
+
+        // Truncate to ~2000 chars for embedding efficiency
+        const input = text.length > 2000 ? text.slice(0, 2000) : text;
+
+        // Try /api/embeddings first (older API), then /api/embed (newer)
+        for (const path of ['/api/embeddings', '/api/embed']) {
+            try {
+                const body = path === '/api/embeddings'
+                    ? { model: this.model, prompt: input }
+                    : { model: this.model, input: input };
+
+                const result = await this._post(path, body);
+
+                if (result.embedding && Array.isArray(result.embedding)) {
+                    this.dimensions = result.embedding.length;
+                    return result.embedding;
+                }
+                if (result.embeddings && Array.isArray(result.embeddings) && result.embeddings[0]) {
+                    this.dimensions = result.embeddings[0].length;
+                    return result.embeddings[0];
+                }
+            } catch (e) {
+                continue;
+            }
+        }
+
+        return [];
+    }
+
+    /**
+     * Generate embeddings for multiple texts in batch.
+     *
+     * @param {string[]} texts
+     * @returns {Promise<number[][]>}
+     */
+    async embedBatch(texts) {
+        const results = [];
+        for (const text of texts) {
+            results.push(await this.embed(text));
+        }
+        return results;
+    }
+
+    /**
+     * Compute cosine similarity between two vectors.
+     *
+     * @param {number[]} a
+     * @param {number[]} b
+     * @returns {number} Similarity score (0-1)
+     */
+    cosineSimilarity(a, b) {
+        if (!a || !b || a.length === 0 || b.length === 0 || a.length !== b.length) return 0;
+
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+
+        for (let i = 0; i < a.length; i++) {
+            dotProduct += a[i] * b[i];
+            normA += a[i] * a[i];
+            normB += b[i] * b[i];
+        }
+
+        const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+        return denominator === 0 ? 0 : dotProduct / denominator;
+    }
+
+    /**
+     * Search for the most similar vectors to a query vector.
+     *
+     * @param {number[]} queryVec - Query embedding vector
+     * @param {{ id: string, vector: number[] }[]} candidates - Candidate vectors
+     * @param {number} topK - Number of results to return
+     * @param {number} threshold - Minimum similarity threshold (0-1)
+     * @returns {{ id: string, score: number }[]}
+     */
+    rankBySimilarity(queryVec, candidates, topK = 10, threshold = 0.3) {
+        if (!queryVec || queryVec.length === 0 || candidates.length === 0) return [];
+
+        const scored = candidates
+            .map(c => ({
+                id: c.id,
+                score: this.cosineSimilarity(queryVec, c.vector),
+            }))
+            .filter(c => c.score >= threshold)
+            .sort((a, b) => b.score - a.score);
+
+        return scored.slice(0, topK);
+    }
+
+    /**
+     * Create a searchable text from a snapshot for embedding.
+     *
+     * @param {object} snapshot - KV-Cache session snapshot
+     * @returns {string} Combined text for embedding
+     */
+    snapshotToText(snapshot) {
+        const parts = [];
+        if (snapshot.keys?.length > 0) parts.push(snapshot.keys.join(' '));
+        if (snapshot.context?.summary) parts.push(snapshot.context.summary);
+        if (snapshot.context?.decisions?.length > 0) {
+            parts.push(snapshot.context.decisions.join(' '));
+        }
+        if (snapshot.context?.todo?.length > 0) {
+            parts.push(snapshot.context.todo.join(' '));
+        }
+        return parts.join('. ');
+    }
+
+    /**
+     * HTTP POST helper for Ollama API.
+     *
+     * @param {string} path - API path
+     * @param {object} body - Request body
+     * @returns {Promise<object>} Response JSON
+     */
+    _post(path, body) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(this.endpoint);
+            const options = {
+                hostname: url.hostname,
+                port: url.port || 11434,
+                path,
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                timeout: 30000,
+            };
+
+            const req = http.request(options, res => {
+                let data = '';
+                res.on('data', chunk => { data += chunk; });
+                res.on('end', () => {
+                    if (res.statusCode >= 400) {
+                        reject(new Error(`Ollama ${res.statusCode}: ${data.slice(0, 200)}`));
+                        return;
+                    }
+                    try {
+                        resolve(JSON.parse(data));
+                    } catch (e) {
+                        reject(new Error(`Invalid JSON from Ollama: ${data.slice(0, 100)}`));
+                    }
+                });
+            });
+
+            req.on('error', reject);
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Ollama request timed out'));
+            });
+
+            req.write(JSON.stringify(body));
+            req.end();
+        });
+    }
+}
+
+module.exports = { EmbeddingEngine };