@vibesdotdev/localdb 0.0.1

package/src/core/migration-registry.ts

@@ -0,0 +1,321 @@
+/**
+ * Migration Registry
+ *
+ * Centralized registration and execution of database migrations.
+ * Consumers register their migrations with the registry, which ensures
+ * they run in order with proper error handling and version tracking.
+ */
+
+import type { Database } from 'bun:sqlite';
+import { getLogger } from '@vibesdotdev/logging';
+import { toErrorContext } from './error-context';
+
+const logger = getLogger('localdb:migrations');
+
+export interface MigrationFunction {
+	(db: Database): void | Promise<void>;
+}
+
+export interface Migration {
+	version: number;
+	name: string;
+	up: MigrationFunction;
+	down?: MigrationFunction;
+}
+
+export interface MigrationNamespace {
+	namespace: string;
+	migrations: Migration[];
+	currentVersion: number;
+}
+
+class MigrationRegistry {
+	private namespaces = new Map<string, MigrationNamespace>();
+
+	private hasVersionTable(db: Database): boolean {
+		const row = db
+			.query<
+				{ name: string },
+				[]
+			>("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'vibes_schema_versions'")
+			.get();
+		return row?.name === 'vibes_schema_versions';
+	}
+
+	private ensureVersionTable(db: Database): void {
+		if (this.hasVersionTable(db)) return;
+
+		db.exec(`
+			CREATE TABLE IF NOT EXISTS vibes_schema_versions (
+				namespace TEXT PRIMARY KEY,
+				version INTEGER NOT NULL DEFAULT 0,
+				updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+			)
+		`);
+	}
+
+	private getLegacyUserVersion(db: Database): number {
+		let lastError: Error | undefined;
+		const maxRetries = 3;
+		const baseDelay = 100;
+
+		for (let attempt = 0; attempt < maxRetries; attempt++) {
+			try {
+				const result = db.query('PRAGMA user_version').get() as { user_version: number };
+				return result.user_version;
+			} catch (error) {
+				lastError = error as Error;
+				if ((error as { code?: string })?.code === 'SQLITE_BUSY' && attempt < maxRetries - 1) {
+					const delay = baseDelay * Math.pow(2, attempt);
+					Bun.sleepSync(delay);
+					continue;
+				}
+				throw error;
+			}
+		}
+
+		throw lastError ?? new Error('All retries exhausted');
+	}
+
+	private getTrackedSchemaVersion(db: Database, namespace: string): number | null {
+		this.ensureVersionTable(db);
+
+		const row = db
+			.query<
+				{ version: number },
+				[string]
+			>('SELECT version FROM vibes_schema_versions WHERE namespace = ?')
+			.get(namespace);
+
+		return row ? row.version : null;
+	}
+
+	private bootstrapSchemaVersion(db: Database, namespace: string): number {
+		const tracked = this.getTrackedSchemaVersion(db, namespace);
+		if (tracked !== null) return tracked;
+
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			throw new Error(`Unknown migration namespace: ${namespace}`);
+		}
+
+		const legacyVersion = this.getLegacyUserVersion(db);
+		const trackedNamespaceCount =
+			db.query<{ count: number }, []>('SELECT COUNT(*) as count FROM vibes_schema_versions').get()
+				?.count ?? 0;
+
+		const bootstrapVersion =
+			trackedNamespaceCount === 0 && legacyVersion > 0 && legacyVersion <= ns.currentVersion
+				? legacyVersion
+				: 0;
+
+		this.setSchemaVersion(db, namespace, bootstrapVersion);
+		return bootstrapVersion;
+	}
+
+	/**
+	 * Register migrations for a namespace (e.g., 'atlas', 'session')
+	 */
+	register(namespace: string, migrations: Migration[]): void {
+		if (this.namespaces.has(namespace)) {
+			throw new Error(`Migration namespace '${namespace}' is already registered`);
+		}
+
+		// Sort migrations by version
+		const sorted = [...migrations].sort((a, b) => a.version - b.version);
+
+		// Validate version sequence
+		for (let i = 0; i < sorted.length; i++) {
+			const expected = i + 1;
+			const actual = sorted[i].version;
+			if (actual !== expected) {
+				throw new Error(
+					`Invalid migration sequence in '${namespace}': expected version ${expected}, got ${actual}`
+				);
+			}
+		}
+
+		const currentVersion = sorted.length > 0 ? sorted[sorted.length - 1].version : 0;
+
+		this.namespaces.set(namespace, {
+			namespace,
+			migrations: sorted,
+			currentVersion
+		});
+
+		logger.debug(`Registered ${migrations.length} migration(s) for namespace '${namespace}'`);
+	}
+
+	/**
+	 * Get current schema version from database
+	 */
+	getSchemaVersion(db: Database, namespace: string): number {
+		return this.bootstrapSchemaVersion(db, namespace);
+	}
+
+	/**
+	 * Set schema version in database
+	 */
+	private setSchemaVersion(db: Database, namespace: string, version: number): void {
+		this.ensureVersionTable(db);
+
+		db.query(
+			`INSERT INTO vibes_schema_versions (namespace, version, updated_at)
+			 VALUES (?, ?, datetime('now'))
+			 ON CONFLICT(namespace) DO UPDATE SET
+			   version = excluded.version,
+			   updated_at = datetime('now')`
+		).run(namespace, version);
+	}
+
+	/**
+	 * Check if database needs migration
+	 */
+	needsMigration(db: Database, namespace: string): boolean {
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			throw new Error(`Unknown migration namespace: ${namespace}`);
+		}
+
+		const currentVersion = this.getSchemaVersion(db, namespace);
+		return currentVersion < ns.currentVersion;
+	}
+
+	/**
+	 * Check if database is from an incompatible/old migration system
+	 * This happens when the version is higher than our max (legacy system)
+	 */
+	isIncompatibleDatabase(db: Database, namespace: string): boolean {
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			return false;
+		}
+
+		const trackedVersion = this.getTrackedSchemaVersion(db, namespace);
+		if (trackedVersion === null) {
+			return false;
+		}
+
+		return trackedVersion > ns.currentVersion;
+	}
+
+	/**
+	 * Run all pending migrations for a namespace
+	 */
+	async runMigrations(db: Database, namespace: string): Promise<void> {
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			throw new Error(`Unknown migration namespace: ${namespace}`);
+		}
+
+		let currentVersion = this.getSchemaVersion(db, namespace);
+
+		logger.debug(
+			`Running migrations for '${namespace}' (v${currentVersion} → v${ns.currentVersion})`
+		);
+
+		for (const migration of ns.migrations) {
+			if (migration.version > currentVersion) {
+				logger.debug(`Applying migration ${migration.version}: ${migration.name}`);
+
+				try {
+					await migration.up(db);
+					currentVersion = migration.version;
+					this.setSchemaVersion(db, namespace, currentVersion);
+					logger.debug(`[LocalDB] Migration ${migration.version} completed`);
+				} catch (error) {
+					logger.error(
+						`[LocalDB] Migration ${migration.version} failed:`,
+						toErrorContext(error)
+					);
+					throw new Error(`Migration ${migration.version} (${migration.name}) failed: ${error}`);
+				}
+			}
+		}
+
+		logger.debug(`[LocalDB] All migrations completed for '${namespace}'`);
+	}
+
+	/**
+	 * Get migration status for all namespaces
+	 */
+	getStatus(): Array<{
+		namespace: string;
+		currentVersion: number;
+		targetVersion: number;
+		pendingMigrations: number;
+	}> {
+		const status: Array<{
+			namespace: string;
+			currentVersion: number;
+			targetVersion: number;
+			pendingMigrations: number;
+		}> = [];
+
+		for (const ns of this.namespaces.values()) {
+			status.push({
+				namespace: ns.namespace,
+				currentVersion: 0, // Will be determined per-database
+				targetVersion: ns.currentVersion,
+				pendingMigrations: 0 // Will be determined per-database
+			});
+		}
+
+		return status;
+	}
+
+	/**
+	 * Get migration status for a specific database and namespace
+	 */
+	getDatabaseStatus(
+		db: Database,
+		namespace: string
+	): {
+		namespace: string;
+		currentVersion: number;
+		targetVersion: number;
+		pendingMigrations: number;
+		migrations: Array<{ version: number; name: string; applied: boolean }>;
+	} {
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			throw new Error(`Unknown migration namespace: ${namespace}`);
+		}
+
+		const currentVersion = this.getSchemaVersion(db, namespace);
+		const pending = Math.max(0, ns.currentVersion - currentVersion);
+
+		return {
+			namespace,
+			currentVersion,
+			targetVersion: ns.currentVersion,
+			pendingMigrations: pending,
+			migrations: ns.migrations.map((m) => ({
+				version: m.version,
+				name: m.name,
+				applied: m.version <= currentVersion
+			}))
+		};
+	}
+
+	/**
+	 * List all registered namespaces
+	 */
+	listNamespaces(): string[] {
+		return Array.from(this.namespaces.keys());
+	}
+
+	/**
+	 * Get migrations for a namespace
+	 */
+	getMigrations(namespace: string): Migration[] {
+		const ns = this.namespaces.get(namespace);
+		if (!ns) {
+			throw new Error(`Unknown migration namespace: ${namespace}`);
+		}
+		return [...ns.migrations];
+	}
+}
+
+// Singleton instance
+export const migrationRegistry = new MigrationRegistry();

