forge-server 0.1.0

package/src/storage/qdrant-store.ts

@@ -0,0 +1,557 @@
+/**
+ * Qdrant implementation of VectorStore.
+ * Connects to localhost:6333 via REST API.
+ * Collections:
+ *   - code_chunks (384-dim cosine)
+ *   - observations (384-dim cosine)
+ *   - knowledge (384-dim cosine) — pipeline-specific, stores KnowledgePayload items
+ */
+
+import { QdrantClient } from '@qdrant/js-client-rest';
+import type { VectorStore, VectorSearchOptions } from './interfaces.js';
+import type {
+  CodeChunkPayload,
+  ObservationPayload,
+  GitCommitPayload,
+  VectorSearchResult,
+} from '../util/types.js';
+import { logger } from '../util/logger.js';
+import { CircuitBreaker } from '../util/circuit-breaker.js';
+
+const CODE_CHUNKS_COLLECTION = 'code_chunks';
+const OBSERVATIONS_COLLECTION = 'observations';
+const KNOWLEDGE_COLLECTION = 'knowledge';
+const GIT_COMMITS_COLLECTION = 'git_commits';
+
+export class QdrantVectorStore implements VectorStore {
+  private client: QdrantClient;
+  private readonly url: string;
+  private readonly breaker: CircuitBreaker;
+
+  constructor(url: string = 'http://localhost:6333') {
+    this.url = url;
+    this.client = new QdrantClient({ url });
+    this.breaker = new CircuitBreaker({
+      name: 'qdrant',
+      failureThreshold: 5,
+      resetTimeoutMs: 30_000,
+    });
+  }
+
+  async connect(): Promise<void> {
+    // Qdrant REST client doesn't need an explicit connection - just validate health
+    const healthy = await this.isHealthy();
+    if (!healthy) {
+      throw new Error(`Qdrant not reachable at ${this.url}`);
+    }
+    logger.info('Qdrant connected', { url: this.url });
+  }
+
+  async disconnect(): Promise<void> {
+    // No persistent connection to close for REST client
+    logger.info('Qdrant disconnected');
+  }
+
+  async isHealthy(): Promise<boolean> {
+    // Circuit breaker short-circuits when OPEN — skip the HTTP health probe
+    if (!this.breaker.isHealthy()) return false;
+    try {
+      // getCollections() is the most reliable health probe for qdrant-js-client-rest:
+      // it performs a real HTTP request and returns if the server is reachable.
+      await this.client.getCollections();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async ensureCollections(dimension: number): Promise<void> {
+    const hnsw = { m: 16, ef_construct: 100 };
+    const onDisk = true;
+
+    // Create code_chunks collection
+    await this.ensureCollection(CODE_CHUNKS_COLLECTION, dimension, hnsw, onDisk, [
+      { field_name: 'repo_id', field_schema: 'keyword' },
+      { field_name: 'file_path', field_schema: 'keyword' },
+      { field_name: 'entity_type', field_schema: 'keyword' },
+    ]);
+
+    // Create observations collection
+    await this.ensureCollection(OBSERVATIONS_COLLECTION, dimension, hnsw, onDisk, [
+      { field_name: 'repo_id', field_schema: 'keyword' },
+      { field_name: 'session_id', field_schema: 'keyword' },
+      { field_name: 'namespace', field_schema: 'keyword' },
+      { field_name: 'key', field_schema: 'keyword' },
+      { field_name: 'source', field_schema: 'keyword' },
+      { field_name: 'type', field_schema: 'keyword' },
+    ]);
+
+    // Create knowledge collection (pipeline-specific)
+    await this.ensureCollection(KNOWLEDGE_COLLECTION, dimension, hnsw, onDisk, [
+      { field_name: 'category', field_schema: 'keyword' },
+      { field_name: 'repo_id', field_schema: 'keyword' },
+      { field_name: 'stack_tags', field_schema: 'keyword' },
+      { field_name: 'confidence', field_schema: 'float' },
+      { field_name: 'sharing', field_schema: 'keyword' },
+    ]);
+
+    // Create git_commits collection (Phase 3 - git enrichment)
+    await this.ensureCollection(GIT_COMMITS_COLLECTION, dimension, hnsw, onDisk, [
+      { field_name: 'repo_id', field_schema: 'keyword' },
+      { field_name: 'commit_hash', field_schema: 'keyword' },
+      { field_name: 'author', field_schema: 'keyword' },
+      { field_name: 'timestamp', field_schema: 'integer' },
+      { field_name: 'file_paths', field_schema: 'keyword' },
+    ]);
+
+    logger.info('Qdrant collections ensured', { dimension });
+  }
+
+  private async ensureCollection(
+    name: string,
+    dimension: number,
+    hnsw: { m: number; ef_construct: number },
+    onDisk: boolean,
+    payloadIndexes: Array<{ field_name: string; field_schema: string }>
+  ): Promise<void> {
+    try {
+      await this.client.getCollection(name);
+      logger.debug(`Collection ${name} already exists`);
+    } catch {
+      // Collection does not exist - create it
+      await this.client.createCollection(name, {
+        vectors: {
+          size: dimension,
+          distance: 'Cosine',
+          on_disk: onDisk,
+        },
+        hnsw_config: {
+          m: hnsw.m,
+          ef_construct: hnsw.ef_construct,
+          on_disk: true,
+        },
+      });
+      logger.info(`Created Qdrant collection: ${name}`);
+
+      // Create payload indexes
+      for (const idx of payloadIndexes) {
+        try {
+          await this.client.createPayloadIndex(name, {
+            field_name: idx.field_name,
+            field_schema: idx.field_schema as 'keyword' | 'float',
+          });
+        } catch (err) {
+          logger.warn(`Failed to create payload index ${idx.field_name} on ${name}`, { error: String(err) });
+        }
+      }
+    }
+  }
+
+  async upsertCodeChunks(
+    chunks: Array<{ id: string; vector: number[]; payload: CodeChunkPayload }>
+  ): Promise<void> {
+    if (chunks.length === 0) return;
+
+    const points = chunks.map(chunk => ({
+      id: this.uuidToNumeric(chunk.id),
+      vector: chunk.vector,
+      payload: chunk.payload as unknown as Record<string, unknown>,
+    }));
+
+    await this.client.upsert(CODE_CHUNKS_COLLECTION, {
+      wait: true,
+      points,
+    });
+
+    logger.debug(`Upserted ${chunks.length} code chunks to Qdrant`);
+  }
+
+  async upsertObservation(id: string, vector: number[], payload: ObservationPayload): Promise<void> {
+    await this.client.upsert(OBSERVATIONS_COLLECTION, {
+      wait: true,
+      points: [{
+        id: this.uuidToNumeric(id),
+        vector,
+        payload: payload as unknown as Record<string, unknown>,
+      }],
+    });
+  }
+
+  async searchCodeChunks(queryVector: number[], options: VectorSearchOptions): Promise<VectorSearchResult[]> {
+    const { limit = 20, filter, scoreThreshold = 0 } = options;
+
+    const params: Parameters<typeof this.client.search>[1] = {
+      vector: queryVector,
+      limit,
+      score_threshold: scoreThreshold,
+      with_payload: true,
+    };
+
+    if (filter) {
+      params.filter = this.buildFilter(filter);
+    }
+
+    const results = await this.breaker.execute(() =>
+      this.client.search(CODE_CHUNKS_COLLECTION, params)
+    );
+
+    return results.map(r => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload as unknown as CodeChunkPayload,
+    }));
+  }
+
+  async searchObservations(queryVector: number[], options: VectorSearchOptions): Promise<VectorSearchResult[]> {
+    const { limit = 10, filter, scoreThreshold = 0.3 } = options;
+
+    const params: Parameters<typeof this.client.search>[1] = {
+      vector: queryVector,
+      limit,
+      score_threshold: scoreThreshold,
+      with_payload: true,
+    };
+
+    if (filter) {
+      params.filter = this.buildFilter(filter);
+    }
+
+    const results = await this.breaker.execute(() =>
+      this.client.search(OBSERVATIONS_COLLECTION, params)
+    );
+
+    return results.map(r => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload as unknown as ObservationPayload,
+    }));
+  }
+
+  async deleteFileChunks(filePath: string, repoId: string): Promise<void> {
+    await this.client.delete(CODE_CHUNKS_COLLECTION, {
+      wait: true,
+      filter: {
+        must: [
+          { key: 'file_path', match: { value: filePath } },
+          { key: 'repo_id', match: { value: repoId } },
+        ],
+      },
+    });
+  }
+
+  async deleteRepoChunks(repoId: string): Promise<void> {
+    await this.client.delete(CODE_CHUNKS_COLLECTION, {
+      wait: true,
+      filter: {
+        must: [{ key: 'repo_id', match: { value: repoId } }],
+      },
+    });
+  }
+
+  async getCounts(): Promise<{ codeChunks: number; observations: number }> {
+    try {
+      const [codeInfo, obsInfo] = await Promise.all([
+        this.client.getCollection(CODE_CHUNKS_COLLECTION),
+        this.client.getCollection(OBSERVATIONS_COLLECTION),
+      ]);
+      return {
+        codeChunks: codeInfo.points_count ?? 0,
+        observations: obsInfo.points_count ?? 0,
+      };
+    } catch {
+      return { codeChunks: 0, observations: 0 };
+    }
+  }
+
+  async getObservation(id: string): Promise<ObservationPayload | null> {
+    try {
+      const results = await this.client.retrieve(OBSERVATIONS_COLLECTION, {
+        ids: [this.uuidToNumeric(id)],
+        with_payload: true,
+      });
+      if (results.length === 0) return null;
+      return results[0]!.payload as unknown as ObservationPayload;
+    } catch {
+      return null;
+    }
+  }
+
+  async updateObservation(id: string, payload: Partial<ObservationPayload>): Promise<void> {
+    await this.client.setPayload(OBSERVATIONS_COLLECTION, {
+      wait: true,
+      points: [this.uuidToNumeric(id)],
+      payload: payload as unknown as Record<string, unknown>,
+    });
+  }
+
+  async filterObservations(filter: Record<string, unknown>, limit = 10): Promise<VectorSearchResult[]> {
+    const results = await this.client.scroll(OBSERVATIONS_COLLECTION, {
+      filter: this.buildFilter(filter),
+      limit,
+      with_payload: true,
+      with_vector: false,
+    });
+
+    return (results.points ?? []).map(r => ({
+      id: String(r.id),
+      score: 1.0,
+      payload: r.payload as unknown as ObservationPayload,
+    }));
+  }
+
+  // ============================================================
+  // Knowledge collection helpers (pipeline-specific)
+  // ============================================================
+
+  /**
+   * Search the knowledge collection by vector similarity.
+   */
+  async searchKnowledge(
+    queryVector: number[],
+    options: VectorSearchOptions
+  ): Promise<VectorSearchResult[]> {
+    const { limit = 10, filter, scoreThreshold = 0.3 } = options;
+
+    const params: Parameters<typeof this.client.search>[1] = {
+      vector: queryVector,
+      limit,
+      score_threshold: scoreThreshold,
+      with_payload: true,
+    };
+
+    if (filter) {
+      params.filter = this.buildFilter(filter);
+    }
+
+    const results = await this.breaker.execute(() =>
+      this.client.search(KNOWLEDGE_COLLECTION, params)
+    );
+
+    return results.map(r => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload as Record<string, unknown>,
+    })) as unknown as VectorSearchResult[];
+  }
+
+  /**
+   * Upsert a knowledge item into the knowledge collection.
+   */
+  async upsertKnowledge(
+    id: string,
+    vector: number[],
+    payload: Record<string, unknown>
+  ): Promise<void> {
+    await this.client.upsert(KNOWLEDGE_COLLECTION, {
+      wait: true,
+      points: [{
+        id: this.uuidToNumeric(id),
+        vector,
+        payload,
+      }],
+    });
+  }
+
+  /**
+   * Delete a knowledge item from the knowledge collection.
+   */
+  async deleteKnowledge(id: string): Promise<void> {
+    await this.client.delete(KNOWLEDGE_COLLECTION, {
+      wait: true,
+      points: [this.uuidToNumeric(id)],
+    });
+  }
+
+  /**
+   * Delete ALL knowledge items for a given repo_id from the knowledge collection.
+   * Used by KnowledgeHydrator.removeRepo() before re-hydrating to handle
+   * item deletions (items removed from YAML should disappear from Qdrant).
+   */
+  async deleteKnowledgeByRepo(repoId: string): Promise<void> {
+    await this.client.delete(KNOWLEDGE_COLLECTION, {
+      wait: true,
+      filter: {
+        must: [{ key: 'repo_id', match: { value: repoId } }],
+      },
+    });
+    logger.debug('QdrantVectorStore: deleted knowledge points for repo', { repoId });
+  }
+
+  /**
+   * Retrieve a single knowledge item payload by its Qdrant point ID.
+   * Returns null if the item does not exist.
+   * Used by KnowledgeSearch.boostConfidence() to read current confidence value.
+   */
+  async getKnowledge(id: string): Promise<Record<string, unknown> | null> {
+    try {
+      const results = await this.client.retrieve(KNOWLEDGE_COLLECTION, {
+        ids: [this.uuidToNumeric(id)],
+        with_payload: true,
+      });
+      if (results.length === 0) return null;
+      return results[0]!.payload as Record<string, unknown> ?? null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Partially update a knowledge item's payload fields without changing the vector.
+   * Used by KnowledgeSearch.boostConfidence() to update accessed_at, access_count,
+   * and confidence without re-embedding.
+   */
+  async setKnowledgePayload(id: string, patch: Record<string, unknown>): Promise<void> {
+    await this.client.setPayload(KNOWLEDGE_COLLECTION, {
+      wait: true,
+      points: [this.uuidToNumeric(id)],
+      payload: patch,
+    });
+  }
+
+  /**
+   * Filter-scroll the knowledge collection without a semantic query.
+   * Used by KnowledgeSearch.getGotchas() and getPatterns() to enumerate items
+   * by category without needing an embedding.
+   *
+   * Returns up to `limit` items matching the filter, each as { id, payload }.
+   */
+  async filterKnowledge(
+    filter: Record<string, unknown>,
+    limit: number,
+  ): Promise<Array<{ id: string; payload: Record<string, unknown> }>> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const results = await this.client.scroll(KNOWLEDGE_COLLECTION, {
+      filter: filter as unknown as any, // eslint-disable-line @typescript-eslint/no-explicit-any
+      limit,
+      with_payload: true,
+      with_vector: false,
+    });
+
+    return (results.points ?? []).map((r) => ({
+      id: String(r.id),
+      payload: r.payload as Record<string, unknown>,
+    }));
+  }
+
+  /**
+   * Get count of knowledge items.
+   */
+  async getKnowledgeCount(): Promise<number> {
+    try {
+      const info = await this.client.getCollection(KNOWLEDGE_COLLECTION);
+      return info.points_count ?? 0;
+    } catch {
+      return 0;
+    }
+  }
+
+  // ============================================================
+  // Git commits collection helpers (Phase 3 - git enrichment)
+  // ============================================================
+
+  /**
+   * Upsert git commit embeddings into the git_commits collection.
+   * Each commit message is embedded and stored with metadata for semantic search.
+   */
+  async upsertGitCommits(
+    commits: Array<{ id: string; vector: number[]; payload: GitCommitPayload }>
+  ): Promise<void> {
+    if (commits.length === 0) return;
+
+    const points = commits.map(c => ({
+      id: this.uuidToNumeric(c.id),
+      vector: c.vector,
+      payload: c.payload as unknown as Record<string, unknown>,
+    }));
+
+    // Upsert in batches of 100 to avoid overwhelming the server
+    const BATCH = 100;
+    for (let i = 0; i < points.length; i += BATCH) {
+      const batch = points.slice(i, i + BATCH);
+      await this.client.upsert(GIT_COMMITS_COLLECTION, {
+        wait: true,
+        points: batch,
+      });
+    }
+
+    logger.debug(`Upserted ${commits.length} git commits to Qdrant`);
+  }
+
+  /**
+   * Semantic search over git commit messages.
+   * Returns commits matching the query vector, optionally filtered by repo_id.
+   */
+  async searchGitCommits(
+    queryVector: number[],
+    repoId?: string,
+    limit: number = 20
+  ): Promise<VectorSearchResult[]> {
+    const params: Parameters<typeof this.client.search>[1] = {
+      vector: queryVector,
+      limit,
+      score_threshold: 0.2,
+      with_payload: true,
+    };
+
+    if (repoId) {
+      params.filter = this.buildFilter({ repo_id: repoId });
+    }
+
+    const results = await this.breaker.execute(() =>
+      this.client.search(GIT_COMMITS_COLLECTION, params)
+    );
+
+    return results.map(r => ({
+      id: String(r.id),
+      score: r.score,
+      payload: r.payload as unknown as GitCommitPayload,
+    })) as unknown as VectorSearchResult[];
+  }
+
+  /**
+   * Delete all git commit embeddings for a given repo.
+   * Used during re-indexing to avoid stale commit data.
+   */
+  async deleteGitCommitsByRepo(repoId: string): Promise<void> {
+    await this.client.delete(GIT_COMMITS_COLLECTION, {
+      wait: true,
+      filter: {
+        must: [{ key: 'repo_id', match: { value: repoId } }],
+      },
+    });
+    logger.debug('QdrantVectorStore: deleted git commits for repo', { repoId });
+  }
+
+  private buildFilter(filter: Record<string, unknown>): Record<string, unknown> {
+    // Simple filter builder: { repo_id: 'x', namespace: 'y' } -> Qdrant must filter
+    const must = Object.entries(filter)
+      .filter(([, v]) => v !== undefined && v !== null)
+      .map(([key, value]) => ({
+        key,
+        match: { value },
+      }));
+
+    return must.length > 0 ? { must } : {};
+  }
+
+  /**
+   * Convert UUID string to a numeric ID for Qdrant.
+   * Qdrant supports both UUID strings and unsigned 64-bit integers as point IDs.
+   * We use UUID format directly as Qdrant v1.x supports UUID string IDs.
+   */
+  private uuidToNumeric(id: string): string {
+    // Qdrant supports UUID string IDs - return as-is
+    // Ensure it's a valid UUID format; if not, pad it
+    if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) {
+      return id;
+    }
+    // Hash to a deterministic UUID-like format
+    let hash = 0;
+    for (let i = 0; i < id.length; i++) {
+      hash = ((hash << 5) - hash) + id.charCodeAt(i);
+      hash |= 0;
+    }
+    const absHash = Math.abs(hash);
+    return `00000000-0000-4000-8000-${String(absHash).padStart(12, '0')}`;
+  }
+}

