claude-brain 0.30.2 → 0.30.3

package/src/code-intelligence/indexer.ts

@@ -1,352 +1,352 @@
-import { Database } from 'bun:sqlite'
-import { readdir, stat } from 'node:fs/promises'
-import { join, relative, extname } from 'node:path'
-import { createHash } from 'node:crypto'
-import type { Logger } from 'pino'
-import type { CodeParser } from './parser'
-import type { IndexResult, IndexStats, ParsedFile } from './types'
-import { createCodeSchema } from './schema'
-
-const SKIP_DIRS = new Set([
-  'node_modules', '.git', 'dist', 'build', '__pycache__',
-  '.venv', 'target', '.cache', 'coverage', '.turbo', '.output', 'vendor',
-])
-
-const SKIP_FILES = new Set([
-  'package-lock.json', 'yarn.lock', 'bun.lockb', 'pnpm-lock.yaml', '.DS_Store',
-])
-
-const MAX_FILE_SIZE = 500 * 1024 // 500KB
-
-const SUPPORTED_EXTENSIONS = new Set([
-  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
-  '.py', '.go', '.rs', '.vue',
-  '.html', '.css', '.json', '.yaml', '.yml',
-])
-
-const BATCH_SIZE = 100
-
-export class CodeIndexer {
-  private db: Database
-  private parser: CodeParser
-  private logger: Logger
-
-  constructor(db: Database, parser: CodeParser, logger: Logger) {
-    this.db = db
-    this.parser = parser
-    this.logger = logger.child({ component: 'code-indexer' })
-  }
-
-  async initialize(): Promise<void> {
-    createCodeSchema(this.db)
-    this.logger.info('Code intelligence schema initialized')
-  }
-
-  async indexProject(projectPath: string, projectName: string): Promise<IndexResult> {
-    const startTime = Date.now()
-    const errors: string[] = []
-    let filesIndexed = 0
-    let filesSkipped = 0
-    let symbolsFound = 0
-
-    this.logger.info({ projectPath, projectName }, 'Starting project index')
-
-    // Collect all eligible files
-    const files = await this.collectFiles(projectPath)
-    this.logger.info({ fileCount: files.length }, 'Files collected for indexing')
-
-    // Process in batches
-    for (let i = 0; i < files.length; i += BATCH_SIZE) {
-      const batch = files.slice(i, i + BATCH_SIZE)
-      this.db.run('BEGIN TRANSACTION')
-      try {
-        for (const filePath of batch) {
-          try {
-            const result = await this.indexSingleFile(filePath, projectPath, projectName)
-            if (result.skipped) {
-              filesSkipped++
-            } else {
-              filesIndexed++
-              symbolsFound += result.symbolCount
-            }
-          } catch (error) {
-            const msg = `Failed to index ${filePath}: ${error instanceof Error ? error.message : String(error)}`
-            errors.push(msg)
-            this.logger.warn({ filePath, error }, 'Failed to index file')
-          }
-        }
-        this.db.run('COMMIT')
-      } catch (error) {
-        this.db.run('ROLLBACK')
-        const msg = `Batch failed at offset ${i}: ${error instanceof Error ? error.message : String(error)}`
-        errors.push(msg)
-        this.logger.error({ error, batchOffset: i }, 'Batch transaction failed')
-      }
-    }
-
-    const durationMs = Date.now() - startTime
-    this.logger.info(
-      { filesIndexed, filesSkipped, symbolsFound, durationMs, errors: errors.length },
-      'Project indexing complete'
-    )
-
-    return {
-      project: projectName,
-      filesIndexed,
-      filesSkipped,
-      symbolsFound,
-      durationMs,
-      errors,
-    }
-  }
-
-  async indexFile(filePath: string, projectName: string): Promise<void> {
-    this.db.run('BEGIN TRANSACTION')
-    try {
-      // Clear existing data for this file
-      this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, filePath])
-      this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, filePath])
-      this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, filePath])
-
-      const content = await Bun.file(filePath).text()
-      const hash = createHash('sha256').update(content).digest('hex')
-      const parsed = await this.parser.parseFile(filePath, content)
-
-      this.storeFile(parsed, projectName, hash)
-      this.storeSymbols(parsed, projectName)
-      this.storeDependencies(parsed, projectName)
-
-      this.db.run('COMMIT')
-      this.logger.debug({ filePath, symbols: parsed.symbols.length }, 'File re-indexed')
-    } catch (error) {
-      this.db.run('ROLLBACK')
-      throw error
-    }
-  }
-
-  async clearProject(projectName: string): Promise<void> {
-    this.db.run('BEGIN TRANSACTION')
-    try {
-      this.db.run('DELETE FROM code_symbols WHERE project = ?', [projectName])
-      this.db.run('DELETE FROM code_dependencies WHERE project = ?', [projectName])
-      this.db.run('DELETE FROM code_files WHERE project = ?', [projectName])
-      this.db.run('COMMIT')
-      this.logger.info({ projectName }, 'Project data cleared')
-    } catch (error) {
-      this.db.run('ROLLBACK')
-      throw error
-    }
-  }
-
-  getStats(projectName: string): IndexStats {
-    const fileRow = this.db.query(
-      'SELECT COUNT(*) as cnt FROM code_files WHERE project = ?'
-    ).get(projectName) as { cnt: number } | null
-
-    const symbolRow = this.db.query(
-      'SELECT COUNT(*) as cnt FROM code_symbols WHERE project = ?'
-    ).get(projectName) as { cnt: number } | null
-
-    const lastRow = this.db.query(
-      'SELECT MAX(last_indexed) as last_indexed FROM code_files WHERE project = ?'
-    ).get(projectName) as { last_indexed: string | null } | null
-
-    return {
-      project: projectName,
-      filesIndexed: fileRow?.cnt ?? 0,
-      totalSymbols: symbolRow?.cnt ?? 0,
-      lastIndexed: lastRow?.last_indexed ?? null,
-      staleFiles: 0, // Could be computed by comparing file hashes
-    }
-  }
-
-  generateFileSummary(parsed: ParsedFile): string {
-    const exported = parsed.symbols.filter(s => s.exported)
-    if (exported.length === 0) {
-      return `${parsed.language} file, ${parsed.lineCount} lines`
-    }
-
-    const grouped = new Map<string, string[]>()
-    for (const sym of exported) {
-      const existing = grouped.get(sym.type) ?? []
-      existing.push(sym.name)
-      grouped.set(sym.type, existing)
-    }
-
-    const parts: string[] = []
-    for (const [type, names] of grouped) {
-      if (names.length <= 3) {
-        parts.push(`${names.join(', ')} (${type})`)
-      } else {
-        parts.push(`${names.slice(0, 3).join(', ')} +${names.length - 3} (${type})`)
-      }
-    }
-
-    return parts.join(' — ')
-  }
-
-  // ─── Private Helpers ──────────────────────────────────────
-
-  private async collectFiles(dirPath: string): Promise<string[]> {
-    const files: string[] = []
-    await this.walkDirectory(dirPath, files)
-    if (files.length === 0) {
-      this.logger.warn({ dirPath }, 'collectFiles returned 0 files — trying fallback without withFileTypes')
-      await this.walkDirectoryFallback(dirPath, files)
-    }
-    return files
-  }
-
-  private async walkDirectory(dirPath: string, files: string[]): Promise<void> {
-    let entries
-    try {
-      entries = await readdir(dirPath, { withFileTypes: true })
-    } catch (error) {
-      this.logger.debug({ dirPath, error: error instanceof Error ? error.message : String(error) }, 'Cannot read directory')
-      return
-    }
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (!SKIP_DIRS.has(entry.name)) {
-          await this.walkDirectory(join(dirPath, entry.name), files)
-        }
-      } else if (entry.isFile()) {
-        if (SKIP_FILES.has(entry.name)) continue
-        const ext = extname(entry.name).toLowerCase()
-        if (!SUPPORTED_EXTENSIONS.has(ext)) continue
-        files.push(join(dirPath, entry.name))
-      }
-    }
-  }
-
-  /** Fallback walker that uses readdir (names only) + stat — works on all platforms */
-  private async walkDirectoryFallback(dirPath: string, files: string[]): Promise<void> {
-    let names: string[]
-    try {
-      names = await readdir(dirPath)
-    } catch (error) {
-      this.logger.debug({ dirPath, error: error instanceof Error ? error.message : String(error) }, 'Fallback: cannot read directory')
-      return
-    }
-
-    for (const name of names) {
-      const fullPath = join(dirPath, name)
-      let fileStat
-      try {
-        fileStat = await stat(fullPath)
-      } catch {
-        continue
-      }
-
-      if (fileStat.isDirectory()) {
-        if (!SKIP_DIRS.has(name)) {
-          await this.walkDirectoryFallback(fullPath, files)
-        }
-      } else if (fileStat.isFile()) {
-        if (SKIP_FILES.has(name)) continue
-        const ext = extname(name).toLowerCase()
-        if (!SUPPORTED_EXTENSIONS.has(ext)) continue
-        files.push(fullPath)
-      }
-    }
-  }
-
-  private async indexSingleFile(
-    filePath: string,
-    projectPath: string,
-    projectName: string
-  ): Promise<{ skipped: boolean; symbolCount: number }> {
-    // Check file size
-    const fileStats = await stat(filePath)
-    if (fileStats.size > MAX_FILE_SIZE) {
-      return { skipped: true, symbolCount: 0 }
-    }
-
-    const content = await Bun.file(filePath).text()
-    const hash = createHash('sha256').update(content).digest('hex')
-
-    // Check if file is unchanged
-    const relativePath = relative(projectPath, filePath)
-    const existing = this.db.query(
-      'SELECT file_hash FROM code_files WHERE project = ? AND file_path = ?'
-    ).get(projectName, relativePath) as { file_hash: string | null } | null
-
-    if (existing?.file_hash === hash) {
-      return { skipped: true, symbolCount: 0 }
-    }
-
-    // Clear old data for this file
-    this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, relativePath])
-    this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, relativePath])
-    this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, relativePath])
-
-    // Parse and store
-    const parsed = await this.parser.parseFile(filePath, content)
-    // Override filePath with relative path for storage
-    const storable: ParsedFile = { ...parsed, filePath: relativePath }
-
-    this.storeFile(storable, projectName, hash)
-    this.storeSymbols(storable, projectName)
-    this.storeDependencies(storable, projectName)
-
-    return { skipped: false, symbolCount: storable.symbols.length }
-  }
-
-  private storeFile(parsed: ParsedFile, projectName: string, hash: string): void {
-    const summary = this.generateFileSummary(parsed)
-    this.db.run(
-      `INSERT OR REPLACE INTO code_files (project, file_path, language, summary, symbol_count, line_count, last_indexed, file_hash)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
-      [
-        projectName,
-        parsed.filePath,
-        parsed.language,
-        summary,
-        parsed.symbols.length,
-        parsed.lineCount,
-        new Date().toISOString(),
-        hash,
-      ]
-    )
-  }
-
-  private storeSymbols(parsed: ParsedFile, projectName: string): void {
-    const stmt = this.db.prepare(
-      `INSERT INTO code_symbols (project, file_path, symbol_name, symbol_type, line_start, line_end, parent_symbol, signature, exported, updated_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    )
-
-    for (const sym of parsed.symbols) {
-      stmt.run(
-        projectName,
-        parsed.filePath,
-        sym.name,
-        sym.type,
-        sym.lineStart,
-        sym.lineEnd ?? null,
-        sym.parentSymbol ?? null,
-        sym.signature ?? null,
-        sym.exported ? 1 : 0,
-        new Date().toISOString()
-      )
-    }
-  }
-
-  private storeDependencies(parsed: ParsedFile, projectName: string): void {
-    const stmt = this.db.prepare(
-      `INSERT INTO code_dependencies (project, source_file, target_file, import_names, import_type)
-       VALUES (?, ?, ?, ?, ?)`
-    )
-
-    for (const imp of parsed.imports) {
-      stmt.run(
-        projectName,
-        parsed.filePath,
-        imp.source,
-        imp.names.join(', '),
-        imp.importType
-      )
-    }
-  }
-}
+import { Database } from 'bun:sqlite'
+import { readdir, stat } from 'node:fs/promises'
+import { join, relative, extname } from 'node:path'
+import { createHash } from 'node:crypto'
+import type { Logger } from 'pino'
+import type { CodeParser } from './parser'
+import type { IndexResult, IndexStats, ParsedFile } from './types'
+import { createCodeSchema } from './schema'
+
+const SKIP_DIRS = new Set([
+  'node_modules', '.git', 'dist', 'build', '__pycache__',
+  '.venv', 'target', '.cache', 'coverage', '.turbo', '.output', 'vendor',
+])
+
+const SKIP_FILES = new Set([
+  'package-lock.json', 'yarn.lock', 'bun.lockb', 'pnpm-lock.yaml', '.DS_Store',
+])
+
+const MAX_FILE_SIZE = 500 * 1024 // 500KB
+
+const SUPPORTED_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.go', '.rs', '.vue',
+  '.html', '.css', '.json', '.yaml', '.yml',
+])
+
+const BATCH_SIZE = 100
+
+export class CodeIndexer {
+  private db: Database
+  private parser: CodeParser
+  private logger: Logger
+
+  constructor(db: Database, parser: CodeParser, logger: Logger) {
+    this.db = db
+    this.parser = parser
+    this.logger = logger.child({ component: 'code-indexer' })
+  }
+
+  async initialize(): Promise<void> {
+    createCodeSchema(this.db)
+    this.logger.info('Code intelligence schema initialized')
+  }
+
+  async indexProject(projectPath: string, projectName: string): Promise<IndexResult> {
+    const startTime = Date.now()
+    const errors: string[] = []
+    let filesIndexed = 0
+    let filesSkipped = 0
+    let symbolsFound = 0
+
+    this.logger.info({ projectPath, projectName }, 'Starting project index')
+
+    // Collect all eligible files
+    const files = await this.collectFiles(projectPath)
+    this.logger.info({ fileCount: files.length }, 'Files collected for indexing')
+
+    // Process in batches
+    for (let i = 0; i < files.length; i += BATCH_SIZE) {
+      const batch = files.slice(i, i + BATCH_SIZE)
+      this.db.run('BEGIN TRANSACTION')
+      try {
+        for (const filePath of batch) {
+          try {
+            const result = await this.indexSingleFile(filePath, projectPath, projectName)
+            if (result.skipped) {
+              filesSkipped++
+            } else {
+              filesIndexed++
+              symbolsFound += result.symbolCount
+            }
+          } catch (error) {
+            const msg = `Failed to index ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+            errors.push(msg)
+            this.logger.warn({ filePath, error }, 'Failed to index file')
+          }
+        }
+        this.db.run('COMMIT')
+      } catch (error) {
+        this.db.run('ROLLBACK')
+        const msg = `Batch failed at offset ${i}: ${error instanceof Error ? error.message : String(error)}`
+        errors.push(msg)
+        this.logger.error({ error, batchOffset: i }, 'Batch transaction failed')
+      }
+    }
+
+    const durationMs = Date.now() - startTime
+    this.logger.info(
+      { filesIndexed, filesSkipped, symbolsFound, durationMs, errors: errors.length },
+      'Project indexing complete'
+    )
+
+    return {
+      project: projectName,
+      filesIndexed,
+      filesSkipped,
+      symbolsFound,
+      durationMs,
+      errors,
+    }
+  }
+
+  async indexFile(filePath: string, projectName: string): Promise<void> {
+    this.db.run('BEGIN TRANSACTION')
+    try {
+      // Clear existing data for this file
+      this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, filePath])
+      this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, filePath])
+      this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, filePath])
+
+      const content = await Bun.file(filePath).text()
+      const hash = createHash('sha256').update(content).digest('hex')
+      const parsed = await this.parser.parseFile(filePath, content)
+
+      this.storeFile(parsed, projectName, hash)
+      this.storeSymbols(parsed, projectName)
+      this.storeDependencies(parsed, projectName)
+
+      this.db.run('COMMIT')
+      this.logger.debug({ filePath, symbols: parsed.symbols.length }, 'File re-indexed')
+    } catch (error) {
+      this.db.run('ROLLBACK')
+      throw error
+    }
+  }
+
+  async clearProject(projectName: string): Promise<void> {
+    this.db.run('BEGIN TRANSACTION')
+    try {
+      this.db.run('DELETE FROM code_symbols WHERE project = ?', [projectName])
+      this.db.run('DELETE FROM code_dependencies WHERE project = ?', [projectName])
+      this.db.run('DELETE FROM code_files WHERE project = ?', [projectName])
+      this.db.run('COMMIT')
+      this.logger.info({ projectName }, 'Project data cleared')
+    } catch (error) {
+      this.db.run('ROLLBACK')
+      throw error
+    }
+  }
+
+  getStats(projectName: string): IndexStats {
+    const fileRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_files WHERE project = ?'
+    ).get(projectName) as { cnt: number } | null
+
+    const symbolRow = this.db.query(
+      'SELECT COUNT(*) as cnt FROM code_symbols WHERE project = ?'
+    ).get(projectName) as { cnt: number } | null
+
+    const lastRow = this.db.query(
+      'SELECT MAX(last_indexed) as last_indexed FROM code_files WHERE project = ?'
+    ).get(projectName) as { last_indexed: string | null } | null
+
+    return {
+      project: projectName,
+      filesIndexed: fileRow?.cnt ?? 0,
+      totalSymbols: symbolRow?.cnt ?? 0,
+      lastIndexed: lastRow?.last_indexed ?? null,
+      staleFiles: 0, // Could be computed by comparing file hashes
+    }
+  }
+
+  generateFileSummary(parsed: ParsedFile): string {
+    const exported = parsed.symbols.filter(s => s.exported)
+    if (exported.length === 0) {
+      return `${parsed.language} file, ${parsed.lineCount} lines`
+    }
+
+    const grouped = new Map<string, string[]>()
+    for (const sym of exported) {
+      const existing = grouped.get(sym.type) ?? []
+      existing.push(sym.name)
+      grouped.set(sym.type, existing)
+    }
+
+    const parts: string[] = []
+    for (const [type, names] of grouped) {
+      if (names.length <= 3) {
+        parts.push(`${names.join(', ')} (${type})`)
+      } else {
+        parts.push(`${names.slice(0, 3).join(', ')} +${names.length - 3} (${type})`)
+      }
+    }
+
+    return parts.join(' — ')
+  }
+
+  // ─── Private Helpers ──────────────────────────────────────
+
+  private async collectFiles(dirPath: string): Promise<string[]> {
+    const files: string[] = []
+    await this.walkDirectory(dirPath, files)
+    if (files.length === 0) {
+      this.logger.warn({ dirPath }, 'collectFiles returned 0 files — trying fallback without withFileTypes')
+      await this.walkDirectoryFallback(dirPath, files)
+    }
+    return files
+  }
+
+  private async walkDirectory(dirPath: string, files: string[]): Promise<void> {
+    let entries
+    try {
+      entries = await readdir(dirPath, { withFileTypes: true })
+    } catch (error) {
+      this.logger.debug({ dirPath, error: error instanceof Error ? error.message : String(error) }, 'Cannot read directory')
+      return
+    }
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) {
+          await this.walkDirectory(join(dirPath, entry.name), files)
+        }
+      } else if (entry.isFile()) {
+        if (SKIP_FILES.has(entry.name)) continue
+        const ext = extname(entry.name).toLowerCase()
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue
+        files.push(join(dirPath, entry.name))
+      }
+    }
+  }
+
+  /** Fallback walker that uses readdir (names only) + stat — works on all platforms */
+  private async walkDirectoryFallback(dirPath: string, files: string[]): Promise<void> {
+    let names: string[]
+    try {
+      names = await readdir(dirPath)
+    } catch (error) {
+      this.logger.debug({ dirPath, error: error instanceof Error ? error.message : String(error) }, 'Fallback: cannot read directory')
+      return
+    }
+
+    for (const name of names) {
+      const fullPath = join(dirPath, name)
+      let fileStat
+      try {
+        fileStat = await stat(fullPath)
+      } catch {
+        continue
+      }
+
+      if (fileStat.isDirectory()) {
+        if (!SKIP_DIRS.has(name)) {
+          await this.walkDirectoryFallback(fullPath, files)
+        }
+      } else if (fileStat.isFile()) {
+        if (SKIP_FILES.has(name)) continue
+        const ext = extname(name).toLowerCase()
+        if (!SUPPORTED_EXTENSIONS.has(ext)) continue
+        files.push(fullPath)
+      }
+    }
+  }
+
+  private async indexSingleFile(
+    filePath: string,
+    projectPath: string,
+    projectName: string
+  ): Promise<{ skipped: boolean; symbolCount: number }> {
+    // Check file size
+    const fileStats = await stat(filePath)
+    if (fileStats.size > MAX_FILE_SIZE) {
+      return { skipped: true, symbolCount: 0 }
+    }
+
+    const content = await Bun.file(filePath).text()
+    const hash = createHash('sha256').update(content).digest('hex')
+
+    // Check if file is unchanged
+    const relativePath = relative(projectPath, filePath)
+    const existing = this.db.query(
+      'SELECT file_hash FROM code_files WHERE project = ? AND file_path = ?'
+    ).get(projectName, relativePath) as { file_hash: string | null } | null
+
+    if (existing?.file_hash === hash) {
+      return { skipped: true, symbolCount: 0 }
+    }
+
+    // Clear old data for this file
+    this.db.run('DELETE FROM code_symbols WHERE project = ? AND file_path = ?', [projectName, relativePath])
+    this.db.run('DELETE FROM code_dependencies WHERE project = ? AND source_file = ?', [projectName, relativePath])
+    this.db.run('DELETE FROM code_files WHERE project = ? AND file_path = ?', [projectName, relativePath])
+
+    // Parse and store
+    const parsed = await this.parser.parseFile(filePath, content)
+    // Override filePath with relative path for storage
+    const storable: ParsedFile = { ...parsed, filePath: relativePath }
+
+    this.storeFile(storable, projectName, hash)
+    this.storeSymbols(storable, projectName)
+    this.storeDependencies(storable, projectName)
+
+    return { skipped: false, symbolCount: storable.symbols.length }
+  }
+
+  private storeFile(parsed: ParsedFile, projectName: string, hash: string): void {
+    const summary = this.generateFileSummary(parsed)
+    this.db.run(
+      `INSERT OR REPLACE INTO code_files (project, file_path, language, summary, symbol_count, line_count, last_indexed, file_hash)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        projectName,
+        parsed.filePath,
+        parsed.language,
+        summary,
+        parsed.symbols.length,
+        parsed.lineCount,
+        new Date().toISOString(),
+        hash,
+      ]
+    )
+  }
+
+  private storeSymbols(parsed: ParsedFile, projectName: string): void {
+    const stmt = this.db.prepare(
+      `INSERT INTO code_symbols (project, file_path, symbol_name, symbol_type, line_start, line_end, parent_symbol, signature, exported, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    )
+
+    for (const sym of parsed.symbols) {
+      stmt.run(
+        projectName,
+        parsed.filePath,
+        sym.name,
+        sym.type,
+        sym.lineStart,
+        sym.lineEnd ?? null,
+        sym.parentSymbol ?? null,
+        sym.signature ?? null,
+        sym.exported ? 1 : 0,
+        new Date().toISOString()
+      )
+    }
+  }
+
+  private storeDependencies(parsed: ParsedFile, projectName: string): void {
+    const stmt = this.db.prepare(
+      `INSERT INTO code_dependencies (project, source_file, target_file, import_names, import_type)
+       VALUES (?, ?, ?, ?, ?)`
+    )
+
+    for (const imp of parsed.imports) {
+      stmt.run(
+        projectName,
+        parsed.filePath,
+        imp.source,
+        imp.names.join(', '),
+        imp.importType
+      )
+    }
+  }
+}