family-ai-agent 1.0.6 → 1.0.7

package/src/database/drizzle/schema/documents.ts

@@ -0,0 +1,157 @@
+/**
+ * Documents Schema
+ *
+ * Drizzle ORM schema for knowledge base documents and chunks.
+ * Supports vector embeddings for RAG (Retrieval Augmented Generation).
+ */
+
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+} from 'drizzle-orm/pg-core';
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+} from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+
+// =============================================================================
+// PostgreSQL Schema
+// =============================================================================
+
+/**
+ * Documents table (PostgreSQL)
+ */
+export const documentsPg = pgTable(
+  'documents',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    userId: text('user_id'),
+    filename: text('filename').notNull(),
+    fileType: text('file_type'),
+    fileSize: integer('file_size'),
+    content: text('content'),
+    metadata: jsonb('metadata').default({}).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    userIdIdx: index('documents_user_id_idx').on(table.userId),
+    filenameIdx: index('documents_filename_idx').on(table.filename),
+    createdAtIdx: index('documents_created_at_idx').on(table.createdAt),
+  })
+);
+
+/**
+ * Document chunks table (PostgreSQL)
+ */
+export const documentChunksPg = pgTable(
+  'document_chunks',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    documentId: uuid('document_id')
+      .notNull()
+      .references(() => documentsPg.id, { onDelete: 'cascade' }),
+    chunkIndex: integer('chunk_index').notNull(),
+    content: text('content').notNull(),
+    // pgvector embedding
+    embedding: text('embedding').notNull(),
+    metadata: jsonb('metadata').default({}).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    documentIdIdx: index('chunks_document_id_idx').on(table.documentId),
+    chunkIndexIdx: index('chunks_chunk_index_idx').on(table.chunkIndex),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Documents table (SQLite)
+ */
+export const documentsSqlite = sqliteTable('documents', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  userId: sqliteText('user_id'),
+  filename: sqliteText('filename').notNull(),
+  fileType: sqliteText('file_type'),
+  fileSize: sqliteInteger('file_size'),
+  content: sqliteText('content'),
+  metadata: sqliteText('metadata', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+/**
+ * Document chunks table (SQLite)
+ */
+export const documentChunksSqlite = sqliteTable('document_chunks', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  documentId: sqliteText('document_id')
+    .notNull()
+    .references(() => documentsSqlite.id, { onDelete: 'cascade' }),
+  chunkIndex: sqliteInteger('chunk_index').notNull(),
+  content: sqliteText('content').notNull(),
+  embedding: sqliteText('embedding').notNull(),
+  metadata: sqliteText('metadata', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type DocumentPg = typeof documentsPg.$inferSelect;
+export type NewDocumentPg = typeof documentsPg.$inferInsert;
+export type DocumentChunkPg = typeof documentChunksPg.$inferSelect;
+export type NewDocumentChunkPg = typeof documentChunksPg.$inferInsert;
+
+export type DocumentSqlite = typeof documentsSqlite.$inferSelect;
+export type NewDocumentSqlite = typeof documentsSqlite.$inferInsert;
+export type DocumentChunkSqlite = typeof documentChunksSqlite.$inferSelect;
+export type NewDocumentChunkSqlite = typeof documentChunksSqlite.$inferInsert;
+
+// Unified types
+export type Document = DocumentPg | DocumentSqlite;
+export type NewDocument = NewDocumentPg | NewDocumentSqlite;
+export type DocumentChunk = DocumentChunkPg | DocumentChunkSqlite;
+export type NewDocumentChunk = NewDocumentChunkPg | NewDocumentChunkSqlite;
+
+// Parsed chunk with embedding array
+export interface ParsedDocumentChunk {
+  id: string;
+  documentId: string;
+  chunkIndex: number;
+  content: string;
+  embedding: number[];
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+}

package/src/database/drizzle/schema/index.ts

@@ -0,0 +1,139 @@
+/**
+ * Schema Exports
+ *
+ * Central export for all Drizzle ORM schemas.
+ */
+
+// Conversations
+export {
+  conversationsPg,
+  messagesPg,
+  conversationsSqlite,
+  messagesSqlite,
+  type ConversationPg,
+  type NewConversationPg,
+  type MessagePg,
+  type NewMessagePg,
+  type ConversationSqlite,
+  type NewConversationSqlite,
+  type MessageSqlite,
+  type NewMessageSqlite,
+  type Conversation,
+  type NewConversation,
+  type Message,
+  type NewMessage,
+} from './conversations.js';
+
+// Long-term memories
+export {
+  longTermMemoriesPg,
+  longTermMemoriesSqlite,
+  type LongTermMemoryPg,
+  type NewLongTermMemoryPg,
+  type LongTermMemorySqlite,
+  type NewLongTermMemorySqlite,
+  type LongTermMemory,
+  type NewLongTermMemory,
+  type MemoryType,
+  type ParsedMemory,
+} from './memories.js';
+
+// Documents
+export {
+  documentsPg,
+  documentChunksPg,
+  documentsSqlite,
+  documentChunksSqlite,
+  type DocumentPg,
+  type NewDocumentPg,
+  type DocumentChunkPg,
+  type NewDocumentChunkPg,
+  type DocumentSqlite,
+  type NewDocumentSqlite,
+  type DocumentChunkSqlite,
+  type NewDocumentChunkSqlite,
+  type Document,
+  type NewDocument,
+  type DocumentChunk,
+  type NewDocumentChunk,
+  type ParsedDocumentChunk,
+} from './documents.js';
+
+// Checkpoints
+export {
+  checkpointsPg,
+  checkpointWritesPg,
+  checkpointsSqlite,
+  checkpointWritesSqlite,
+  type CheckpointPg,
+  type NewCheckpointPg,
+  type CheckpointWritePg,
+  type NewCheckpointWritePg,
+  type CheckpointSqlite,
+  type NewCheckpointSqlite,
+  type CheckpointWriteSqlite,
+  type NewCheckpointWriteSqlite,
+  type Checkpoint,
+  type NewCheckpoint,
+  type CheckpointWrite,
+  type NewCheckpointWrite,
+} from './checkpoints.js';
+
+// Audit logs
+export {
+  auditLogsPg,
+  auditLogsSqlite,
+  type AuditLogPg,
+  type NewAuditLogPg,
+  type AuditLogSqlite,
+  type NewAuditLogSqlite,
+  type AuditLog,
+  type NewAuditLog,
+  type AuditActionType,
+  type AuditStatus,
+} from './audit.js';
+
+// Tasks
+export {
+  tasksPg,
+  tasksSqlite,
+  type TaskPg,
+  type NewTaskPg,
+  type TaskSqlite,
+  type NewTaskSqlite,
+  type Task,
+  type NewTask,
+  type TaskStatus,
+  TaskPriority,
+  type TaskPriorityLevel,
+} from './tasks.js';
+
+/**
+ * All PostgreSQL tables
+ */
+export const pgSchema = {
+  conversations: () => import('./conversations.js').then((m) => m.conversationsPg),
+  messages: () => import('./conversations.js').then((m) => m.messagesPg),
+  longTermMemories: () => import('./memories.js').then((m) => m.longTermMemoriesPg),
+  documents: () => import('./documents.js').then((m) => m.documentsPg),
+  documentChunks: () => import('./documents.js').then((m) => m.documentChunksPg),
+  checkpoints: () => import('./checkpoints.js').then((m) => m.checkpointsPg),
+  checkpointWrites: () => import('./checkpoints.js').then((m) => m.checkpointWritesPg),
+  auditLogs: () => import('./audit.js').then((m) => m.auditLogsPg),
+  tasks: () => import('./tasks.js').then((m) => m.tasksPg),
+};
+
+/**
+ * All SQLite tables
+ */
+export const sqliteSchema = {
+  conversations: () => import('./conversations.js').then((m) => m.conversationsSqlite),
+  messages: () => import('./conversations.js').then((m) => m.messagesSqlite),
+  longTermMemories: () => import('./memories.js').then((m) => m.longTermMemoriesSqlite),
+  documents: () => import('./documents.js').then((m) => m.documentsSqlite),
+  documentChunks: () => import('./documents.js').then((m) => m.documentChunksSqlite),
+  checkpoints: () => import('./checkpoints.js').then((m) => m.checkpointsSqlite),
+  checkpointWrites: () => import('./checkpoints.js').then((m) => m.checkpointWritesSqlite),
+  auditLogs: () => import('./audit.js').then((m) => m.auditLogsSqlite),
+  tasks: () => import('./tasks.js').then((m) => m.tasksSqlite),
+};

package/src/database/drizzle/schema/memories.ts

@@ -0,0 +1,127 @@
+/**
+ * Long-Term Memories Schema
+ *
+ * Drizzle ORM schema for vector-embedded memories.
+ * PostgreSQL uses pgvector, SQLite stores embeddings as JSON.
+ */
+
+import {
+  pgTable,
+  uuid,
+  text,
+  real,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+} from 'drizzle-orm/pg-core';
+import {
+  sqliteTable,
+  text as sqliteText,
+  real as sqliteReal,
+  integer as sqliteInteger,
+} from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+
+// =============================================================================
+// PostgreSQL Schema (with pgvector)
+// =============================================================================
+
+/**
+ * Long-term memories table (PostgreSQL)
+ * Uses pgvector extension for embedding storage and similarity search
+ */
+export const longTermMemoriesPg = pgTable(
+  'long_term_memories',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    userId: text('user_id'),
+    memoryType: text('memory_type').notNull(), // 'semantic' | 'episodic' | 'procedural'
+    content: text('content').notNull(),
+    // pgvector type - stored as vector(1536)
+    // Note: Drizzle doesn't have native pgvector support, so we use customType
+    embedding: text('embedding').notNull(), // Will store as '[0.1, 0.2, ...]' format
+    importance: real('importance').default(0.5).notNull(),
+    accessCount: integer('access_count').default(0).notNull(),
+    lastAccessed: timestamp('last_accessed', { withTimezone: true }),
+    metadata: jsonb('metadata').default({}).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    userIdIdx: index('memories_user_id_idx').on(table.userId),
+    memoryTypeIdx: index('memories_memory_type_idx').on(table.memoryType),
+    importanceIdx: index('memories_importance_idx').on(table.importance),
+    createdAtIdx: index('memories_created_at_idx').on(table.createdAt),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Long-term memories table (SQLite)
+ * Embeddings stored as JSON string, similarity search done in-memory
+ */
+export const longTermMemoriesSqlite = sqliteTable('long_term_memories', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  userId: sqliteText('user_id'),
+  memoryType: sqliteText('memory_type').notNull(),
+  content: sqliteText('content').notNull(),
+  // Embedding stored as JSON array string: "[0.1, 0.2, ...]"
+  embedding: sqliteText('embedding').notNull(),
+  importance: sqliteReal('importance').default(0.5).notNull(),
+  accessCount: sqliteInteger('access_count').default(0).notNull(),
+  lastAccessed: sqliteInteger('last_accessed', { mode: 'timestamp' }),
+  metadata: sqliteText('metadata', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: sqliteInteger('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type LongTermMemoryPg = typeof longTermMemoriesPg.$inferSelect;
+export type NewLongTermMemoryPg = typeof longTermMemoriesPg.$inferInsert;
+
+export type LongTermMemorySqlite = typeof longTermMemoriesSqlite.$inferSelect;
+export type NewLongTermMemorySqlite = typeof longTermMemoriesSqlite.$inferInsert;
+
+// Unified types
+export type LongTermMemory = LongTermMemoryPg | LongTermMemorySqlite;
+export type NewLongTermMemory = NewLongTermMemoryPg | NewLongTermMemorySqlite;
+
+// Memory type enum
+export type MemoryType = 'semantic' | 'episodic' | 'procedural';
+
+// Memory with parsed embedding
+export interface ParsedMemory {
+  id: string;
+  userId: string | null;
+  memoryType: MemoryType;
+  content: string;
+  embedding: number[];
+  importance: number;
+  accessCount: number;
+  lastAccessed: Date | null;
+  metadata: Record<string, unknown>;
+  createdAt: Date;
+  updatedAt: Date;
+}

package/src/database/drizzle/schema/tasks.ts

@@ -0,0 +1,129 @@
+/**
+ * Tasks Schema
+ *
+ * Drizzle ORM schema for automation task queue.
+ * Supports scheduled and recurring tasks.
+ */
+
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  index,
+} from 'drizzle-orm/pg-core';
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+} from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+
+// =============================================================================
+// PostgreSQL Schema
+// =============================================================================
+
+/**
+ * Tasks table (PostgreSQL)
+ */
+export const tasksPg = pgTable(
+  'tasks',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    userId: text('user_id'),
+    taskType: text('task_type').notNull(),
+    priority: integer('priority').default(0).notNull(),
+    status: text('status').default('pending').notNull(), // 'pending' | 'running' | 'completed' | 'failed' | 'cancelled'
+    payload: jsonb('payload').default({}).notNull(),
+    result: jsonb('result'),
+    errorMessage: text('error_message'),
+    scheduledAt: timestamp('scheduled_at', { withTimezone: true }),
+    startedAt: timestamp('started_at', { withTimezone: true }),
+    completedAt: timestamp('completed_at', { withTimezone: true }),
+    retryCount: integer('retry_count').default(0).notNull(),
+    maxRetries: integer('max_retries').default(3).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    userIdIdx: index('tasks_user_id_idx').on(table.userId),
+    statusIdx: index('tasks_status_idx').on(table.status),
+    priorityIdx: index('tasks_priority_idx').on(table.priority),
+    scheduledAtIdx: index('tasks_scheduled_at_idx').on(table.scheduledAt),
+    taskTypeIdx: index('tasks_task_type_idx').on(table.taskType),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Tasks table (SQLite)
+ */
+export const tasksSqlite = sqliteTable('tasks', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  userId: sqliteText('user_id'),
+  taskType: sqliteText('task_type').notNull(),
+  priority: sqliteInteger('priority').default(0).notNull(),
+  status: sqliteText('status').default('pending').notNull(),
+  payload: sqliteText('payload', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  result: sqliteText('result', { mode: 'json' }).$type<Record<string, unknown>>(),
+  errorMessage: sqliteText('error_message'),
+  scheduledAt: sqliteInteger('scheduled_at', { mode: 'timestamp' }),
+  startedAt: sqliteInteger('started_at', { mode: 'timestamp' }),
+  completedAt: sqliteInteger('completed_at', { mode: 'timestamp' }),
+  retryCount: sqliteInteger('retry_count').default(0).notNull(),
+  maxRetries: sqliteInteger('max_retries').default(3).notNull(),
+  createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: sqliteInteger('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type TaskPg = typeof tasksPg.$inferSelect;
+export type NewTaskPg = typeof tasksPg.$inferInsert;
+
+export type TaskSqlite = typeof tasksSqlite.$inferSelect;
+export type NewTaskSqlite = typeof tasksSqlite.$inferInsert;
+
+// Unified types
+export type Task = TaskPg | TaskSqlite;
+export type NewTask = NewTaskPg | NewTaskSqlite;
+
+// Task status enum
+export type TaskStatus =
+  | 'pending'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled';
+
+// Task priority levels
+export const TaskPriority = {
+  LOW: 0,
+  NORMAL: 5,
+  HIGH: 10,
+  URGENT: 20,
+} as const;
+
+export type TaskPriorityLevel = (typeof TaskPriority)[keyof typeof TaskPriority];