codehere 0.2.2 → 0.3.0-rc.10

package/dist/infrastructure/storage/sqlite-decision-repository.js

@@ -1,232 +0,0 @@
-/**
- * Infrastructure: SQLiteDecisionRepository
- * SQLite implementation of decision storage
- *
- * Clean Architecture: Infrastructure Layer
- * Pattern: Repository Pattern Implementation
- */
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
-import { randomUUID } from 'crypto';
-function getDbPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../..');
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'decisions.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'decisions.sqlite');
-}
-export class SQLiteDecisionRepository {
-    dbPath;
-    db = null;
-    constructor() {
-        this.dbPath = getDbPath();
-    }
-    async getDb() {
-        if (this.db)
-            return this.db;
-        const SQL = await initSqlJs();
-        const dbDir = dirname(this.dbPath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        // Create decisions table
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS decisions (
-        id TEXT PRIMARY KEY,
-        codebaseId TEXT NOT NULL,
-        type TEXT NOT NULL,
-        title TEXT NOT NULL,
-        description TEXT NOT NULL,
-        rationale TEXT NOT NULL,
-        alternatives TEXT,
-        constraints TEXT,
-        tradeoffs TEXT,
-        consequences TEXT,
-        metadata TEXT,
-        createdAt INTEGER NOT NULL,
-        updatedAt INTEGER,
-        author TEXT
-      )
-    `);
-        // Create indexes
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_codebase ON decisions(codebaseId)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_type ON decisions(codebaseId, type)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_created ON decisions(codebaseId, createdAt DESC)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_status ON decisions(codebaseId, json_extract(metadata, '$.status'))`);
-        return this.db;
-    }
-    async store(decision) {
-        const db = await this.getDb();
-        const id = decision.id || randomUUID();
-        const now = Date.now();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO decisions
-      (id, codebaseId, type, title, description, rationale, alternatives, constraints,
-       tradeoffs, consequences, metadata, createdAt, updatedAt, author)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run([
-            id,
-            decision.codebaseId,
-            decision.type,
-            decision.title,
-            decision.description,
-            decision.rationale,
-            JSON.stringify(decision.alternatives ?? []),
-            JSON.stringify(decision.constraints ?? []),
-            JSON.stringify(decision.tradeoffs ?? []),
-            JSON.stringify(decision.consequences ?? []),
-            JSON.stringify(decision.metadata ?? {}),
-            decision.createdAt.getTime(),
-            decision.updatedAt?.getTime() ?? now,
-            decision.author ?? null,
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM decisions WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return this.mapRowToDecision(row);
-    }
-    async findByCodebase(codebaseId, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM decisions
-      WHERE codebaseId = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async findByType(codebaseId, type, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM decisions
-      WHERE codebaseId = ? AND type = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, type, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async search(codebaseId, query, limit = 50) {
-        const db = await this.getDb();
-        const searchTerm = `%${query}%`;
-        const stmt = db.prepare(`
-      SELECT * FROM decisions
-      WHERE codebaseId = ?
-        AND (title LIKE ? OR description LIKE ? OR rationale LIKE ?)
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, searchTerm, searchTerm, searchTerm, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async update(decision) {
-        if (!decision.id) {
-            throw new Error('Decision ID required for update');
-        }
-        decision.updatedAt = new Date();
-        await this.store(decision); // INSERT OR REPLACE handles update
-    }
-    async delete(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('DELETE FROM decisions WHERE id = ?');
-        stmt.run([id]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getRecent(codebaseId, limit = 10) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM decisions
-      WHERE codebaseId = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async getByStatus(codebaseId, status, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM decisions
-      WHERE codebaseId = ?
-        AND json_extract(metadata, '$.status') = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, status, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async findRelated(decisionId, limit = 10) {
-        const decision = await this.getById(decisionId);
-        if (!decision || !decision.metadata?.relatedDecisions) {
-            return [];
-        }
-        const relatedIds = decision.metadata.relatedDecisions.slice(0, limit);
-        const related = [];
-        for (const id of relatedIds) {
-            const relatedDecision = await this.getById(id);
-            if (relatedDecision) {
-                related.push(relatedDecision);
-            }
-        }
-        return related;
-    }
-    mapRowToDecision(row) {
-        const metadata = JSON.parse(row.metadata ?? '{}');
-        return {
-            id: row.id,
-            codebaseId: row.codebaseId,
-            type: row.type,
-            title: row.title,
-            description: row.description,
-            rationale: row.rationale,
-            alternatives: JSON.parse(row.alternatives ?? '[]'),
-            constraints: JSON.parse(row.constraints ?? '[]'),
-            tradeoffs: JSON.parse(row.tradeoffs ?? '[]'),
-            consequences: JSON.parse(row.consequences ?? '[]'),
-            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
-            createdAt: new Date(row.createdAt),
-            updatedAt: row.updatedAt ? new Date(row.updatedAt) : undefined,
-            author: row.author ?? undefined,
-        };
-    }
-    executeAndMap(stmt) {
-        const decisions = [];
-        while (stmt.step()) {
-            decisions.push(this.mapRowToDecision(stmt.getAsObject()));
-        }
-        stmt.free();
-        return decisions;
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-}
-//# sourceMappingURL=sqlite-decision-repository.js.map

package/dist/infrastructure/storage/sqlite-embedding-repository.js

@@ -1,311 +0,0 @@
-/**
- * Infrastructure: SQLiteEmbeddingRepository
- * Implements IEmbeddingRepository using SQLite
- */
-import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
-import { getQueryResultCache } from '../cache/query-result-cache.js';
-import { getEmbeddingsDbPath } from './embeddings-path.js';
-/**
- * @deprecated Legacy global DB path - use getEmbeddingsDbPath() instead
- * This function is not used - SQLiteEmbeddingRepository now uses per-repo paths by default
- * Kept only for reference during migration
- */
-function getLegacyDbPath() {
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    const agentDir = join(__dirname, '../../..');
-    if (existsSync(join(agentDir, 'package.json'))) {
-        return join(agentDir, 'data', 'embeddings.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'embeddings.sqlite');
-}
-function cosineSimilarity(a, b) {
-    if (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;
-}
-/**
- * Optimized cosine similarity with pre-computed query norm
- * Reduces redundant calculations when comparing same query to multiple embeddings
- */
-function cosineSimilarityOptimized(queryEmbedding, queryNorm, docEmbedding) {
-    if (queryEmbedding.length !== docEmbedding.length)
-        return 0;
-    let dotProduct = 0;
-    let docNorm = 0;
-    for (let i = 0; i < docEmbedding.length; i++) {
-        dotProduct += queryEmbedding[i] * docEmbedding[i];
-        docNorm += docEmbedding[i] * docEmbedding[i];
-    }
-    const denominator = queryNorm * Math.sqrt(docNorm);
-    return denominator === 0 ? 0 : dotProduct / denominator;
-}
-export class SQLiteEmbeddingRepository {
-    dbPath;
-    db = null;
-    /**
-     * @param dbPath - Optional database path. If not provided, uses per-repo path via getEmbeddingsDbPath()
-     * @param cwd - Optional current working directory for codebase root detection (defaults to process.cwd())
-     */
-    constructor(dbPath, cwd) {
-        if (dbPath) {
-            // Use provided path
-            this.dbPath = dbPath;
-        }
-        else {
-            // Use per-repo path based on codebase root
-            const pathInfo = getEmbeddingsDbPath(cwd);
-            this.dbPath = pathInfo.dbPath;
-        }
-    }
-    async getDb() {
-        if (this.db)
-            return this.db;
-        const SQL = await initSqlJs();
-        const dbDir = dirname(this.dbPath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS embeddings (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        filepath TEXT NOT NULL,
-        chunkIndex INTEGER NOT NULL,
-        content TEXT NOT NULL,
-        embedding TEXT NOT NULL
-      )
-    `);
-        this.db.run(`
-      CREATE INDEX IF NOT EXISTS idx_filepath ON embeddings(filepath)
-    `);
-        return this.db;
-    }
-    async store(chunks) {
-        const db = await this.getDb();
-        db.run('DELETE FROM embeddings');
-        const stmt = db.prepare(`
-      INSERT INTO embeddings (filepath, chunkIndex, content, embedding)
-      VALUES (?, ?, ?, ?)
-    `);
-        for (const chunk of chunks) {
-            if (!chunk.embedding)
-                continue;
-            stmt.run([
-                chunk.filepath,
-                chunk.chunkIndex || 0,
-                chunk.content,
-                JSON.stringify(chunk.embedding),
-            ]);
-        }
-        stmt.free();
-        this.saveDb();
-        // Clear query result cache when codebase is re-indexed
-        getQueryResultCache().clear();
-    }
-    async search(query, topK) {
-        // For now, return empty - will implement with query embedding
-        // This requires AI service, which creates circular dependency
-        // Will be resolved via dependency injection in application layer
-        return [];
-    }
-    async getByFilepath(filepath) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM embeddings WHERE filepath = ?');
-        stmt.bind([filepath]);
-        const results = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            results.push({
-                filepath: row.filepath,
-                content: row.content,
-                score: 1.0,
-                chunkIndex: row.chunkIndex,
-                embedding: JSON.parse(row.embedding),
-            });
-        }
-        stmt.free();
-        return results;
-    }
-    async isIndexed(filepath) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT COUNT(*) as count FROM embeddings WHERE filepath = ?');
-        stmt.bind([filepath]);
-        stmt.step();
-        const result = stmt.getAsObject();
-        stmt.free();
-        return result.count > 0;
-    }
-    /**
-     * Check if any embeddings exist for this repository
-     * Used to detect when a repo has never been indexed
-     */
-    async hasEmbeddings() {
-        // Check if DB file exists
-        if (!existsSync(this.dbPath)) {
-            return false;
-        }
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT COUNT(*) as count FROM embeddings');
-        stmt.step();
-        const result = stmt.getAsObject();
-        stmt.free();
-        return result.count > 0;
-    }
-    async clear() {
-        const db = await this.getDb();
-        db.run('DELETE FROM embeddings');
-        this.saveDb();
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-    /**
-     * Search with pre-computed query embedding
-     * (Used by application layer to avoid circular dependency)
-     *
-     * PERFORMANCE OPTIMIZATION:
-     * 1. Uses min-heap to maintain only topK results (O(n log k) vs O(n log n))
-     * 2. Pre-computes query norm once (avoids redundant calculations)
-     * 3. Optimized cosine similarity calculation
-     * 4. Result caching (query + topK results) to avoid redundant searches
-     * 5. Batch processing with early termination for large datasets
-     * 6. Optimized JSON parsing (cache parsed embeddings per row)
-     *
-     * Note: Cache key should be generated from query string, not embedding
-     * This method receives embedding, so caching should be done at call site
-     */
-    async searchWithEmbedding(queryEmbedding, topK) {
-        const db = await this.getDb();
-        // Pre-compute query norm once (used for all similarity calculations)
-        let queryNorm = 0;
-        for (let i = 0; i < queryEmbedding.length; i++) {
-            queryNorm += queryEmbedding[i] * queryEmbedding[i];
-        }
-        queryNorm = Math.sqrt(queryNorm);
-        // Get total count for optimization decisions
-        const countStmt = db.prepare('SELECT COUNT(*) as count FROM embeddings');
-        countStmt.step();
-        const totalCount = countStmt.getAsObject().count;
-        countStmt.free();
-        // OPTIMIZATION: Early termination for large datasets
-        // Process with early termination if dataset is large
-        const USE_EARLY_TERMINATION = totalCount > 500;
-        const MAX_PROCESS = USE_EARLY_TERMINATION ? Math.min(totalCount, 1000) : totalCount;
-        // Min-heap to maintain topK results (smallest score at root)
-        const heap = [];
-        const heapInsert = (item) => {
-            if (heap.length < topK) {
-                heap.push(item);
-                // Bubble up
-                let i = heap.length - 1;
-                while (i > 0) {
-                    const parent = Math.floor((i - 1) / 2);
-                    if (heap[parent].score <= heap[i].score)
-                        break;
-                    [heap[parent], heap[i]] = [heap[i], heap[parent]];
-                    i = parent;
-                }
-            }
-            else if (item.score > heap[0].score) {
-                // Replace root (smallest) with new item if it's larger
-                heap[0] = item;
-                // Bubble down
-                let i = 0;
-                while (true) {
-                    const left = 2 * i + 1;
-                    const right = 2 * i + 2;
-                    let smallest = i;
-                    if (left < heap.length && heap[left].score < heap[smallest].score) {
-                        smallest = left;
-                    }
-                    if (right < heap.length && heap[right].score < heap[smallest].score) {
-                        smallest = right;
-                    }
-                    if (smallest === i)
-                        break;
-                    [heap[i], heap[smallest]] = [heap[smallest], heap[i]];
-                    i = smallest;
-                }
-            }
-        };
-        // Standard query - early termination will handle large datasets
-        const stmt = db.prepare('SELECT * FROM embeddings');
-        let processed = 0;
-        let consecutiveLowScores = 0;
-        const EARLY_TERMINATION_THRESHOLD = USE_EARLY_TERMINATION ? 150 : Infinity; // More aggressive for large datasets
-        // Process embeddings in batches with early termination
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            // Parse embedding (try-catch for invalid JSON)
-            let embedding;
-            try {
-                embedding = JSON.parse(row.embedding);
-            }
-            catch {
-                continue; // Skip invalid embeddings
-            }
-            // Compute similarity using optimized function (pre-computed query norm)
-            const score = cosineSimilarityOptimized(queryEmbedding, queryNorm, embedding);
-            // Insert into heap (maintains topK)
-            heapInsert({
-                chunk: {
-                    filepath: row.filepath,
-                    content: row.content,
-                    score,
-                    chunkIndex: row.chunkIndex,
-                    embedding,
-                },
-                score,
-            });
-            processed++;
-            // Early termination: If we have topK results and many consecutive low scores,
-            // likely we've found the best matches
-            if (heap.length >= topK) {
-                const minScore = heap[0].score;
-                if (score < minScore * 0.8) { // Score significantly lower than current min
-                    consecutiveLowScores++;
-                    if (consecutiveLowScores > EARLY_TERMINATION_THRESHOLD) {
-                        break; // Early termination
-                    }
-                }
-                else {
-                    consecutiveLowScores = 0; // Reset counter
-                }
-            }
-            // Limit total processing for very large datasets (early termination optimization)
-            if (processed >= MAX_PROCESS) {
-                break;
-            }
-        }
-        stmt.free();
-        // Extract results from heap and sort descending (highest scores first)
-        const results = heap
-            .sort((a, b) => b.score - a.score)
-            .map(r => r.chunk);
-        return results;
-    }
-}
-//# sourceMappingURL=sqlite-embedding-repository.js.map