package/src/storage/schema.ts

@@ -0,0 +1,139 @@
+// SQL DDL for the dk-forge-server SQLite database.
+// All knowledge/vector data lives in Qdrant — this file covers pipeline state only.
+//
+// Design notes:
+// - Timestamps are INTEGER (Unix milliseconds) throughout — no TEXT dates.
+// - JSON columns are TEXT in SQLite; callers parse/serialize them explicitly.
+// - Foreign keys are declared; the PipelineDB class enables FK enforcement
+//   via PRAGMA foreign_keys=ON at connection time.
+// - Every CREATE TABLE uses IF NOT EXISTS so initialize() is idempotent.
+// - Every CREATE INDEX uses IF NOT EXISTS for the same reason.
+
+export const SCHEMA_SQL = `
+-- Repo registry
+CREATE TABLE IF NOT EXISTS repos (
+  id           TEXT    PRIMARY KEY,
+  name         TEXT    NOT NULL,
+  path         TEXT    NOT NULL,
+  remote       TEXT,
+  stack        TEXT    NOT NULL DEFAULT '[]',
+  sharing      TEXT    NOT NULL DEFAULT 'private',
+  org          TEXT,
+  registered_at  INTEGER NOT NULL,
+  last_seen_at   INTEGER NOT NULL,
+  manifest_hash  TEXT
+);
+
+-- Pipeline projects
+CREATE TABLE IF NOT EXISTS projects (
+  id            TEXT    PRIMARY KEY,
+  repo_id       TEXT    NOT NULL REFERENCES repos(id),
+  name          TEXT    NOT NULL,
+  description   TEXT,
+  current_phase TEXT    NOT NULL DEFAULT 'idle',
+  tier          TEXT    NOT NULL DEFAULT 'full',
+  status        TEXT    NOT NULL DEFAULT 'active',
+  created_at    INTEGER NOT NULL,
+  updated_at    INTEGER NOT NULL,
+  metadata      TEXT    NOT NULL DEFAULT '{}'
+);
+
+-- Pipeline events (event sourcing log)
+CREATE TABLE IF NOT EXISTS pipeline_events (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT    NOT NULL REFERENCES projects(id),
+  event_type  TEXT    NOT NULL,
+  from_phase  TEXT,
+  to_phase    TEXT,
+  agent       TEXT,
+  payload     TEXT    NOT NULL DEFAULT '{}',
+  created_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_events_project
+  ON pipeline_events(project_id, created_at);
+
+-- Phase outputs
+CREATE TABLE IF NOT EXISTS phase_outputs (
+  id          INTEGER PRIMARY KEY AUTOINCREMENT,
+  project_id  TEXT    NOT NULL REFERENCES projects(id),
+  phase       TEXT    NOT NULL,
+  output_type TEXT    NOT NULL,
+  content     TEXT    NOT NULL,
+  file_path   TEXT,
+  created_at  INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_outputs_project_phase
+  ON phase_outputs(project_id, phase);
+
+-- Trajectories
+CREATE TABLE IF NOT EXISTS trajectories (
+  id           TEXT    PRIMARY KEY,
+  project_id   TEXT    NOT NULL REFERENCES projects(id),
+  phase        TEXT    NOT NULL,
+  agent        TEXT    NOT NULL,
+  status       TEXT    NOT NULL DEFAULT 'active',
+  started_at   INTEGER NOT NULL,
+  completed_at INTEGER,
+  success      INTEGER,
+  feedback     TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_trajectories_project
+  ON trajectories(project_id, phase);
+
+-- Trajectory steps
+CREATE TABLE IF NOT EXISTS trajectory_steps (
+  id             INTEGER PRIMARY KEY AUTOINCREMENT,
+  trajectory_id  TEXT    NOT NULL REFERENCES trajectories(id),
+  action         TEXT    NOT NULL,
+  result         TEXT,
+  quality_score  REAL,
+  metadata       TEXT    NOT NULL DEFAULT '{}',
+  created_at     INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_steps_trajectory
+  ON trajectory_steps(trajectory_id, created_at);
+
+-- Sessions
+CREATE TABLE IF NOT EXISTS sessions (
+  id                TEXT    NOT NULL,
+  project_id        TEXT    REFERENCES projects(id),
+  repo_id           TEXT    REFERENCES repos(id),
+  started_at        INTEGER NOT NULL,
+  ended_at          INTEGER,
+  state             TEXT    NOT NULL DEFAULT '{}',
+  observation_count INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (id)
+);
+CREATE INDEX IF NOT EXISTS idx_sessions_project
+  ON sessions(project_id);
+
+-- Parallel work claims
+CREATE TABLE IF NOT EXISTS claims (
+  id           TEXT    PRIMARY KEY,
+  project_id   TEXT    NOT NULL REFERENCES projects(id),
+  module_name  TEXT    NOT NULL,
+  agent        TEXT    NOT NULL,
+  branch       TEXT,
+  status       TEXT    NOT NULL DEFAULT 'claimed',
+  claimed_at   INTEGER NOT NULL,
+  completed_at INTEGER,
+  result       TEXT
+);
+CREATE INDEX IF NOT EXISTS idx_claims_project
+  ON claims(project_id, status);
+`;
+
+// Individual table DDL strings — useful for tests that need to create a
+// single table in isolation without executing the full schema.
+export const TABLE_NAMES = [
+  'repos',
+  'projects',
+  'pipeline_events',
+  'phase_outputs',
+  'trajectories',
+  'trajectory_steps',
+  'sessions',
+  'claims',
+] as const;
+
+export type TableName = (typeof TABLE_NAMES)[number];