package/src/core/runtime.ts

@@ -0,0 +1,17 @@
+function hasRuntimeProcessVersion(name: 'bun' | 'node'): boolean {
+	if (typeof process === 'undefined') return false;
+	const value = process.versions?.[name];
+	return typeof value === 'string' && value.length > 0;
+}
+
+export function isLocaldbBrowserRuntime(scope: typeof globalThis = globalThis): boolean {
+	const globals = scope as typeof globalThis & Record<string, unknown>;
+	const hasWindow = typeof globals.window !== 'undefined' && globals.window !== null;
+	const hasDocument = typeof globals.document !== 'undefined' && globals.document !== null;
+	const hasServerRuntime = hasRuntimeProcessVersion('bun') || hasRuntimeProcessVersion('node');
+	return hasDocument || (hasWindow && !hasServerRuntime);
+}
+
+export function isLocaldbServerRuntime(scope: typeof globalThis = globalThis): boolean {
+	return !isLocaldbBrowserRuntime(scope);
+}

package/src/dev.localdb.cli-group.descriptor.ts

@@ -0,0 +1,20 @@
+/**
+ * Dev LocalDB CLI Group Descriptor
+ *
+ * Groups LocalDB development commands under `vibes dev localdb`.
+ */
+
+import type { CLIGroupAssetDescriptor } from '@vibesdotdev/cli/schemas/types';
+
+const descriptor: CLIGroupAssetDescriptor = {
+	kind: 'cli/group',
+	id: 'dev.localdb',
+	name: 'localdb',
+	description: 'Manage local SQLite databases (migrations, connections, status)',
+	parent: 'dev',
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/dev.localdb.context.descriptor.ts

@@ -0,0 +1,13 @@
+/**
+ * Dev LocalDB Context Descriptor
+ *
+ * Provides LocalDB API for dev commands and workflows.
+ */
+
+import { createContextDescriptor } from '@vibesdotdev/runtime';
+
+export default createContextDescriptor({
+	id: 'dev/localdb',
+	description: 'LocalDB API for managing local SQLite databases.',
+	hardware: ['consumer']
+});

package/src/dev.localdb.context.impl.consumer.ts

@@ -0,0 +1,12 @@
+/**
+ * Dev LocalDB Context Implementation (Consumer)
+ */
+
+import type { LocaldbApi } from './schemas/api';
+
+export default {
+	provide: async (): Promise<LocaldbApi> => {
+		const { localdb } = await import('./index');
+		return localdb;
+	}
+};

package/src/index.ts

@@ -0,0 +1,28 @@
+/**
+ * Local Database (LocalDB)
+ *
+ * Unified SQLite database management for vibes dev toolkit.
+ * Provides connection pooling, migration management, and consistent configuration.
+ */
+
+export type {
+	LocaldbApi,
+	LocaldbRawDatabase,
+	LocalDatabase as LocalDatabaseInterface,
+	Migration,
+	MigrationFunction,
+	ConnectionStats,
+	ConnectionPoolApi,
+	MigrationRegistryApi
+} from './schemas/api';
+
+export { LocalDatabase, localdb } from './core/database';
+export { connectionPool } from './core/connection-pool';
+export { migrationRegistry } from './core/migration-registry';
+export {
+	loadMigrationSQL,
+	loadMigrationSQLSync,
+	listMigrationFiles,
+	parseVersionFromFilename,
+	parseMigrationName
+} from './migrations/load-sql';

package/src/localdb.cloud.plugin.ts

@@ -0,0 +1,24 @@
+/**
+ * LocalDB Cloud Plugin
+ *
+ * Cloud-bundle-safe variant of `localdb.plugin.ts`.
+ *
+ * LocalDB manages on-disk SQLite (libsql / better-sqlite3) for consumer
+ * environments. Every loader in `localdb.plugin.ts` is `.impl.consumer.ts`
+ * and reaches `bun:sqlite` / `node:fs`. None of it is reachable from a
+ * cloudflare-workers bundle.
+ *
+ * ai-web's plugin chain still loads localdb for shape uniformity per
+ * `apps/ai-web (consolidated)/SPEC.md` line 14. This empty cloud variant satisfies
+ * the chain without pulling consumer-only code into the cloud bundle.
+ */
+
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+
+export default createRuntimePlugin({
+	// Same id as the consumer `localdb` plugin per AGENT-CONSTITUTION
+	// §PLUGIN ID PARITY: the bare id is the public capability.
+	id: 'localdb',
+	name: 'LocalDB (Cloud)',
+	description: 'Cloud-safe localdb registration — empty (localdb is consumer-only)'
+});

package/src/localdb.plugin.ts

@@ -0,0 +1,43 @@
+/**
+ * LocalDB Plugin
+ *
+ * Local SQLite database management — migrations, connections, status.
+ */
+
+import { createRuntimePlugin, loader } from '@vibesdotdev/runtime';
+
+// CLI
+import localdbGroup from './dev.localdb.cli-group.descriptor.ts';
+import localdbMigrate from './cli/commands/migrate/dev.localdb.migrate.cli-command.descriptor.ts';
+import localdbNamespaces from './cli/commands/namespaces/dev.localdb.namespaces.cli-command.descriptor.ts';
+import localdbPools from './cli/commands/pools/dev.localdb.pools.cli-command.descriptor.ts';
+import localdbQuery from './cli/commands/query/dev.localdb.query.cli-command.descriptor.ts';
+import localdbStatus from './cli/commands/status/dev.localdb.status.cli-command.descriptor.ts';
+
+// Context
+import localdbContextDescriptor from './dev.localdb.context.descriptor.ts';
+
+export default createRuntimePlugin({
+	id: 'localdb',
+	name: 'LocalDB',
+	description: 'Local SQLite database management — migrations, connections, status',
+
+	descriptors: [
+		localdbGroup,
+		localdbMigrate,
+		localdbNamespaces,
+		localdbPools,
+		localdbQuery,
+		localdbStatus,
+		localdbContextDescriptor
+	],
+
+	loaders: [
+		loader('dev.localdb.migrate', 'consumer', () => import('./cli/commands/migrate/dev.localdb.migrate.cli-command.impl.consumer.ts')),
+		loader('dev.localdb.namespaces', () => import('./cli/commands/namespaces/dev.localdb.namespaces.cli-command.impl.ts')),
+		loader('dev.localdb.pools', () => import('./cli/commands/pools/dev.localdb.pools.cli-command.impl.ts')),
+		loader('dev.localdb.query', 'consumer', () => import('./cli/commands/query/dev.localdb.query.cli-command.impl.consumer.ts')),
+		loader('dev.localdb.status', 'consumer', () => import('./cli/commands/status/dev.localdb.status.cli-command.impl.consumer.ts')),
+		loader('dev/localdb', 'consumer', () => import('./dev.localdb.context.impl.consumer.ts'))
+	]
+});

package/src/migrations/atlas/001-initial-schema.sql

@@ -0,0 +1,173 @@
+-- Atlas Migration 001: Initial Schema
+-- Creates all tables for code indexing
+
+-- Index configurations
+CREATE TABLE IF NOT EXISTS index_configs (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL,
+  branch TEXT NOT NULL DEFAULT 'main',
+  git_commit TEXT,
+  workspace_path TEXT NOT NULL,
+  paths TEXT NOT NULL,
+  exclude_paths TEXT NOT NULL,
+  languages TEXT NOT NULL,
+  storage_backend TEXT NOT NULL,
+  runtime TEXT NOT NULL,
+  package_manager TEXT NOT NULL,
+  enable_embeddings INTEGER NOT NULL DEFAULT 0,
+  redact_patterns TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+);
+
+CREATE INDEX idx_configs_project ON index_configs(project_id);
+
+-- Index runs
+CREATE TABLE IF NOT EXISTS index_runs (
+  id TEXT PRIMARY KEY,
+  config_id TEXT NOT NULL,
+  status TEXT NOT NULL CHECK(status IN ('pending', 'running', 'completed', 'failed', 'cancelled')),
+  started_at TEXT NOT NULL,
+  completed_at TEXT,
+  files_processed INTEGER NOT NULL DEFAULT 0,
+  symbols_captured INTEGER NOT NULL DEFAULT 0,
+  errors TEXT NOT NULL DEFAULT '[]',
+  worker_job_id TEXT,
+  duration_ms INTEGER,
+  memory_usage_bytes INTEGER,
+  cpu_usage_percent REAL,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (config_id) REFERENCES index_configs(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_runs_config ON index_runs(config_id);
+CREATE INDEX idx_runs_status ON index_runs(status);
+CREATE INDEX idx_runs_started_at ON index_runs(started_at DESC);
+
+-- Symbols
+CREATE TABLE IF NOT EXISTS symbols (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  kind TEXT NOT NULL CHECK(kind IN (
+    'class', 'function', 'method', 'variable', 'constant',
+    'interface', 'type', 'enum', 'namespace', 'module',
+    'property', 'parameter', 'import', 'export'
+  )),
+  language TEXT NOT NULL,
+  file_path TEXT NOT NULL,
+  start_line INTEGER NOT NULL,
+  start_column INTEGER NOT NULL,
+  end_line INTEGER NOT NULL,
+  end_column INTEGER NOT NULL,
+  signature TEXT,
+  documentation TEXT,
+  exported INTEGER NOT NULL DEFAULT 0,
+  parent_symbol_id TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (run_id) REFERENCES index_runs(id) ON DELETE CASCADE,
+  FOREIGN KEY (parent_symbol_id) REFERENCES symbols(id) ON DELETE SET NULL
+);
+
+CREATE INDEX idx_symbols_run ON symbols(run_id);
+CREATE INDEX idx_symbols_name ON symbols(name);
+CREATE INDEX idx_symbols_file ON symbols(file_path);
+CREATE INDEX idx_symbols_kind ON symbols(kind);
+CREATE INDEX idx_symbols_parent ON symbols(parent_symbol_id);
+
+-- Full-text search index for symbols
+CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(
+  name,
+  signature,
+  documentation,
+  content=symbols,
+  content_rowid=rowid
+);
+
+-- Triggers to keep FTS index in sync
+CREATE TRIGGER IF NOT EXISTS symbols_fts_insert AFTER INSERT ON symbols BEGIN
+  INSERT INTO symbols_fts(rowid, name, signature, documentation)
+  VALUES (new.rowid, new.name, new.signature, new.documentation);
+END;
+
+CREATE TRIGGER IF NOT EXISTS symbols_fts_delete AFTER DELETE ON symbols BEGIN
+  DELETE FROM symbols_fts WHERE rowid = old.rowid;
+END;
+
+CREATE TRIGGER IF NOT EXISTS symbols_fts_update AFTER UPDATE ON symbols BEGIN
+  DELETE FROM symbols_fts WHERE rowid = old.rowid;
+  INSERT INTO symbols_fts(rowid, name, signature, documentation)
+  VALUES (new.rowid, new.name, new.signature, new.documentation);
+END;
+
+-- File metadata
+CREATE TABLE IF NOT EXISTS files (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  path TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  size_bytes INTEGER NOT NULL,
+  language TEXT NOT NULL,
+  lines_of_code INTEGER NOT NULL DEFAULT 0,
+  imports TEXT NOT NULL DEFAULT '[]',
+  exports TEXT NOT NULL DEFAULT '[]',
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (run_id) REFERENCES index_runs(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_files_run ON files(run_id);
+CREATE INDEX idx_files_path ON files(path);
+CREATE INDEX idx_files_checksum ON files(checksum);
+
+-- Dependency edges
+CREATE TABLE IF NOT EXISTS edges (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  source_file_id TEXT,
+  source_symbol_id TEXT,
+  target_file_id TEXT,
+  target_symbol_id TEXT,
+  edge_type TEXT NOT NULL CHECK(edge_type IN (
+    'imports', 'calls', 'extends', 'implements', 'references'
+  )),
+  weight INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (run_id) REFERENCES index_runs(id) ON DELETE CASCADE,
+  FOREIGN KEY (source_file_id) REFERENCES files(id) ON DELETE CASCADE,
+  FOREIGN KEY (source_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE,
+  FOREIGN KEY (target_file_id) REFERENCES files(id) ON DELETE CASCADE,
+  FOREIGN KEY (target_symbol_id) REFERENCES symbols(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_edges_run ON edges(run_id);
+CREATE INDEX idx_edges_source_file ON edges(source_file_id);
+CREATE INDEX idx_edges_source_symbol ON edges(source_symbol_id);
+CREATE INDEX idx_edges_target_file ON edges(target_file_id);
+CREATE INDEX idx_edges_target_symbol ON edges(target_symbol_id);
+CREATE INDEX idx_edges_type ON edges(edge_type);
+
+-- Embeddings (for semantic search)
+CREATE TABLE IF NOT EXISTS embeddings (
+  id TEXT PRIMARY KEY,
+  run_id TEXT NOT NULL,
+  symbol_id TEXT,
+  file_id TEXT,
+  vector_id TEXT NOT NULL,
+  embedding BLOB,
+  metadata TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  FOREIGN KEY (run_id) REFERENCES index_runs(id) ON DELETE CASCADE,
+  FOREIGN KEY (symbol_id) REFERENCES symbols(id) ON DELETE CASCADE,
+  FOREIGN KEY (file_id) REFERENCES files(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_embeddings_run ON embeddings(run_id);
+CREATE INDEX idx_embeddings_symbol ON embeddings(symbol_id);
+CREATE INDEX idx_embeddings_file ON embeddings(file_id);
+
+-- Performance optimizations
+PRAGMA journal_mode = WAL;
+PRAGMA synchronous = NORMAL;
+PRAGMA cache_size = -64000;  -- 64MB cache
+PRAGMA temp_store = memory;
+PRAGMA mmap_size = 30000000000;  -- 30GB mmap

package/src/migrations/atlas/002-lang-server-fields.sql

@@ -0,0 +1,12 @@
+-- Atlas Migration 002: Language Server Integration Fields
+-- Adds fields for lang server enrichment and validation
+
+-- Add lang server config options to index_configs
+ALTER TABLE index_configs ADD COLUMN enable_lang_server_enrichment INTEGER NOT NULL DEFAULT 0;
+ALTER TABLE index_configs ADD COLUMN enable_lang_server_validation INTEGER NOT NULL DEFAULT 1;
+ALTER TABLE index_configs ADD COLUMN lang_server_timeout INTEGER NOT NULL DEFAULT 2000;
+
+-- Add lang server enrichment fields to symbols
+ALTER TABLE symbols ADD COLUMN type_signature TEXT;
+ALTER TABLE symbols ADD COLUMN has_errors INTEGER DEFAULT 0;
+ALTER TABLE symbols ADD COLUMN error_messages TEXT;