feat(store): unified edges, single-table indexed stores, graph-prefixed schema

Major refactoring of store types and schema:
- Unified Edge type replaces Relation + CrossLink (one edges table)
- Code, Docs, Files: single table per graph with kind field (no separate file/symbol tables)
- Graph-prefixed table names: knowledge, tasks, epics, skills, code, docs, files
- Hierarchy via edges (file→symbol, file→chunk, dir→file) instead of FK parent refs
- Detail types simplified: edges: Edge[] instead of separate relation arrays
- SearchResult.id changed to number (numeric IDs throughout)
- All 22 tests passing

Author: prih

src/store/index.ts

@@ -0,0 +1,2 @@
+export { SqliteStore } from './sqlite/store';
+export * from './types';

src/store/sqlite/lib/bigint.ts

@@ -0,0 +1,9 @@
+/** Convert BigInt (from better-sqlite3 safeIntegers) to number */
+export function num(v: bigint | number): number {
+  return typeof v === 'bigint' ? Number(v) : v;
+}
+
+/** Current timestamp in ms as BigInt (for SQLite INTEGER columns) */
+export function now(): bigint {
+  return BigInt(Date.now());
+}

src/store/sqlite/lib/db.ts

@@ -0,0 +1,19 @@
+import Database from 'better-sqlite3';
+import sqliteVec from 'sqlite-vec';
+
+/**
+ * Open a SQLite database with all required extensions and pragmas.
+ *
+ * - defaultSafeIntegers(true) — required for sqlite-vec (BigInt rowids)
+ * - sqlite-vec extension loaded
+ * - WAL journal mode for concurrent reads
+ * - foreign_keys enforced
+ */
+export function openDatabase(dbPath: string): Database.Database {
+  const db = new Database(dbPath);
+  db.defaultSafeIntegers(true);
+  sqliteVec.load(db);
+  db.pragma('journal_mode = WAL');
+  db.pragma('foreign_keys = ON');
+  return db;
+}

src/store/sqlite/lib/meta.ts

@@ -0,0 +1,34 @@
+import Database from 'better-sqlite3';
+
+/**
+ * Reusable MetaMixin implementation.
+ * Keys are stored with a prefix: `${prefix}:${key}` (or just `${key}` if prefix is empty).
+ */
+export class MetaHelper {
+  private stmtGet: Database.Statement;
+  private stmtSet: Database.Statement;
+  private stmtDel: Database.Statement;
+
+  constructor(db: Database.Database, private prefix: string) {
+    this.stmtGet = db.prepare('SELECT value FROM meta WHERE key = ?');
+    this.stmtSet = db.prepare('INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)');
+    this.stmtDel = db.prepare('DELETE FROM meta WHERE key = ?');
+  }
+
+  private key(k: string): string {
+    return this.prefix ? `${this.prefix}:${k}` : k;
+  }
+
+  getMeta(key: string): string | null {
+    const row = this.stmtGet.get(this.key(key)) as { value: string } | undefined;
+    return row ? row.value : null;
+  }
+
+  setMeta(key: string, value: string): void {
+    this.stmtSet.run(this.key(key), value);
+  }
+
+  deleteMeta(key: string): void {
+    this.stmtDel.run(this.key(key));
+  }
+}

src/store/sqlite/lib/migrate.ts

@@ -0,0 +1,37 @@
+import Database from 'better-sqlite3';
+import { num } from './bigint';
+
+export interface Migration {
+  version: number;
+  sql: string;
+}
+
+/**
+ * Run pending migrations against the database.
+ * Uses PRAGMA user_version to track which migrations have been applied.
+ * Each migration runs in its own transaction.
+ *
+ * @returns number of migrations applied
+ */
+export function runMigrations(db: Database.Database, migrations: Migration[]): number {
+  const sorted = [...migrations].sort((a, b) => a.version - b.version);
+  const current = num((db.pragma('user_version') as Array<{ user_version: bigint }>)[0].user_version);
+  let applied = 0;
+
+  for (const m of sorted) {
+    if (m.version > current) {
+      db.transaction(() => {
+        db.exec(m.sql);
+        db.pragma(`user_version = ${m.version}`);
+      })();
+      applied++;
+    }
+  }
+
+  return applied;
+}
+
+/** Get the current schema version */
+export function getSchemaVersion(db: Database.Database): number {
+  return num((db.pragma('user_version') as Array<{ user_version: bigint }>)[0].user_version);
+}

src/store/sqlite/lib/search.ts

