codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/storage/sqlite-knowledge-graph-repository.js

@@ -1,417 +0,0 @@
-/**
- * Infrastructure: SQLiteKnowledgeGraphRepository
- * SQLite implementation of knowledge graph 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', 'knowledge-graph.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'knowledge-graph.sqlite');
-}
-export class SQLiteKnowledgeGraphRepository {
-    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 nodes table
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS knowledge_nodes (
-        id TEXT PRIMARY KEY,
-        codebaseId TEXT NOT NULL,
-        type TEXT NOT NULL,
-        label TEXT NOT NULL,
-        content TEXT NOT NULL,
-        metadata TEXT,
-        createdAt INTEGER NOT NULL,
-        lastUpdated INTEGER NOT NULL
-      )
-    `);
-        // Create edges table
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS knowledge_edges (
-        id TEXT PRIMARY KEY,
-        fromNodeId TEXT NOT NULL,
-        toNodeId TEXT NOT NULL,
-        type TEXT NOT NULL,
-        weight REAL,
-        metadata TEXT,
-        createdAt INTEGER NOT NULL,
-        FOREIGN KEY (fromNodeId) REFERENCES knowledge_nodes(id),
-        FOREIGN KEY (toNodeId) REFERENCES knowledge_nodes(id)
-      )
-    `);
-        // Create indexes
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_codebase ON knowledge_nodes(codebaseId)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_type ON knowledge_nodes(codebaseId, type)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_from_node ON knowledge_edges(fromNodeId)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_to_node ON knowledge_edges(toNodeId)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_edge_type ON knowledge_edges(type)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_edge_codebase ON knowledge_edges(fromNodeId, toNodeId)`);
-        return this.db;
-    }
-    async storeNode(node) {
-        const db = await this.getDb();
-        const id = node.id || randomUUID();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO knowledge_nodes
-      (id, codebaseId, type, label, content, metadata, createdAt, lastUpdated)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run([
-            id,
-            node.codebaseId,
-            node.type,
-            node.label,
-            node.content,
-            JSON.stringify(node.metadata ?? {}),
-            node.createdAt.getTime(),
-            node.lastUpdated.getTime(),
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getNodeById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM knowledge_nodes WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return this.mapRowToNode(row);
-    }
-    async findNodesByCodebase(codebaseId, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_nodes
-      WHERE codebaseId = ?
-      ORDER BY lastUpdated DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMapNodes(stmt);
-    }
-    async findNodesByType(codebaseId, type, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_nodes
-      WHERE codebaseId = ? AND type = ?
-      ORDER BY lastUpdated DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, type, limit]);
-        return this.executeAndMapNodes(stmt);
-    }
-    async searchNodes(codebaseId, query, limit = 50) {
-        const db = await this.getDb();
-        const searchTerm = `%${query}%`;
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_nodes
-      WHERE codebaseId = ?
-        AND (label LIKE ? OR content LIKE ?)
-      ORDER BY lastUpdated DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, searchTerm, searchTerm, limit]);
-        return this.executeAndMapNodes(stmt);
-    }
-    async updateNode(node) {
-        if (!node.id) {
-            throw new Error('Node ID required for update');
-        }
-        await this.storeNode(node); // INSERT OR REPLACE handles update
-    }
-    async deleteNode(id) {
-        const db = await this.getDb();
-        // Delete edges first (foreign key constraints)
-        const deleteEdgesStmt = db.prepare(`
-      DELETE FROM knowledge_edges
-      WHERE fromNodeId = ? OR toNodeId = ?
-    `);
-        deleteEdgesStmt.run([id, id]);
-        deleteEdgesStmt.free();
-        // Delete node
-        const deleteNodeStmt = db.prepare('DELETE FROM knowledge_nodes WHERE id = ?');
-        deleteNodeStmt.run([id]);
-        deleteNodeStmt.free();
-        this.saveDb();
-    }
-    async storeEdge(edge) {
-        const db = await this.getDb();
-        const id = edge.id || randomUUID();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO knowledge_edges
-      (id, fromNodeId, toNodeId, type, weight, metadata, createdAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run([
-            id,
-            edge.fromNodeId,
-            edge.toNodeId,
-            edge.type,
-            edge.weight ?? null,
-            JSON.stringify(edge.metadata ?? {}),
-            edge.createdAt.getTime(),
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getEdgeById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM knowledge_edges WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return this.mapRowToEdge(row);
-    }
-    async findEdgesByCodebase(codebaseId, limit = 1000) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT e.* FROM knowledge_edges e
-      INNER JOIN knowledge_nodes n1 ON e.fromNodeId = n1.id
-      WHERE n1.codebaseId = ?
-      ORDER BY e.createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMapEdges(stmt);
-    }
-    async findEdgesByType(codebaseId, type, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT e.* FROM knowledge_edges e
-      INNER JOIN knowledge_nodes n1 ON e.fromNodeId = n1.id
-      WHERE n1.codebaseId = ? AND e.type = ?
-      ORDER BY e.createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, type, limit]);
-        return this.executeAndMapEdges(stmt);
-    }
-    async findEdgesFromNode(nodeId, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_edges
-      WHERE fromNodeId = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([nodeId, limit]);
-        return this.executeAndMapEdges(stmt);
-    }
-    async findEdgesToNode(nodeId, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_edges
-      WHERE toNodeId = ?
-      ORDER BY createdAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([nodeId, limit]);
-        return this.executeAndMapEdges(stmt);
-    }
-    async findEdgesBetween(fromNodeId, toNodeId) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_edges
-      WHERE fromNodeId = ? AND toNodeId = ?
-    `);
-        stmt.bind([fromNodeId, toNodeId]);
-        return this.executeAndMapEdges(stmt);
-    }
-    async updateEdge(edge) {
-        if (!edge.id) {
-            throw new Error('Edge ID required for update');
-        }
-        await this.storeEdge(edge); // INSERT OR REPLACE handles update
-    }
-    async deleteEdge(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('DELETE FROM knowledge_edges WHERE id = ?');
-        stmt.run([id]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getGraphByCodebase(codebaseId) {
-        const nodes = await this.findNodesByCodebase(codebaseId);
-        const edges = await this.findEdgesByCodebase(codebaseId);
-        // Calculate metadata
-        const nodeTypes = {};
-        const relationshipTypes = {};
-        for (const node of nodes) {
-            nodeTypes[node.type] = (nodeTypes[node.type] || 0) + 1;
-        }
-        for (const edge of edges) {
-            relationshipTypes[edge.type] = (relationshipTypes[edge.type] || 0) + 1;
-        }
-        const metadata = {
-            nodeCount: nodes.length,
-            edgeCount: edges.length,
-            nodeTypes,
-            relationshipTypes,
-        };
-        return {
-            codebaseId,
-            nodes,
-            edges,
-            metadata,
-            createdAt: nodes.length > 0 ? nodes[0].createdAt : new Date(),
-            lastUpdated: nodes.length > 0 ? nodes[nodes.length - 1].lastUpdated : new Date(),
-        };
-    }
-    async getNeighbors(nodeId, direction = 'both') {
-        const db = await this.getDb();
-        const nodeIds = new Set();
-        if (direction === 'out' || direction === 'both') {
-            const outEdges = await this.findEdgesFromNode(nodeId);
-            outEdges.forEach(edge => nodeIds.add(edge.toNodeId));
-        }
-        if (direction === 'in' || direction === 'both') {
-            const inEdges = await this.findEdgesToNode(nodeId);
-            inEdges.forEach(edge => nodeIds.add(edge.fromNodeId));
-        }
-        const neighbors = [];
-        for (const id of nodeIds) {
-            const node = await this.getNodeById(id);
-            if (node) {
-                neighbors.push(node);
-            }
-        }
-        return neighbors;
-    }
-    async getNodesWithinHops(nodeId, maxHops) {
-        const visited = new Set();
-        const result = [];
-        const queue = [{ nodeId, hops: 0 }];
-        while (queue.length > 0) {
-            const { nodeId: currentId, hops } = queue.shift();
-            if (visited.has(currentId) || hops > maxHops) {
-                continue;
-            }
-            visited.add(currentId);
-            const node = await this.getNodeById(currentId);
-            if (node) {
-                result.push(node);
-            }
-            if (hops < maxHops) {
-                const neighbors = await this.getNeighbors(currentId);
-                for (const neighbor of neighbors) {
-                    if (neighbor.id && !visited.has(neighbor.id)) {
-                        queue.push({ nodeId: neighbor.id, hops: hops + 1 });
-                    }
-                }
-            }
-        }
-        return result;
-    }
-    async findShortestPath(fromNodeId, toNodeId) {
-        // BFS to find shortest path
-        const visited = new Set();
-        const queue = [{ nodeId: fromNodeId, path: [fromNodeId] }];
-        while (queue.length > 0) {
-            const { nodeId: currentId, path } = queue.shift();
-            if (visited.has(currentId)) {
-                continue;
-            }
-            visited.add(currentId);
-            if (currentId === toNodeId) {
-                // Found path, return nodes
-                const nodes = [];
-                for (const id of path) {
-                    const node = await this.getNodeById(id);
-                    if (node) {
-                        nodes.push(node);
-                    }
-                }
-                return nodes;
-            }
-            const neighbors = await this.getNeighbors(currentId, 'out');
-            for (const neighbor of neighbors) {
-                if (neighbor.id && !visited.has(neighbor.id)) {
-                    queue.push({ nodeId: neighbor.id, path: [...path, neighbor.id] });
-                }
-            }
-        }
-        return null; // No path found
-    }
-    mapRowToNode(row) {
-        return {
-            id: row.id,
-            codebaseId: row.codebaseId,
-            type: row.type,
-            label: row.label,
-            content: row.content,
-            metadata: JSON.parse(row.metadata ?? '{}'),
-            createdAt: new Date(row.createdAt),
-            lastUpdated: new Date(row.lastUpdated),
-        };
-    }
-    mapRowToEdge(row) {
-        return {
-            id: row.id,
-            fromNodeId: row.fromNodeId,
-            toNodeId: row.toNodeId,
-            type: row.type,
-            weight: row.weight ?? undefined,
-            metadata: JSON.parse(row.metadata ?? '{}'),
-            createdAt: new Date(row.createdAt),
-        };
-    }
-    executeAndMapNodes(stmt) {
-        const nodes = [];
-        while (stmt.step()) {
-            nodes.push(this.mapRowToNode(stmt.getAsObject()));
-        }
-        stmt.free();
-        return nodes;
-    }
-    executeAndMapEdges(stmt) {
-        const edges = [];
-        while (stmt.step()) {
-            edges.push(this.mapRowToEdge(stmt.getAsObject()));
-        }
-        stmt.free();
-        return edges;
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-}
-//# sourceMappingURL=sqlite-knowledge-graph-repository.js.map

package/dist/infrastructure/storage/sqlite-knowledge-preservation-repository.js

@@ -1,230 +0,0 @@
-/**
- * Infrastructure: SQLiteKnowledgePreservationRepository
- * SQLite implementation of knowledge preservation 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', 'knowledge_preservation.sqlite');
-    }
-    return join(process.cwd(), 'agent', 'data', 'knowledge_preservation.sqlite');
-}
-export class SQLiteKnowledgePreservationRepository {
-    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 knowledge preservation table
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS knowledge_preservation (
-        id TEXT PRIMARY KEY,
-        codebaseId TEXT NOT NULL,
-        type TEXT NOT NULL,
-        title TEXT NOT NULL,
-        content TEXT NOT NULL,
-        sourceType TEXT NOT NULL,
-        sourceFilepath TEXT,
-        sourceLineStart INTEGER,
-        sourceLineEnd INTEGER,
-        sourceContext TEXT,
-        relevanceScore REAL,
-        metadata TEXT,
-        extractedAt INTEGER NOT NULL
-      )
-    `);
-        // Create indexes
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_codebase ON knowledge_preservation(codebaseId)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_type ON knowledge_preservation(codebaseId, type)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_extracted ON knowledge_preservation(codebaseId, extractedAt DESC)`);
-        this.db.run(`CREATE INDEX IF NOT EXISTS idx_relevance ON knowledge_preservation(codebaseId, relevanceScore DESC)`);
-        return this.db;
-    }
-    saveDb() {
-        if (!this.db)
-            return;
-        const data = this.db.export();
-        const buffer = Buffer.from(data);
-        writeFileSync(this.dbPath, buffer);
-    }
-    async store(knowledge) {
-        const db = await this.getDb();
-        const id = knowledge.id || randomUUID();
-        const extractedAt = knowledge.extractedAt.getTime();
-        const stmt = db.prepare(`
-      INSERT OR REPLACE INTO knowledge_preservation
-      (id, codebaseId, type, title, content, sourceType, sourceFilepath,
-       sourceLineStart, sourceLineEnd, sourceContext, relevanceScore, metadata, extractedAt)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `);
-        stmt.run([
-            id,
-            knowledge.codebaseId,
-            knowledge.type,
-            knowledge.title,
-            knowledge.content,
-            knowledge.source.type,
-            knowledge.source.filepath ?? null,
-            knowledge.source.lineNumbers?.start ?? null,
-            knowledge.source.lineNumbers?.end ?? null,
-            knowledge.source.context ?? null,
-            knowledge.relevanceScore ?? null,
-            JSON.stringify(knowledge.metadata ?? {}),
-            extractedAt,
-        ]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getById(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM knowledge_preservation WHERE id = ?');
-        stmt.bind([id]);
-        if (!stmt.step()) {
-            stmt.free();
-            return null;
-        }
-        const row = stmt.getAsObject();
-        stmt.free();
-        return this.mapRowToKnowledge(row);
-    }
-    async findByCodebase(codebaseId, limit = 100) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_preservation
-      WHERE codebaseId = ?
-      ORDER BY extractedAt 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 knowledge_preservation
-      WHERE codebaseId = ? AND type = ?
-      ORDER BY extractedAt 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 knowledge_preservation
-      WHERE codebaseId = ?
-        AND (title LIKE ? OR content LIKE ?)
-      ORDER BY relevanceScore DESC, extractedAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, searchTerm, searchTerm, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async findByTags(codebaseId, tags, limit = 50) {
-        const db = await this.getDb();
-        const tagConditions = tags.map(() => 'json_extract(metadata, "$.tags") LIKE ?').join(' OR ');
-        const searchTerms = tags.map(tag => `%"${tag}"%`);
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_preservation
-      WHERE codebaseId = ?
-        AND (${tagConditions})
-      ORDER BY extractedAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, ...searchTerms, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async update(knowledge) {
-        if (!knowledge.id) {
-            throw new Error('Knowledge ID required for update');
-        }
-        await this.store(knowledge); // INSERT OR REPLACE handles update
-    }
-    async delete(id) {
-        const db = await this.getDb();
-        const stmt = db.prepare('DELETE FROM knowledge_preservation WHERE id = ?');
-        stmt.run([id]);
-        stmt.free();
-        this.saveDb();
-    }
-    async getMostAccessed(codebaseId, limit = 20) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_preservation
-      WHERE codebaseId = ?
-        AND json_extract(metadata, "$.usageCount") > 0
-      ORDER BY json_extract(metadata, "$.usageCount") DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMap(stmt);
-    }
-    async getRecent(codebaseId, limit = 20) {
-        const db = await this.getDb();
-        const stmt = db.prepare(`
-      SELECT * FROM knowledge_preservation
-      WHERE codebaseId = ?
-      ORDER BY extractedAt DESC
-      LIMIT ?
-    `);
-        stmt.bind([codebaseId, limit]);
-        return this.executeAndMap(stmt);
-    }
-    mapRowToKnowledge(row) {
-        const metadata = JSON.parse(row.metadata ?? '{}');
-        return {
-            id: row.id,
-            codebaseId: row.codebaseId,
-            type: row.type,
-            title: row.title,
-            content: row.content,
-            source: {
-                type: row.sourceType,
-                filepath: row.sourceFilepath ?? undefined,
-                lineNumbers: (row.sourceLineStart !== null && row.sourceLineEnd !== null)
-                    ? { start: row.sourceLineStart, end: row.sourceLineEnd }
-                    : undefined,
-                context: row.sourceContext ?? undefined,
-            },
-            extractedAt: new Date(row.extractedAt),
-            relevanceScore: row.relevanceScore ?? undefined,
-            metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
-        };
-    }
-    executeAndMap(stmt) {
-        const knowledge = [];
-        while (stmt.step()) {
-            knowledge.push(this.mapRowToKnowledge(stmt.getAsObject()));
-        }
-        stmt.free();
-        return knowledge;
-    }
-}
-//# sourceMappingURL=sqlite-knowledge-preservation-repository.js.map