squish-memory 1.0.2 → 1.2.0

package/dist/db/schema/generator.js

@@ -0,0 +1,108 @@
+/**
+ * Migration Generator - Creates migrations from schema definitions
+ *
+ * This utility generates ALTER TABLE statements from schema column definitions,
+ * eliminating the need for inline column arrays in migration files.
+ */
+import { logger } from '../../core/logger.js';
+/**
+ * Get existing columns for a table
+ */
+function getExistingColumns(sqlite, tableName) {
+    try {
+        const tableInfo = sqlite.prepare(`PRAGMA table_info(${tableName})`).all();
+        return new Set(tableInfo.map(col => col.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+/**
+ * Get existing indexes for a table
+ */
+function getExistingIndexes(sqlite, tableName) {
+    try {
+        const indexes = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='index' AND tbl_name=?").all(tableName);
+        return new Set(indexes.map(idx => idx.name));
+    }
+    catch {
+        return new Set();
+    }
+}
+/**
+ * Generate and run column migrations for a table schema
+ */
+export async function migrateTable(sqlite, schema) {
+    const existingColumns = getExistingColumns(sqlite, schema.name);
+    for (const [columnName, definition] of Object.entries(schema.columns)) {
+        if (!existingColumns.has(columnName)) {
+            const sql = generateAlterTable(schema.name, columnName, definition);
+            try {
+                sqlite.exec(sql);
+                logger.info(`Migration: Added column ${columnName} to ${schema.name}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                if (msg.includes('duplicate column name')) {
+                    logger.debug(`Migration skipped for ${schema.name}.${columnName}: already exists`);
+                }
+                else {
+                    throw new Error(`Migration failed for ${schema.name}.${columnName}: ${msg}`);
+                }
+            }
+        }
+    }
+    // Handle indexes
+    if (schema.indexes) {
+        await migrateIndexes(sqlite, schema.name, schema.indexes);
+    }
+}
+/**
+ * Generate and run index migrations
+ */
+export async function migrateIndexes(sqlite, tableName, indexes) {
+    const existingIndexes = getExistingIndexes(sqlite, tableName);
+    for (const indexDef of indexes) {
+        if (!existingIndexes.has(indexDef.name)) {
+            const sql = generateCreateIndex(tableName, indexDef);
+            try {
+                sqlite.exec(sql);
+                logger.info(`Migration: Added index ${indexDef.name}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                logger.warn(`Index migration failed for ${indexDef.name}: ${msg}`);
+            }
+        }
+    }
+}
+/**
+ * Generate ALTER TABLE ADD COLUMN statement
+ */
+function generateAlterTable(tableName, columnName, definition) {
+    let sql = `ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition.type}`;
+    if (definition.default) {
+        sql += ` DEFAULT ${definition.default}`;
+    }
+    return sql;
+}
+/**
+ * Generate CREATE INDEX statement
+ */
+function generateCreateIndex(tableName, indexDef) {
+    const columns = indexDef.columns.join(', ');
+    const unique = indexDef.unique ? 'UNIQUE ' : '';
+    return `CREATE ${unique}INDEX IF NOT EXISTS ${indexDef.name} ON ${tableName}(${columns})`;
+}
+/**
+ * Run all table migrations from schema list
+ */
+export async function runAllSchemaMigrations(sqlite, schemas) {
+    for (const schema of schemas) {
+        const tableCheck = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name=?").get(schema.name);
+        if (tableCheck) {
+            await migrateTable(sqlite, schema);
+        }
+    }
+}
+//# sourceMappingURL=generator.js.map

package/dist/db/schema/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Schema Index - Table schema definitions
+ *
+ * DEPRECATED: This module was previously used to aggregate table schemas.
+ * Table definitions are now in db/bootstrap.ts for first-time setup
+ * and db/schema/*.ts for migration column definitions.
+ *
+ * These exports remain for backward compatibility but return empty arrays.
+ */
+import type { TableSchema } from './generator.js';
+export { memoriesSchema } from './memories.js';
+export { learningsSchema } from './learnings.js';
+export { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from './beliefs.js';
+/**
+ * Table schemas for migration utilities
+ * @deprecated Use db/schema/memories.ts, db/schema/learnings.ts, db/schema/beliefs.ts directly
+ */
+export declare const tableSchemas: TableSchema[];
+/**
+ * Generate complete SQLite schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export declare function generateSqliteSchema(): string;
+/**
+ * Generate complete PostgreSQL schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export declare function generatePostgresSchema(): string;
+/**
+ * Get all SQLite table definitions in order
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export declare function getAllSqliteTables(): string[];
+/**
+ * Get all PostgreSQL table definitions in order
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export declare function getAllPostgresTables(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/db/schema/index.js

@@ -0,0 +1,51 @@
+/**
+ * Schema Index - Table schema definitions
+ *
+ * DEPRECATED: This module was previously used to aggregate table schemas.
+ * Table definitions are now in db/bootstrap.ts for first-time setup
+ * and db/schema/*.ts for migration column definitions.
+ *
+ * These exports remain for backward compatibility but return empty arrays.
+ */
+// Re-export migration schemas for compatibility
+export { memoriesSchema } from './memories.js';
+export { learningsSchema } from './learnings.js';
+export { beliefsSchema, beliefMemorySourcesSchema, beliefEdgesSchema } from './beliefs.js';
+/**
+ * Table schemas for migration utilities
+ * @deprecated Use db/schema/memories.ts, db/schema/learnings.ts, db/schema/beliefs.ts directly
+ */
+export const tableSchemas = [];
+/**
+ * Generate complete SQLite schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export function generateSqliteSchema() {
+    console.warn('DEPRECATED: generateSqliteSchema() - table definitions are in db/bootstrap.ts');
+    return '';
+}
+/**
+ * Generate complete PostgreSQL schema SQL
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export function generatePostgresSchema() {
+    console.warn('DEPRECATED: generatePostgresSchema() - table definitions are in db/bootstrap.ts');
+    return '';
+}
+/**
+ * Get all SQLite table definitions in order
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export function getAllSqliteTables() {
+    console.warn('DEPRECATED: getAllSqliteTables() - table definitions are in db/bootstrap.ts');
+    return [];
+}
+/**
+ * Get all PostgreSQL table definitions in order
+ * @deprecated Table definitions moved to db/bootstrap.ts
+ */
+export function getAllPostgresTables() {
+    console.warn('DEPRECATED: getAllPostgresTables() - table definitions are in db/bootstrap.ts');
+    return [];
+}
+//# sourceMappingURL=index.js.map

package/dist/db/schema/learnings.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Learnings table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const learningsSchema: TableSchema;
+//# sourceMappingURL=learnings.d.ts.map

package/dist/db/schema/learnings.js

@@ -0,0 +1,30 @@
+/**
+ * Learnings table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const learningsSchema = {
+    name: 'learnings',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        type: { type: 'TEXT' },
+        content: { type: 'TEXT' },
+        summary: { type: 'TEXT' },
+        source: { type: 'TEXT' },
+        confidence: { type: 'INTEGER', default: '50' },
+        confidence_level: { type: 'TEXT', default: "'speculative'" },
+        tags: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        embedding: { type: 'BLOB' },
+        folder_path: { type: 'TEXT' },
+        project_path: { type: 'TEXT' },
+        is_private: { type: 'INTEGER', default: '0' },
+        has_secrets: { type: 'INTEGER', default: '0' },
+        relevance_score: { type: 'INTEGER', default: '50' },
+        memory_id: { type: 'TEXT' },
+        is_imported: { type: 'INTEGER', default: '0' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=learnings.js.map

package/dist/db/schema/memories.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Memories table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+import type { TableSchema } from '../generator.js';
+export declare const memoriesSchema: TableSchema;
+//# sourceMappingURL=memories.d.ts.map

package/dist/db/schema/memories.js

@@ -0,0 +1,81 @@
+/**
+ * Memories table schema for migrations
+ * Column definitions for ALTER TABLE migrations
+ */
+export const memoriesSchema = {
+    name: 'memories',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        project_id: { type: 'TEXT' },
+        user_id: { type: 'TEXT' },
+        type: { type: 'TEXT' },
+        content: { type: 'TEXT' },
+        summary: { type: 'TEXT' },
+        embedding_json: { type: 'TEXT' },
+        embedding: { type: 'BLOB' },
+        source: { type: 'TEXT' },
+        confidence: { type: 'INTEGER', default: '50' },
+        confidence_level: { type: 'TEXT', default: "'speculative'" },
+        tags: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        is_private: { type: 'INTEGER', default: '0' },
+        has_secrets: { type: 'INTEGER', default: '0' },
+        relevance_score: { type: 'INTEGER', default: '50' },
+        is_active: { type: 'INTEGER', default: '1' },
+        expires_at: { type: 'INTEGER' },
+        access_count: { type: 'INTEGER', default: '0' },
+        last_accessed_at: { type: 'INTEGER' },
+        is_merged: { type: 'INTEGER', default: '0' },
+        merged_into_id: { type: 'TEXT' },
+        merged_at: { type: 'INTEGER' },
+        is_canonical: { type: 'INTEGER', default: '0' },
+        merge_source_ids: { type: 'TEXT' },
+        is_mergeable: { type: 'INTEGER', default: '1' },
+        merge_version: { type: 'INTEGER', default: '1' },
+        namespace_id: { type: 'TEXT' },
+        namespace_path: { type: 'TEXT' },
+        has_l0_abstract: { type: 'INTEGER', default: '0' },
+        has_l1_overview: { type: 'INTEGER', default: '0' },
+        last_layer_update: { type: 'INTEGER' },
+        importance_score: { type: 'INTEGER', default: '50' },
+        importance_decay_rate: { type: 'INTEGER', default: '30' },
+        last_importance_recalc: { type: 'INTEGER' },
+        retrieval_priority: { type: 'INTEGER', default: '50' },
+        tokens_estimate: { type: 'INTEGER', default: '0' },
+        consolidated_into: { type: 'TEXT' },
+        consolidated_at: { type: 'INTEGER' },
+        is_consolidated: { type: 'INTEGER', default: '0' },
+        sector: { type: 'TEXT', default: "'episodic'" },
+        tier: { type: 'TEXT', default: "'hot'" },
+        status: { type: 'TEXT', default: "'active'" },
+        encrypted_content: { type: 'TEXT' },
+        encryption_nonce: { type: 'TEXT' },
+        is_encrypted: { type: 'INTEGER', default: '0' },
+        context_status: { type: 'TEXT', default: "'out-of-context'" },
+        decay_rate: { type: 'INTEGER', default: '30' },
+        coactivation_score: { type: 'INTEGER', default: '0' },
+        last_decay_at: { type: 'INTEGER' },
+        agent_id: { type: 'TEXT' },
+        agent_role: { type: 'TEXT' },
+        visibility_scope: { type: 'TEXT', default: "'private'" },
+        is_protected: { type: 'INTEGER', default: '0' },
+        is_pinned: { type: 'INTEGER', default: '0' },
+        is_immutable: { type: 'INTEGER', default: '0' },
+        write_scope: { type: 'TEXT' },
+        read_scope: { type: 'TEXT' },
+        triggered_by: { type: 'TEXT' },
+        capture_reason: { type: 'TEXT' },
+        last_used_at: { type: 'INTEGER' },
+        usage_count: { type: 'INTEGER', default: '0' },
+        valid_from: { type: 'INTEGER' },
+        valid_to: { type: 'INTEGER' },
+        recorded_at: { type: 'INTEGER' },
+        superseded_by: { type: 'TEXT' },
+        version: { type: 'INTEGER', default: '1' },
+        place_id: { type: 'TEXT' },
+        place_sort_order: { type: 'INTEGER', default: '0' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=memories.js.map

package/dist/db/schema/projects.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from '../generator.js';
+export declare const projectsSchema: TableSchema;
+export declare const usersSchema: TableSchema;
+//# sourceMappingURL=projects.d.ts.map

package/dist/db/schema/projects.js

@@ -0,0 +1,31 @@
+export const projectsSchema = {
+    name: 'projects',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        name: { type: 'TEXT' },
+        path: { type: 'TEXT' },
+        description: { type: 'TEXT' },
+        metadata: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+    indexes: [
+        {
+            name: 'projects_path_idx',
+            columns: ['path'],
+        },
+    ],
+};
+export const usersSchema = {
+    name: 'users',
+    columns: {
+        id: { type: 'TEXT', primary: true },
+        external_id: { type: 'TEXT' },
+        name: { type: 'TEXT' },
+        email: { type: 'TEXT' },
+        preferences: { type: 'TEXT' },
+        created_at: { type: 'INTEGER' },
+        updated_at: { type: 'INTEGER' },
+    },
+};
+//# sourceMappingURL=projects.js.map

package/dist/db/schema/tables/context-sessions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Context Sessions Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const contextSessionsTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=context-sessions.d.ts.map

package/dist/db/schema/tables/context-sessions.js

@@ -0,0 +1,37 @@
+/**
+ * Context Sessions Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export const contextSessionsTable = {
+    sqlite: `
+CREATE TABLE IF NOT EXISTS context_sessions (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  status TEXT DEFAULT 'active',
+  memory_ids TEXT,
+  token_count INTEGER DEFAULT 0,
+  started_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  ended_at INTEGER,
+  metadata TEXT
+);
+
+CREATE INDEX IF NOT EXISTS context_sessions_project_idx ON context_sessions(project_id);
+CREATE INDEX IF NOT EXISTS context_sessions_session_idx ON context_sessions(session_id);`,
+    postgres: `
+CREATE TABLE IF NOT EXISTS context_sessions (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+  session_id TEXT NOT NULL,
+  status TEXT DEFAULT 'active',
+  memory_ids TEXT[],
+  token_count INTEGER DEFAULT 0,
+  started_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+  ended_at TIMESTAMPTZ,
+  metadata JSONB
+);
+
+CREATE INDEX IF NOT EXISTS context_sessions_project_idx ON context_sessions(project_id);
+CREATE INDEX IF NOT EXISTS context_sessions_session_idx ON context_sessions(session_id);`,
+};
+//# sourceMappingURL=context-sessions.js.map

package/dist/db/schema/tables/conversations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Conversations Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const conversationsTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=conversations.d.ts.map

package/dist/db/schema/tables/conversations.js

@@ -0,0 +1,47 @@
+/**
+ * Conversations Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export const conversationsTable = {
+    sqlite: `
+CREATE TABLE IF NOT EXISTS conversations (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+  session_id TEXT NOT NULL,
+  title TEXT,
+  summary TEXT,
+  message_count INTEGER DEFAULT 0,
+  token_count INTEGER DEFAULT 0,
+  started_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  ended_at INTEGER,
+  metadata TEXT,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  updated_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS conversations_project_idx ON conversations(project_id);
+CREATE INDEX IF NOT EXISTS conversations_session_idx ON conversations(session_id);
+CREATE INDEX IF NOT EXISTS conversations_started_idx ON conversations(started_at);`,
+    postgres: `
+CREATE TABLE IF NOT EXISTS conversations (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+  user_id UUID REFERENCES users(id) ON DELETE SET NULL,
+  session_id TEXT NOT NULL,
+  title TEXT,
+  summary TEXT,
+  message_count INTEGER DEFAULT 0,
+  token_count INTEGER DEFAULT 0,
+  started_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+  ended_at TIMESTAMPTZ,
+  metadata JSONB,
+  created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS conversations_project_idx ON conversations(project_id);
+CREATE INDEX IF NOT EXISTS conversations_session_idx ON conversations(session_id);
+CREATE INDEX IF NOT EXISTS conversations_started_idx ON conversations(started_at);`,
+};
+//# sourceMappingURL=conversations.js.map

package/dist/db/schema/tables/core-memory.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Core Memory Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const coreMemoryTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=core-memory.d.ts.map

package/dist/db/schema/tables/core-memory.js

@@ -0,0 +1,41 @@
+/**
+ * Core Memory Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export const coreMemoryTable = {
+    sqlite: `
+CREATE TABLE IF NOT EXISTS core_memory (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  memory_type TEXT NOT NULL,
+  content TEXT NOT NULL,
+  embedding_json TEXT,
+  embedding BLOB,
+  importance INTEGER DEFAULT 50,
+  metadata TEXT,
+  tokens_estimate INTEGER DEFAULT 0,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  updated_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS core_memory_project_idx ON core_memory(project_id);
+CREATE INDEX IF NOT EXISTS core_memory_type_idx ON core_memory(memory_type);`,
+    postgres: `
+CREATE TABLE IF NOT EXISTS core_memory (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+  memory_type TEXT NOT NULL,
+  content TEXT NOT NULL,
+  embedding_json TEXT,
+  embedding vector(1536),
+  importance INTEGER DEFAULT 50,
+  metadata JSONB,
+  tokens_estimate INTEGER DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS core_memory_project_idx ON core_memory(project_id);
+CREATE INDEX IF NOT EXISTS core_memory_type_idx ON core_memory(memory_type);`,
+};
+//# sourceMappingURL=core-memory.js.map

package/dist/db/schema/tables/entities.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Entities Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const entitiesTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=entities.d.ts.map

package/dist/db/schema/tables/entities.js

@@ -0,0 +1,39 @@
+/**
+ * Entities Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export const entitiesTable = {
+    sqlite: `
+CREATE TABLE IF NOT EXISTS entities (
+  id TEXT PRIMARY KEY,
+  project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  entity_type TEXT,
+  aliases TEXT,
+  metadata TEXT,
+  last_mentioned_at INTEGER,
+  mention_count INTEGER DEFAULT 0,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL,
+  updated_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS entities_project_idx ON entities(project_id);
+CREATE INDEX IF NOT EXISTS entities_name_idx ON entities(name);`,
+    postgres: `
+CREATE TABLE IF NOT EXISTS entities (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  project_id UUID REFERENCES projects(id) ON DELETE CASCADE,
+  name TEXT NOT NULL,
+  entity_type TEXT,
+  aliases TEXT[],
+  metadata JSONB,
+  last_mentioned_at TIMESTAMPTZ,
+  mention_count INTEGER DEFAULT 0,
+  created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL,
+  updated_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS entities_project_idx ON entities(project_id);
+CREATE INDEX IF NOT EXISTS entities_name_idx ON entities(name);`,
+};
+//# sourceMappingURL=entities.js.map

package/dist/db/schema/tables/entity-relations.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Entity Relations Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const entityRelationsTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=entity-relations.d.ts.map

package/dist/db/schema/tables/entity-relations.js

@@ -0,0 +1,31 @@
+/**
+ * Entity Relations Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export const entityRelationsTable = {
+    sqlite: `
+CREATE TABLE IF NOT EXISTS entity_relations (
+  id TEXT PRIMARY KEY,
+  entity_id TEXT NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  related_entity_id TEXT NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  relation_type TEXT,
+  strength REAL DEFAULT 0.5,
+  created_at INTEGER DEFAULT (strftime('%s','now')) NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS entity_relations_entity_idx ON entity_relations(entity_id);
+CREATE INDEX IF NOT EXISTS entity_relations_related_idx ON entity_relations(related_entity_id);`,
+    postgres: `
+CREATE TABLE IF NOT EXISTS entity_relations (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  related_entity_id UUID NOT NULL REFERENCES entities(id) ON DELETE CASCADE,
+  relation_type TEXT,
+  strength REAL DEFAULT 0.5,
+  created_at TIMESTAMPTZ DEFAULT NOW() NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS entity_relations_entity_idx ON entity_relations(entity_id);
+CREATE INDEX IF NOT EXISTS entity_relations_related_idx ON entity_relations(related_entity_id);`,
+};
+//# sourceMappingURL=entity-relations.js.map

package/dist/db/schema/tables/learnings.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Learnings Table Schema
+ * SQLite and PostgreSQL definitions
+ */
+export declare const learningsTable: {
+    sqlite: string;
+    postgres: string;
+};
+//# sourceMappingURL=learnings.d.ts.map