@@ -0,0 +1,103 @@
+import Database from 'better-sqlite3';
+import type { SearchQuery, SearchResult } from '../../types';
+import { num } from './bigint';
+
+const RRF_K = 60;
+
+/**
+ * Configuration for hybrid search on a specific entity table.
+ * Each store provides its own config pointing to its FTS5 and vec0 tables.
+ */
+export interface SearchConfig {
+  /** FTS5 virtual table name (e.g. 'notes_fts') */
+  ftsTable: string;
+  /** vec0 virtual table name (e.g. 'notes_vec') */
+  vecTable: string;
+  /** Parent table name (e.g. 'notes') for project_id filtering */
+  parentTable: string;
+  /** Column to join parent table to FTS rowid (usually 'id') */
+  parentIdColumn: string;
+}
+
+/**
+ * Perform hybrid search combining FTS5 keyword search and vec0 vector search.
+ *
+ * - mode 'keyword': FTS5 only, embedding ignored
+ * - mode 'vector': vec0 only, text ignored
+ * - mode 'hybrid' (default): both, fused via Reciprocal Rank Fusion (RRF)
+ *
+ * vec0 cannot filter by project_id directly, so we overfetch and post-filter via JOIN.
+ */
+export function hybridSearch(
+  db: Database.Database,
+  config: SearchConfig,
+  query: SearchQuery,
+  projectId: number,
+): SearchResult[] {
+  const mode = query.searchMode ?? 'hybrid';
+  const topK = query.topK ?? 50;
+  const maxResults = query.maxResults ?? 20;
+  const minScore = query.minScore ?? 0;
+
+  let ftsRanked: Array<{ id: number; rn: number }> = [];
+  let vecRanked: Array<{ id: number; rn: number }> = [];
+
+  // FTS5 keyword search
+  if (mode !== 'vector' && query.text) {
+    const rows = db.prepare(`
+      SELECT p.${config.parentIdColumn} AS id, ROW_NUMBER() OVER (ORDER BY rank) AS rn
+      FROM ${config.ftsTable} fts
+      JOIN ${config.parentTable} p ON p.${config.parentIdColumn} = fts.rowid AND p.project_id = ?
+      WHERE ${config.ftsTable} MATCH ?
+      LIMIT ?
+    `).all(projectId, query.text, topK) as Array<{ id: bigint; rn: bigint }>;
+
+    ftsRanked = rows.map(r => ({ id: num(r.id), rn: num(r.rn) }));
+  }
+
+  // vec0 vector search
+  if (mode !== 'keyword' && query.embedding && query.embedding.length > 0) {
+    const embeddingBuf = Buffer.from(new Float32Array(query.embedding).buffer);
+    // Overfetch x3 to compensate for cross-project rows filtered out by JOIN
+    const vecK = topK * 3;
+
+    const rows = db.prepare(`
+      SELECT v.rowid AS id, v.distance, ROW_NUMBER() OVER (ORDER BY v.distance) AS rn
+      FROM ${config.vecTable} v
+      JOIN ${config.parentTable} p ON p.${config.parentIdColumn} = v.rowid AND p.project_id = ?
+      WHERE v.embedding MATCH ? AND v.k = ?
+    `).all(projectId, embeddingBuf, vecK) as Array<{ id: bigint; distance: number; rn: bigint }>;
+
+    vecRanked = rows.slice(0, topK).map((r, i) => ({ id: num(r.id), rn: i + 1 }));
+  }
+
+  // Single-mode: return directly with normalized scores
+  if (mode === 'keyword') {
+    return ftsRanked
+      .map(r => ({ id: r.id, score: 1 / (RRF_K + r.rn) }))
+      .filter(r => r.score >= minScore)
+      .slice(0, maxResults);
+  }
+
+  if (mode === 'vector') {
+    return vecRanked
+      .map(r => ({ id: r.id, score: 1 / (RRF_K + r.rn) }))
+      .filter(r => r.score >= minScore)
+      .slice(0, maxResults);
+  }
+
+  // Hybrid: RRF fusion
+  const scores = new Map<number, number>();
+  for (const r of ftsRanked) {
+    scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (RRF_K + r.rn));
+  }
+  for (const r of vecRanked) {
+    scores.set(r.id, (scores.get(r.id) ?? 0) + 1 / (RRF_K + r.rn));
+  }
+
+  return [...scores.entries()]
+    .map(([id, score]) => ({ id, score }))
+    .filter(r => r.score >= minScore)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxResults);
+}