symbiote-cli 0.1.0

package/dist/src/cortex/repository.js

@@ -0,0 +1,1078 @@
+const CHUNK_SIZE = 500;
+export class CortexRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async upsertFileNode(node) {
+        await this.db.run(`INSERT INTO nodes_file (id, path, hash, language, depth_level, last_indexed)
+             VALUES ($1, $2, $3, $4, $5, $6)
+             ON CONFLICT (id) DO UPDATE SET path = excluded.path, hash = excluded.hash,
+             language = excluded.language, depth_level = excluded.depth_level,
+             last_indexed = excluded.last_indexed`, node.id, node.path, node.hash, node.language, node.depthLevel, node.lastIndexed ? node.lastIndexed.toISOString() : null);
+    }
+    async getFileNode(id) {
+        const rows = await this.db.all('SELECT * FROM nodes_file WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapFileNodeRow(rows[0]);
+    }
+    async getFilesByMaxDepth(maxDepth) {
+        const rows = await this.db.all('SELECT * FROM nodes_file WHERE depth_level < $1', maxDepth);
+        return rows.map((r) => this.mapFileNodeRow(r));
+    }
+    async getAllFileNodes() {
+        const rows = await this.db.all('SELECT * FROM nodes_file');
+        return rows.map((r) => this.mapFileNodeRow(r));
+    }
+    async isFileChanged(id, hash) {
+        const node = await this.getFileNode(id);
+        if (!node)
+            return true;
+        return node.hash !== hash;
+    }
+    async insertFunctionNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 14, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9}, $${offset + 10}, $${offset + 11}, $${offset + 12}, $${offset + 13}, $${offset + 14})`,
+            params: [
+                node.id,
+                node.name,
+                node.qualifiedName,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.isAsync,
+                node.isExported,
+                node.isEntryPoint,
+                node.entryPointScore,
+                node.signature,
+                node.community,
+                node.pageRank,
+                node.betweenness,
+            ],
+        }), `INSERT INTO nodes_function (id, name, qualified_name, file_path, line_start, line_end, is_async, is_exported, is_entry_point, entry_point_score, signature, community, page_rank, betweenness) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertClassNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 10, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9}, $${offset + 10})`,
+            params: [
+                node.id,
+                node.name,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.isAbstract,
+                node.isExported,
+                node.community,
+                node.pageRank,
+                node.betweenness,
+            ],
+        }), `INSERT INTO nodes_class (id, name, file_path, line_start, line_end, is_abstract, is_exported, community, page_rank, betweenness) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertMethodNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 13, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9}, $${offset + 10}, $${offset + 11}, $${offset + 12}, $${offset + 13})`,
+            params: [
+                node.id,
+                node.name,
+                node.className,
+                node.qualifiedName,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.visibility,
+                node.isStatic,
+                node.isAsync,
+                node.community,
+                node.pageRank,
+                node.betweenness,
+            ],
+        }), `INSERT INTO nodes_method (id, name, class_name, qualified_name, file_path, line_start, line_end, visibility, is_static, is_async, community, page_rank, betweenness) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertInterfaceNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 6, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6})`,
+            params: [
+                node.id,
+                node.name,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.isExported,
+            ],
+        }), `INSERT INTO nodes_interface (id, name, file_path, line_start, line_end, is_exported) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertTypeNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 7, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7})`,
+            params: [
+                node.id,
+                node.name,
+                node.kind,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.isExported,
+            ],
+        }), `INSERT INTO nodes_type (id, name, kind, file_path, line_start, line_end, is_exported) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertVariableNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 8, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8})`,
+            params: [
+                node.id,
+                node.name,
+                node.scope,
+                node.filePath,
+                node.lineStart,
+                node.lineEnd,
+                node.isExported,
+                node.inferredType,
+            ],
+        }), `INSERT INTO nodes_variable (id, name, scope, file_path, line_start, line_end, is_exported, inferred_type) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertModuleNodes(nodes) {
+        if (nodes.length === 0)
+            return;
+        await this.batchInsert(nodes, 3, (node, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3})`,
+            params: [node.id, node.path, node.isBarrel],
+        }), `INSERT INTO nodes_module (id, path, is_barrel) VALUES`, 'ON CONFLICT (id) DO NOTHING');
+    }
+    async insertCallsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 9, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.confidence,
+                edge.isDynamic,
+                edge.isAsync,
+                edge.isIndirect,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_calls (source_id, target_id, line, confidence, is_dynamic, is_async, is_indirect, stage, reason) VALUES`);
+    }
+    async insertImportsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 9, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.kind,
+                edge.originalName,
+                edge.alias,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_imports (source_id, target_id, line, kind, original_name, alias, confidence, stage, reason) VALUES`);
+    }
+    async insertExtendsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 6, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_extends (source_id, target_id, line, confidence, stage, reason) VALUES`);
+    }
+    async insertImplementsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 6, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_implements (source_id, target_id, line, confidence, stage, reason) VALUES`);
+    }
+    async insertContainsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 5, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5})`,
+            params: [edge.sourceId, edge.targetId, edge.confidence, edge.stage, edge.reason],
+        }), `INSERT INTO edges_contains (source_id, target_id, confidence, stage, reason) VALUES`);
+    }
+    async insertReturnsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 7, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.returnType,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_returns (source_id, target_id, line, return_type, confidence, stage, reason) VALUES`);
+    }
+    async insertReadsEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 7, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.field,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_reads (source_id, target_id, line, field, confidence, stage, reason) VALUES`);
+    }
+    async insertWritesEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 7, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.line,
+                edge.field,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_writes (source_id, target_id, line, field, confidence, stage, reason) VALUES`);
+    }
+    async insertFlowsToEdges(edges) {
+        if (edges.length === 0)
+            return;
+        await this.batchInsert(edges, 8, (edge, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8})`,
+            params: [
+                edge.sourceId,
+                edge.targetId,
+                edge.parameterIndex,
+                edge.transform,
+                edge.taintLabel,
+                edge.confidence,
+                edge.stage,
+                edge.reason,
+            ],
+        }), `INSERT INTO edges_flows_to (source_id, target_id, parameter_index, transform, taint_label, confidence, stage, reason) VALUES`);
+    }
+    async getFunctionsByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_function WHERE file_path = $1', filePath);
+        return rows.map(this.mapFunctionNodeRow);
+    }
+    async getClassesByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_class WHERE file_path = $1', filePath);
+        return rows.map(this.mapClassNodeRow);
+    }
+    async getMethodsByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_method WHERE file_path = $1', filePath);
+        return rows.map(this.mapMethodNodeRow);
+    }
+    async getInterfacesByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_interface WHERE file_path = $1', filePath);
+        return rows.map(this.mapInterfaceNodeRow);
+    }
+    async getTypesByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_type WHERE file_path = $1', filePath);
+        return rows.map(this.mapTypeNodeRow);
+    }
+    async getVariablesByFile(filePath) {
+        const rows = await this.db.all('SELECT * FROM nodes_variable WHERE file_path = $1', filePath);
+        return rows.map(this.mapVariableNodeRow);
+    }
+    async deleteCallEdgesBySourceIds(sourceIds) {
+        if (sourceIds.length === 0)
+            return;
+        const placeholders = sourceIds.map((_, i) => `$${i + 1}`).join(', ');
+        await this.db.run(`DELETE FROM edges_calls WHERE source_id IN (${placeholders})`, ...sourceIds);
+    }
+    async getCallsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_calls WHERE source_id = $1', sourceId);
+        return rows.map(this.mapCallsEdgeRow);
+    }
+    async getCallsTo(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_calls WHERE target_id = $1', targetId);
+        return rows.map(this.mapCallsEdgeRow);
+    }
+    async getContainedBy(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_contains WHERE source_id = $1', sourceId);
+        return rows.map(this.mapContainsEdgeRow);
+    }
+    async getImportsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_imports WHERE source_id = $1', sourceId);
+        return rows.map(this.mapImportsEdgeRow);
+    }
+    async getImportersOf(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_imports WHERE target_id = $1', targetId);
+        return rows.map(this.mapImportsEdgeRow);
+    }
+    async getImplementsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_implements WHERE source_id = $1', sourceId);
+        return rows.map(this.mapImplementsEdgeRow);
+    }
+    async insertTypeConstraints(constraints) {
+        if (constraints.length === 0)
+            return;
+        const seen = new Set();
+        const deduped = constraints.filter((c) => {
+            const key = `${c.symbolId}\0${c.typeName}\0${c.source}`;
+            if (seen.has(key))
+                return false;
+            seen.add(key);
+            return true;
+        });
+        if (deduped.length === 0)
+            return;
+        await this.batchInsert(deduped, 6, (c, offset) => ({
+            placeholder: `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6})`,
+            params: [c.symbolId, c.typeName, c.source, c.confidence, c.filePath, c.line],
+        }), `INSERT OR IGNORE INTO type_constraints (symbol_id, type_name, source, confidence, file_path, line) VALUES`);
+    }
+    async getTypeConstraints(symbolId) {
+        const rows = await this.db.all('SELECT * FROM type_constraints WHERE symbol_id = $1', symbolId);
+        return rows.map(this.mapTypeConstraintRow);
+    }
+    async getTypeConstraintsByType(typeName) {
+        const rows = await this.db.all('SELECT * FROM type_constraints WHERE type_name = $1', typeName);
+        return rows.map(this.mapTypeConstraintRow);
+    }
+    async deleteTypeConstraintsForFile(filePath) {
+        await this.db.run('DELETE FROM type_constraints WHERE file_path = $1', filePath);
+    }
+    async insertGenericInstantiations(insts) {
+        if (insts.length === 0)
+            return;
+        await this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const inst of insts) {
+                const listLiteral = `[${inst.typeArguments.map((a) => `'${a.replace(/'/g, "''")}'`).join(', ')}]`;
+                await this.db.run(`INSERT INTO generic_instantiations (symbol_id, generic_name, type_arguments, file_path, line)
+                     VALUES ($1, $2, ${listLiteral}::VARCHAR[], $3, $4)`, inst.symbolId, inst.genericName, inst.filePath, inst.line);
+            }
+            await this.db.exec('COMMIT');
+        }
+        catch (err) {
+            await this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+    async getGenericInstantiations(symbolId) {
+        const rows = await this.db.all('SELECT * FROM generic_instantiations WHERE symbol_id = $1', symbolId);
+        return rows.map(this.mapGenericInstantiationRow);
+    }
+    async deleteGenericInstantiationsForFile(filePath) {
+        await this.db.run('DELETE FROM generic_instantiations WHERE file_path = $1', filePath);
+    }
+    async getFlowsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_flows_to WHERE source_id = $1', sourceId);
+        return rows.map(this.mapFlowsToEdgeRow);
+    }
+    async getFlowsTo(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_flows_to WHERE target_id = $1', targetId);
+        return rows.map(this.mapFlowsToEdgeRow);
+    }
+    async getReadsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_reads WHERE source_id = $1', sourceId);
+        return rows.map(this.mapReadsEdgeRow);
+    }
+    async getReadsOf(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_reads WHERE target_id = $1', targetId);
+        return rows.map(this.mapReadsEdgeRow);
+    }
+    async getWritesFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_writes WHERE source_id = $1', sourceId);
+        return rows.map(this.mapWritesEdgeRow);
+    }
+    async getWritesTo(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_writes WHERE target_id = $1', targetId);
+        return rows.map(this.mapWritesEdgeRow);
+    }
+    async getReturnsFrom(sourceId) {
+        const rows = await this.db.all('SELECT * FROM edges_returns WHERE source_id = $1', sourceId);
+        return rows.map(this.mapReturnsEdgeRow);
+    }
+    async getReturnsTo(targetId) {
+        const rows = await this.db.all('SELECT * FROM edges_returns WHERE target_id = $1', targetId);
+        return rows.map(this.mapReturnsEdgeRow);
+    }
+    async getImplementorsOf(interfaceId) {
+        const rows = await this.db.all('SELECT * FROM edges_implements WHERE target_id = $1', interfaceId);
+        return rows.map(this.mapImplementsEdgeRow);
+    }
+    async getReferencesForSymbol(symbolId) {
+        const [callers, importers, extenders, implementors] = await Promise.all([
+            this.getCallsTo(symbolId),
+            this.getImportersOf(symbolId),
+            this.db.all('SELECT * FROM edges_extends WHERE target_id = $1', symbolId),
+            this.db.all('SELECT * FROM edges_implements WHERE target_id = $1', symbolId),
+        ]);
+        return {
+            callers,
+            importers,
+            extenders: extenders.map((r) => this.mapExtendsEdgeRow(r)),
+            implementors: implementors.map(this.mapImplementsEdgeRow),
+        };
+    }
+    async updateCallEdgeConfidence(sourceId, targetId, confidence, reason) {
+        await this.db.run('UPDATE edges_calls SET confidence = $3, reason = $4 WHERE source_id = $1 AND target_id = $2', sourceId, targetId, confidence, reason);
+    }
+    async updateCallEdgeAsync(sourceId, targetId, isAsync) {
+        await this.db.run('UPDATE edges_calls SET is_async = $3 WHERE source_id = $1 AND target_id = $2', sourceId, targetId, isAsync);
+    }
+    async updateEntryPointScore(functionId, score, isEntryPoint) {
+        await this.db.run('UPDATE nodes_function SET entry_point_score = $2, is_entry_point = $3 WHERE id = $1', functionId, score, isEntryPoint);
+    }
+    async updateVariableType(variableId, inferredType) {
+        await this.db.run('UPDATE nodes_variable SET inferred_type = $2 WHERE id = $1', variableId, inferredType);
+    }
+    async deleteFlowEdgesForFile(filePath) {
+        const nodeIds = await this.getNodeIdsForFile(filePath);
+        if (nodeIds.length === 0)
+            return;
+        const placeholders = nodeIds.map((_, i) => `$${i + 1}`).join(', ');
+        const flowTables = ['edges_flows_to', 'edges_reads', 'edges_writes', 'edges_returns'];
+        for (const table of flowTables) {
+            await this.db.run(`DELETE FROM ${table} WHERE source_id IN (${placeholders})`, ...nodeIds);
+        }
+    }
+    async deleteStageEdges(stage, filePath) {
+        const edgeTables = [
+            'edges_calls',
+            'edges_imports',
+            'edges_extends',
+            'edges_implements',
+            'edges_contains',
+            'edges_flows_to',
+            'edges_reads',
+            'edges_writes',
+            'edges_returns',
+        ];
+        if (filePath) {
+            const nodeIds = await this.getNodeIdsForFile(filePath);
+            if (nodeIds.length === 0)
+                return;
+            const placeholders = nodeIds.map((_, i) => `$${i + 2}`).join(', ');
+            for (const table of edgeTables) {
+                await this.db.run(`DELETE FROM ${table} WHERE stage = $1 AND source_id IN (${placeholders})`, stage, ...nodeIds);
+            }
+        }
+        else {
+            for (const table of edgeTables) {
+                await this.db.run(`DELETE FROM ${table} WHERE stage = $1`, stage);
+            }
+        }
+    }
+    async getModuleNode(id) {
+        const rows = await this.db.all('SELECT * FROM nodes_module WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapModuleNodeRow(rows[0]);
+    }
+    async deleteFileData(filePath) {
+        const nodeIds = await this.getNodeIdsForFile(filePath);
+        await this.db.exec('BEGIN TRANSACTION');
+        try {
+            await this.db.run('DELETE FROM nodes_function WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_class WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_method WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_interface WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_type WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_variable WHERE file_path = $1', filePath);
+            await this.db.run('DELETE FROM nodes_file WHERE path = $1', filePath);
+            if (nodeIds.length > 0) {
+                const placeholders = nodeIds.map((_, i) => `$${i + 1}`).join(', ');
+                const edgeTables = [
+                    'edges_calls',
+                    'edges_imports',
+                    'edges_extends',
+                    'edges_implements',
+                    'edges_contains',
+                    'edges_flows_to',
+                    'edges_reads',
+                    'edges_writes',
+                    'edges_returns',
+                ];
+                for (const table of edgeTables) {
+                    await this.db.run(`DELETE FROM ${table} WHERE source_id IN (${placeholders})`, ...nodeIds);
+                    await this.db.run(`DELETE FROM ${table} WHERE target_id IN (${placeholders})`, ...nodeIds);
+                }
+            }
+            await this.db.exec('COMMIT');
+        }
+        catch (err) {
+            await this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+    async getNodeIdsForFile(filePath) {
+        const rows = await this.db.all(`SELECT id FROM nodes_function WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_class WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_method WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_interface WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_type WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_variable WHERE file_path = $1
+             UNION ALL
+             SELECT id FROM nodes_file WHERE path = $1`, filePath);
+        return rows.map((r) => r.id);
+    }
+    async getStats() {
+        const rows = await this.db.all(`SELECT
+                (SELECT COUNT(*) FROM nodes_file) as files,
+                (SELECT COUNT(*) FROM nodes_function) as functions,
+                (SELECT COUNT(*) FROM nodes_class) as classes,
+                (SELECT COUNT(*) FROM nodes_method) as methods,
+                (SELECT COUNT(*) FROM nodes_interface) as interfaces,
+                (SELECT COUNT(*) FROM nodes_type) as types,
+                (SELECT COUNT(*) FROM nodes_variable) as variables,
+                (SELECT COUNT(*) FROM nodes_module) as modules,
+                (SELECT COUNT(*) FROM edges_calls) as calls,
+                (SELECT COUNT(*) FROM edges_imports) as imports,
+                (SELECT COUNT(*) FROM edges_extends) as extends_count,
+                (SELECT COUNT(*) FROM edges_implements) as implements_count,
+                (SELECT COUNT(*) FROM edges_contains) as contains,
+                (SELECT COUNT(*) FROM edges_flows_to) as flows_to,
+                (SELECT COUNT(*) FROM edges_reads) as reads,
+                (SELECT COUNT(*) FROM edges_writes) as writes,
+                (SELECT COUNT(*) FROM edges_returns) as returns,
+                (SELECT COUNT(*) FROM type_constraints) as type_constraints,
+                (SELECT COUNT(*) FROM generic_instantiations) as generic_instantiations`);
+        const row = rows[0];
+        return {
+            files: Number(row.files),
+            functions: Number(row.functions),
+            classes: Number(row.classes),
+            methods: Number(row.methods),
+            interfaces: Number(row.interfaces),
+            types: Number(row.types),
+            variables: Number(row.variables),
+            modules: Number(row.modules),
+            calls: Number(row.calls),
+            imports: Number(row.imports),
+            extends: Number(row.extends_count),
+            implements: Number(row.implements_count),
+            contains: Number(row.contains),
+            flowsTo: Number(row.flows_to),
+            reads: Number(row.reads),
+            writes: Number(row.writes),
+            returns: Number(row.returns),
+            typeConstraints: Number(row.type_constraints),
+            genericInstantiations: Number(row.generic_instantiations),
+        };
+    }
+    async getAllSymbols() {
+        const rows = await this.db.all('SELECT * FROM symbols');
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            filePath: r.file_path,
+            lineStart: r.line_start,
+            lineEnd: r.line_end,
+            kind: r.kind,
+        }));
+    }
+    async getSymbolById(id) {
+        const rows = await this.db.all('SELECT * FROM symbols WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        const r = rows[0];
+        return {
+            id: r.id,
+            name: r.name,
+            filePath: r.file_path,
+            lineStart: r.line_start,
+            lineEnd: r.line_end,
+            kind: r.kind,
+        };
+    }
+    async getSymbolByName(name) {
+        const rows = await this.db.all('SELECT * FROM symbols WHERE name = $1', name);
+        return rows.map((r) => ({
+            id: r.id,
+            name: r.name,
+            filePath: r.file_path,
+            lineStart: r.line_start,
+            lineEnd: r.line_end,
+            kind: r.kind,
+        }));
+    }
+    async getSymbolTable(fileId) {
+        const rows = await this.db.all('SELECT * FROM cortex_meta WHERE key = $1', `symbol_table:${fileId}`);
+        if (rows.length === 0)
+            return null;
+        const entries = JSON.parse(rows[0].value);
+        return new Map(entries);
+    }
+    async setSymbolTable(fileId, table) {
+        const serialized = JSON.stringify([...table.entries()]);
+        await this.db.run(`INSERT INTO cortex_meta (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = excluded.value`, `symbol_table:${fileId}`, serialized);
+    }
+    async insertFlows(flows) {
+        if (flows.length === 0)
+            return;
+        await this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (const flow of flows) {
+                const listLiteral = `[${flow.nodeIds.map((n) => `'${n.replace(/'/g, "''")}'`).join(', ')}]`;
+                await this.db.run(`INSERT INTO cortex_flows (id, name, entry_point_id, node_ids, has_async, has_error_path)
+                     VALUES ($1, $2, $3, ${listLiteral}::VARCHAR[], $4, $5)
+                     ON CONFLICT (id) DO UPDATE SET name = excluded.name, node_ids = excluded.node_ids,
+                     has_async = excluded.has_async, has_error_path = excluded.has_error_path`, flow.id, flow.name, flow.entryPointId, flow.hasAsync, flow.hasErrorPath);
+            }
+            await this.db.exec('COMMIT');
+        }
+        catch (err) {
+            await this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+    async getFlowsByEntryPoint(entryPointId) {
+        const rows = await this.db.all('SELECT * FROM cortex_flows WHERE entry_point_id = $1', entryPointId);
+        return rows.map(this.mapCortexFlowRow);
+    }
+    async deleteFlowsForFile(filePath) {
+        await this.db.run(`DELETE FROM cortex_flows WHERE entry_point_id LIKE 'fn:' || $1 || '%' OR entry_point_id LIKE 'method:' || $1 || '%'`, filePath);
+    }
+    async batchInsert(items, colCount, mapItem, sqlPrefix, sqlSuffix = '') {
+        await this.db.exec('BEGIN TRANSACTION');
+        try {
+            for (let i = 0; i < items.length; i += CHUNK_SIZE) {
+                const chunk = items.slice(i, i + CHUNK_SIZE);
+                const placeholders = [];
+                const params = [];
+                for (let j = 0; j < chunk.length; j++) {
+                    const offset = j * colCount;
+                    const mapped = mapItem(chunk[j], offset);
+                    placeholders.push(mapped.placeholder);
+                    params.push(...mapped.params);
+                }
+                await this.db.run(`${sqlPrefix} ${placeholders.join(', ')}${sqlSuffix ? ' ' + sqlSuffix : ''}`, ...params);
+            }
+            await this.db.exec('COMMIT');
+        }
+        catch (err) {
+            await this.db.exec('ROLLBACK');
+            throw err;
+        }
+    }
+    mapFileNodeRow(row) {
+        return {
+            id: row.id,
+            path: row.path,
+            hash: row.hash,
+            language: row.language,
+            depthLevel: row.depth_level,
+            lastIndexed: row.last_indexed ? new Date(row.last_indexed) : null,
+        };
+    }
+    mapFunctionNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            qualifiedName: row.qualified_name,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            isAsync: row.is_async,
+            isExported: row.is_exported,
+            isEntryPoint: row.is_entry_point,
+            entryPointScore: row.entry_point_score,
+            signature: row.signature,
+            community: row.community,
+            pageRank: row.page_rank,
+            betweenness: row.betweenness,
+        };
+    }
+    mapClassNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            isAbstract: row.is_abstract,
+            isExported: row.is_exported,
+            community: row.community,
+            pageRank: row.page_rank,
+            betweenness: row.betweenness,
+        };
+    }
+    mapMethodNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            className: row.class_name,
+            qualifiedName: row.qualified_name,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            visibility: row.visibility,
+            isStatic: row.is_static,
+            isAsync: row.is_async,
+            community: row.community,
+            pageRank: row.page_rank,
+            betweenness: row.betweenness,
+        };
+    }
+    mapInterfaceNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            isExported: row.is_exported,
+        };
+    }
+    mapTypeNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            kind: row.kind,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            isExported: row.is_exported,
+        };
+    }
+    mapVariableNodeRow(row) {
+        return {
+            id: row.id,
+            name: row.name,
+            scope: row.scope,
+            filePath: row.file_path,
+            lineStart: row.line_start,
+            lineEnd: row.line_end,
+            isExported: row.is_exported,
+            inferredType: row.inferred_type,
+        };
+    }
+    mapModuleNodeRow(row) {
+        return {
+            id: row.id,
+            path: row.path,
+            isBarrel: row.is_barrel,
+        };
+    }
+    mapCallsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            confidence: row.confidence,
+            isDynamic: row.is_dynamic,
+            isAsync: row.is_async,
+            isIndirect: row.is_indirect,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapImportsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            kind: row.kind,
+            originalName: row.original_name,
+            alias: row.alias,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapExtendsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapImplementsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapContainsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapFlowsToEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            parameterIndex: row.parameter_index,
+            transform: row.transform,
+            taintLabel: row.taint_label,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapReadsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            field: row.field,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapWritesEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            field: row.field,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapReturnsEdgeRow(row) {
+        return {
+            sourceId: row.source_id,
+            targetId: row.target_id,
+            line: row.line,
+            returnType: row.return_type,
+            confidence: row.confidence,
+            stage: row.stage,
+            reason: row.reason,
+        };
+    }
+    mapTypeConstraintRow(row) {
+        return {
+            symbolId: row.symbol_id,
+            typeName: row.type_name,
+            source: row.source,
+            confidence: row.confidence,
+            filePath: row.file_path,
+            line: row.line,
+        };
+    }
+    mapGenericInstantiationRow(row) {
+        const rawArgs = row.type_arguments;
+        const typeArguments = Array.isArray(rawArgs)
+            ? rawArgs
+            : Array.from(rawArgs.items);
+        return {
+            symbolId: row.symbol_id,
+            genericName: row.generic_name,
+            typeArguments,
+            filePath: row.file_path,
+            line: row.line,
+        };
+    }
+    // --- Single-item insert/get methods for topology tests ---
+    async insertFunction(node) {
+        await this.insertFunctionNodes([node]);
+    }
+    async getFunction(id) {
+        const rows = await this.db.all('SELECT * FROM nodes_function WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapFunctionNodeRow(rows[0]);
+    }
+    async insertClass(node) {
+        await this.insertClassNodes([node]);
+    }
+    async getClass(id) {
+        const rows = await this.db.all('SELECT * FROM nodes_class WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapClassNodeRow(rows[0]);
+    }
+    async insertMethod(node) {
+        await this.insertMethodNodes([node]);
+    }
+    async getMethod(id) {
+        const rows = await this.db.all('SELECT * FROM nodes_method WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapMethodNodeRow(rows[0]);
+    }
+    async insertFileNode(node) {
+        await this.upsertFileNode({
+            id: node.id,
+            path: node.path,
+            hash: null,
+            language: node.language,
+            depthLevel: node.depthLevel,
+            lastIndexed: null,
+        });
+    }
+    // --- Topology write-back methods ---
+    async updateNodeMetrics(nodeId, metrics) {
+        const table = this.nodeTableForId(nodeId);
+        if (!table)
+            return;
+        await this.db.run(`UPDATE ${table} SET community = $1, page_rank = $2, betweenness = $3 WHERE id = $4`, metrics.community, metrics.pageRank, metrics.betweenness, nodeId);
+    }
+    async updateNodeMetricsBatch(updates) {
+        for (const update of updates) {
+            await this.updateNodeMetrics(update.nodeId, update);
+        }
+    }
+    // --- Generic meta CRUD ---
+    async getMeta(key) {
+        const rows = await this.db.all('SELECT * FROM cortex_meta WHERE key = $1', key);
+        if (rows.length === 0)
+            return null;
+        return rows[0].value;
+    }
+    async setMeta(key, value) {
+        await this.db.run('INSERT INTO cortex_meta (key, value) VALUES ($1, $2) ON CONFLICT (key) DO UPDATE SET value = excluded.value', key, value);
+    }
+    // --- Topology queries ---
+    async getMaxDepthLevel() {
+        const rows = await this.db.all('SELECT MAX(depth_level) as max_depth FROM nodes_file');
+        if (rows.length === 0)
+            return 0;
+        return Number(rows[0].max_depth) || 0;
+    }
+    async getAllFunctions() {
+        const rows = await this.db.all('SELECT * FROM nodes_function');
+        return rows.map((r) => this.mapFunctionNodeRow(r));
+    }
+    async getAllClasses() {
+        const rows = await this.db.all('SELECT * FROM nodes_class');
+        return rows.map((r) => this.mapClassNodeRow(r));
+    }
+    async getAllMethods() {
+        const rows = await this.db.all('SELECT * FROM nodes_method');
+        return rows.map((r) => this.mapMethodNodeRow(r));
+    }
+    // --- Single-item flow CRUD ---
+    async insertFlow(flow) {
+        await this.insertFlows([flow]);
+    }
+    async getFlow(id) {
+        const rows = await this.db.all('SELECT * FROM cortex_flows WHERE id = $1', id);
+        if (rows.length === 0)
+            return null;
+        return this.mapCortexFlowRow(rows[0]);
+    }
+    async getAllFlows() {
+        const rows = await this.db.all('SELECT * FROM cortex_flows');
+        return rows.map((r) => this.mapCortexFlowRow(r));
+    }
+    async deleteAllFlows() {
+        await this.db.run('DELETE FROM cortex_flows');
+    }
+    // --- Temporal snapshot CRUD ---
+    async insertTemporalSnapshot(snapshot) {
+        await this.db.run(`INSERT INTO cortex_temporal_snapshots
+             (commit_hash, timestamp, node_counts, edge_counts, community_hash, top_pagerank, hotspot_rankings)
+             VALUES ($1, $2, $3, $4, $5, $6, $7)`, snapshot.commitHash, snapshot.timestamp.toISOString(), JSON.stringify(snapshot.nodeCounts), JSON.stringify(snapshot.edgeCounts), snapshot.communityHash, JSON.stringify(snapshot.topPagerank), JSON.stringify(snapshot.hotspotRankings));
+    }
+    async getTemporalSnapshots(limit) {
+        const rows = await this.db.all('SELECT * FROM cortex_temporal_snapshots ORDER BY timestamp DESC LIMIT $1', limit);
+        return rows.map((r) => this.mapSnapshotRow(r));
+    }
+    // --- Private helpers ---
+    nodeTableForId(nodeId) {
+        if (nodeId.startsWith('fn:'))
+            return 'nodes_function';
+        if (nodeId.startsWith('class:'))
+            return 'nodes_class';
+        if (nodeId.startsWith('method:'))
+            return 'nodes_method';
+        if (nodeId.startsWith('iface:'))
+            return 'nodes_interface';
+        if (nodeId.startsWith('type:'))
+            return 'nodes_type';
+        if (nodeId.startsWith('var:'))
+            return 'nodes_variable';
+        if (nodeId.startsWith('file:'))
+            return 'nodes_file';
+        if (nodeId.startsWith('module:'))
+            return 'nodes_module';
+        return null;
+    }
+    mapCortexFlowRow(row) {
+        const rawIds = row.node_ids;
+        const nodeIds = Array.isArray(rawIds)
+            ? rawIds
+            : Array.from(rawIds.items);
+        return {
+            id: row.id,
+            name: row.name,
+            entryPointId: row.entry_point_id,
+            nodeIds,
+            hasAsync: row.has_async,
+            hasErrorPath: row.has_error_path,
+        };
+    }
+    mapSnapshotRow(row) {
+        return {
+            commitHash: row.commit_hash,
+            timestamp: new Date(row.timestamp),
+            nodeCounts: typeof row.node_counts === 'string'
+                ? JSON.parse(row.node_counts)
+                : row.node_counts,
+            edgeCounts: typeof row.edge_counts === 'string'
+                ? JSON.parse(row.edge_counts)
+                : row.edge_counts,
+            communityHash: row.community_hash,
+            topPagerank: typeof row.top_pagerank === 'string'
+                ? JSON.parse(row.top_pagerank)
+                : row.top_pagerank,
+            hotspotRankings: typeof row.hotspot_rankings === 'string'
+                ? JSON.parse(row.hotspot_rankings)
+                : row.hotspot_rankings,
+        };
+    }
+}
+//# sourceMappingURL=repository.js.map