@phoenixaihub/graphrag 0.1.0

package/src/db.ts

@@ -0,0 +1,168 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import fs from 'fs';
+
+export interface Entity {
+  id?: number;
+  filePath: string;
+  name: string;
+  kind: 'file' | 'function' | 'class' | 'method' | 'variable' | 'import' | 'export';
+  startLine: number;
+  endLine: number;
+  code: string;
+  language: string;
+}
+
+export interface Edge {
+  id?: number;
+  sourceId: number;
+  targetId: number;
+  relation: 'contains' | 'imports' | 'exports' | 'calls' | 'extends' | 'implements';
+}
+
+export interface Chunk {
+  id?: number;
+  entityId: number;
+  content: string;
+  embedding?: Float64Array | null;
+}
+
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS entities (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  file_path TEXT NOT NULL,
+  name TEXT NOT NULL,
+  kind TEXT NOT NULL,
+  start_line INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  code TEXT NOT NULL,
+  language TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS edges (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  source_id INTEGER NOT NULL REFERENCES entities(id),
+  target_id INTEGER NOT NULL REFERENCES entities(id),
+  relation TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS chunks (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  entity_id INTEGER NOT NULL REFERENCES entities(id),
+  content TEXT NOT NULL,
+  embedding BLOB
+);
+
+CREATE INDEX IF NOT EXISTS idx_entities_name ON entities(name);
+CREATE INDEX IF NOT EXISTS idx_entities_kind ON entities(kind);
+CREATE INDEX IF NOT EXISTS idx_entities_file ON entities(file_path);
+CREATE INDEX IF NOT EXISTS idx_edges_source ON edges(source_id);
+CREATE INDEX IF NOT EXISTS idx_edges_target ON edges(target_id);
+CREATE INDEX IF NOT EXISTS idx_chunks_entity ON chunks(entity_id);
+`;
+
+export class GraphDB {
+  private db: Database.Database;
+
+  constructor(dbPath: string) {
+    const dir = path.dirname(dbPath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    this.db = new Database(dbPath);
+    this.db.pragma('journal_mode = WAL');
+    this.db.exec(SCHEMA);
+  }
+
+  insertEntity(e: Entity): number {
+    const stmt = this.db.prepare(
+      'INSERT INTO entities (file_path, name, kind, start_line, end_line, code, language) VALUES (?, ?, ?, ?, ?, ?, ?)'
+    );
+    const result = stmt.run(e.filePath, e.name, e.kind, e.startLine, e.endLine, e.code, e.language);
+    return Number(result.lastInsertRowid);
+  }
+
+  insertEdge(e: Edge): number {
+    const stmt = this.db.prepare(
+      'INSERT INTO edges (source_id, target_id, relation) VALUES (?, ?, ?)'
+    );
+    const result = stmt.run(e.sourceId, e.targetId, e.relation);
+    return Number(result.lastInsertRowid);
+  }
+
+  insertChunk(c: Chunk): number {
+    const stmt = this.db.prepare(
+      'INSERT INTO chunks (entity_id, content, embedding) VALUES (?, ?, ?)'
+    );
+    const embeddingBlob = c.embedding ? Buffer.from(c.embedding.buffer) : null;
+    const result = stmt.run(c.entityId, c.content, embeddingBlob);
+    return Number(result.lastInsertRowid);
+  }
+
+  getEntity(id: number): Entity | undefined {
+    return this.db.prepare('SELECT * FROM entities WHERE id = ?').get(id) as Entity | undefined;
+  }
+
+  findEntitiesByName(name: string): Entity[] {
+    return this.db.prepare(
+      'SELECT * FROM entities WHERE name LIKE ?'
+    ).all(`%${name}%`) as Entity[];
+  }
+
+  searchEntities(query: string, limit = 5): Entity[] {
+    // Text-based search across name and code
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0) return [];
+    const conditions = terms.map(() => '(LOWER(name) LIKE ? OR LOWER(code) LIKE ?)').join(' AND ');
+    const params = terms.flatMap(t => [`%${t}%`, `%${t}%`]);
+    return this.db.prepare(
+      `SELECT * FROM entities WHERE ${conditions} ORDER BY kind, name LIMIT ?`
+    ).all(...params, limit) as Entity[];
+  }
+
+  getRelated(entityId: number, direction: 'outgoing' | 'incoming' | 'both' = 'both'): Array<{ entity: Entity; relation: string }> {
+    const results: Array<{ entity: Entity; relation: string }> = [];
+    if (direction === 'outgoing' || direction === 'both') {
+      const rows = this.db.prepare(
+        'SELECT e.*, ed.relation FROM entities e JOIN edges ed ON e.id = ed.target_id WHERE ed.source_id = ?'
+      ).all(entityId) as Array<Entity & { relation: string }>;
+      results.push(...rows.map(r => ({ entity: r, relation: r.relation })));
+    }
+    if (direction === 'incoming' || direction === 'both') {
+      const rows = this.db.prepare(
+        'SELECT e.*, ed.relation FROM entities e JOIN edges ed ON e.id = ed.source_id WHERE ed.target_id = ?'
+      ).all(entityId) as Array<Entity & { relation: string }>;
+      results.push(...rows.map(r => ({ entity: r, relation: r.relation })));
+    }
+    return results;
+  }
+
+  getUsages(name: string): Entity[] {
+    return this.db.prepare(
+      `SELECT DISTINCT e2.* FROM entities e1
+       JOIN edges ed ON e1.id = ed.target_id
+       JOIN entities e2 ON e2.id = ed.source_id
+       WHERE e1.name = ? AND ed.relation IN ('calls', 'imports')`
+    ).all(name) as Entity[];
+  }
+
+  clearFile(filePath: string): void {
+    const entities = this.db.prepare('SELECT id FROM entities WHERE file_path = ?').all(filePath) as Array<{ id: number }>;
+    const ids = entities.map(e => e.id);
+    if (ids.length === 0) return;
+    const placeholders = ids.map(() => '?').join(',');
+    this.db.prepare(`DELETE FROM chunks WHERE entity_id IN (${placeholders})`).run(...ids);
+    this.db.prepare(`DELETE FROM edges WHERE source_id IN (${placeholders}) OR target_id IN (${placeholders})`).run(...ids, ...ids);
+    this.db.prepare(`DELETE FROM entities WHERE file_path = ?`).run(filePath);
+  }
+
+  getStats(): { entities: number; edges: number; chunks: number; files: number } {
+    const entities = (this.db.prepare('SELECT COUNT(*) as c FROM entities').get() as { c: number }).c;
+    const edges = (this.db.prepare('SELECT COUNT(*) as c FROM edges').get() as { c: number }).c;
+    const chunks = (this.db.prepare('SELECT COUNT(*) as c FROM chunks').get() as { c: number }).c;
+    const files = (this.db.prepare('SELECT COUNT(DISTINCT file_path) as c FROM entities').get() as { c: number }).c;
+    return { entities, edges, chunks, files };
+  }
+
+  close(): void {
+    this.db.close();
+  }
+}

package/src/embeddings.ts

@@ -0,0 +1,39 @@
+import OpenAI from 'openai';
+
+let client: OpenAI | null = null;
+
+function getClient(): OpenAI {
+  if (!client) {
+    client = new OpenAI();
+  }
+  return client;
+}
+
+export async function getEmbedding(text: string): Promise<number[]> {
+  const openai = getClient();
+  const resp = await openai.embeddings.create({
+    model: 'text-embedding-3-small',
+    input: text.substring(0, 8000),
+  });
+  return resp.data[0].embedding;
+}
+
+export async function getEmbeddings(texts: string[]): Promise<number[][]> {
+  const openai = getClient();
+  const truncated = texts.map(t => t.substring(0, 8000));
+  const resp = await openai.embeddings.create({
+    model: 'text-embedding-3-small',
+    input: truncated,
+  });
+  return resp.data.map(d => d.embedding);
+}
+
+export function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { indexRepo } from './commands/index-repo.js';
+export { queryCode } from './commands/query.js';
+export { serve } from './commands/serve.js';
+export { GraphDB } from './db.js';
+export { parseFile } from './parser.js';

package/src/parser.ts

@@ -0,0 +1,162 @@
+import fs from 'fs';
+import path from 'path';
+import type { Entity, Edge } from './db.js';
+
+// Regex-based parser (no native tree-sitter dependency — works everywhere)
+
+interface ParseResult {
+  entities: Omit<Entity, 'id'>[];
+  edges: Array<{ sourceName: string; targetName: string; relation: Edge['relation'] }>;
+}
+
+const FUNCTION_PATTERNS: Record<string, RegExp[]> = {
+  typescript: [
+    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/gm,
+    /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?\(/gm,
+    /^(?:export\s+)?const\s+(\w+)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[^=])\s*=>/gm,
+  ],
+  python: [
+    /^def\s+(\w+)\s*\(/gm,
+    /^async\s+def\s+(\w+)\s*\(/gm,
+  ],
+};
+
+const CLASS_PATTERNS: Record<string, RegExp[]> = {
+  typescript: [/^(?:export\s+)?(?:abstract\s+)?class\s+(\w+)/gm],
+  python: [/^class\s+(\w+)/gm],
+};
+
+const IMPORT_PATTERNS: Record<string, RegExp[]> = {
+  typescript: [
+    /import\s+(?:{([^}]+)}|(\w+))\s+from\s+['"]([^'"]+)['"]/gm,
+    /import\s+\*\s+as\s+(\w+)\s+from\s+['"]([^'"]+)['"]/gm,
+  ],
+  python: [
+    /^from\s+(\S+)\s+import\s+(.+)$/gm,
+    /^import\s+(\S+)/gm,
+  ],
+};
+
+function detectLanguage(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext)) return 'typescript';
+  if (ext === '.py') return 'python';
+  return 'unknown';
+}
+
+function getLineNumber(source: string, index: number): number {
+  return source.substring(0, index).split('\n').length;
+}
+
+function extractBlock(lines: string[], startLine: number, language: string): { endLine: number; code: string } {
+  // Simple brace/indent block extraction
+  const start = startLine - 1;
+  if (language === 'python') {
+    let end = start + 1;
+    const baseIndent = lines[start]?.search(/\S/) ?? 0;
+    while (end < lines.length) {
+      const line = lines[end];
+      if (line.trim() === '') { end++; continue; }
+      const indent = line.search(/\S/);
+      if (indent <= baseIndent) break;
+      end++;
+    }
+    return { endLine: end, code: lines.slice(start, end).join('\n') };
+  }
+  
+  // Brace-based
+  let braces = 0;
+  let found = false;
+  let end = start;
+  for (let i = start; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === '{') { braces++; found = true; }
+      if (ch === '}') braces--;
+    }
+    end = i + 1;
+    if (found && braces <= 0) break;
+  }
+  if (!found) end = Math.min(start + 1, lines.length);
+  return { endLine: end, code: lines.slice(start, end).join('\n') };
+}
+
+export function parseFile(filePath: string, source?: string): ParseResult {
+  const content = source ?? fs.readFileSync(filePath, 'utf-8');
+  const language = detectLanguage(filePath);
+  if (language === 'unknown') return { entities: [], edges: [] };
+
+  const lines = content.split('\n');
+  const entities: Omit<Entity, 'id'>[] = [];
+  const edgesList: ParseResult['edges'] = [];
+
+  // File entity
+  entities.push({
+    filePath, name: path.basename(filePath), kind: 'file',
+    startLine: 1, endLine: lines.length, code: content.substring(0, 500),
+    language,
+  });
+
+  const langKey = language;
+  
+  // Functions
+  for (const pattern of (FUNCTION_PATTERNS[langKey] ?? [])) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      const startLine = getLineNumber(content, match.index);
+      const block = extractBlock(lines, startLine, language);
+      entities.push({
+        filePath, name, kind: 'function',
+        startLine, endLine: block.endLine, code: block.code,
+        language,
+      });
+      edgesList.push({ sourceName: path.basename(filePath), targetName: name, relation: 'contains' });
+    }
+  }
+
+  // Classes
+  for (const pattern of (CLASS_PATTERNS[langKey] ?? [])) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const name = match[1];
+      const startLine = getLineNumber(content, match.index);
+      const block = extractBlock(lines, startLine, language);
+      entities.push({
+        filePath, name, kind: 'class',
+        startLine, endLine: block.endLine, code: block.code,
+        language,
+      });
+      edgesList.push({ sourceName: path.basename(filePath), targetName: name, relation: 'contains' });
+    }
+  }
+
+  // Imports
+  for (const pattern of (IMPORT_PATTERNS[langKey] ?? [])) {
+    const regex = new RegExp(pattern.source, pattern.flags);
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const startLine = getLineNumber(content, match.index);
+      const importSource = language === 'typescript' ? (match[3] ?? match[2] ?? match[1]) : match[1];
+      const importedNames = language === 'typescript'
+        ? (match[1] ?? match[2] ?? '').split(',').map(s => s.trim()).filter(Boolean)
+        : (match[2] ?? match[1] ?? '').split(',').map(s => s.trim()).filter(Boolean);
+      
+      for (const name of importedNames) {
+        entities.push({
+          filePath, name: name.replace(/\s+as\s+\w+/, ''), kind: 'import',
+          startLine, endLine: startLine, code: match[0],
+          language,
+        });
+        edgesList.push({
+          sourceName: path.basename(filePath),
+          targetName: name.replace(/\s+as\s+\w+/, ''),
+          relation: 'imports',
+        });
+      }
+    }
+  }
+
+  return { entities, edges: edgesList };
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "Node16",
+    "moduleResolution": "Node16",
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}