family-ai-agent 1.0.5 → 1.0.7

package/src/database/drizzle/index.ts

@@ -0,0 +1,66 @@
+/**
+ * Drizzle ORM Instance Factory
+ *
+ * Creates and manages Drizzle ORM instances for both PostgreSQL and SQLite.
+ */
+
+import { drizzle as drizzlePg } from 'drizzle-orm/node-postgres';
+import { drizzle as drizzleSqlite } from 'drizzle-orm/better-sqlite3';
+import type { NodePgDatabase } from 'drizzle-orm/node-postgres';
+import type { BetterSQLite3Database } from 'drizzle-orm/better-sqlite3';
+import type { Pool } from 'pg';
+import type Database from 'better-sqlite3';
+
+import * as pgSchema from './schema/conversations.js';
+import * as sqliteSchema from './schema/conversations.js';
+
+// Re-export schema
+export * from './schema/index.js';
+
+/**
+ * Drizzle instance types
+ */
+export type DrizzlePgInstance = NodePgDatabase<typeof pgSchema>;
+export type DrizzleSqliteInstance = BetterSQLite3Database<typeof sqliteSchema>;
+export type DrizzleInstance = DrizzlePgInstance | DrizzleSqliteInstance;
+
+/**
+ * Create Drizzle instance for PostgreSQL
+ */
+export function createPgDrizzle(pool: Pool): DrizzlePgInstance {
+  return drizzlePg(pool, {
+    schema: pgSchema,
+    logger: process.env.NODE_ENV === 'development',
+  });
+}
+
+/**
+ * Create Drizzle instance for SQLite
+ */
+export function createSqliteDrizzle(database: Database.Database): DrizzleSqliteInstance {
+  return drizzleSqlite(database, {
+    schema: sqliteSchema,
+    logger: process.env.NODE_ENV === 'development',
+  });
+}
+
+/**
+ * Database type guard for PostgreSQL
+ */
+export function isPgDrizzle(db: DrizzleInstance): db is DrizzlePgInstance {
+  return 'dialect' in db && (db as unknown as { dialect: { name: string } }).dialect?.name === 'pg';
+}
+
+/**
+ * Database type guard for SQLite
+ */
+export function isSqliteDrizzle(db: DrizzleInstance): db is DrizzleSqliteInstance {
+  return 'dialect' in db && (db as unknown as { dialect: { name: string } }).dialect?.name === 'sqlite';
+}
+
+export default {
+  createPgDrizzle,
+  createSqliteDrizzle,
+  isPgDrizzle,
+  isSqliteDrizzle,
+};

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

@@ -0,0 +1,127 @@
+/**
+ * Audit Logs Schema
+ *
+ * Drizzle ORM schema for safety and compliance audit logging.
+ * Tracks all significant actions in the system.
+ */
+
+import {
+  pgTable,
+  uuid,
+  text,
+  integer,
+  timestamp,
+  jsonb,
+  boolean,
+  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
+// =============================================================================
+
+/**
+ * Audit logs table (PostgreSQL)
+ */
+export const auditLogsPg = pgTable(
+  'audit_logs',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    userId: text('user_id'),
+    agentId: text('agent_id'),
+    actionType: text('action_type').notNull(),
+    actionDetails: jsonb('action_details').default({}).notNull(),
+    inputHash: text('input_hash'),
+    outputHash: text('output_hash'),
+    status: text('status').default('success').notNull(),
+    errorMessage: text('error_message'),
+    executionTimeMs: integer('execution_time_ms'),
+    ipAddress: text('ip_address'),
+    userAgent: text('user_agent'),
+    success: boolean('success').default(true).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    userIdIdx: index('audit_user_id_idx').on(table.userId),
+    agentIdIdx: index('audit_agent_id_idx').on(table.agentId),
+    actionTypeIdx: index('audit_action_type_idx').on(table.actionType),
+    createdAtIdx: index('audit_created_at_idx').on(table.createdAt),
+    statusIdx: index('audit_status_idx').on(table.status),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Audit logs table (SQLite)
+ */
+export const auditLogsSqlite = sqliteTable('audit_logs', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  userId: sqliteText('user_id'),
+  agentId: sqliteText('agent_id'),
+  actionType: sqliteText('action_type').notNull(),
+  actionDetails: sqliteText('action_details', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  inputHash: sqliteText('input_hash'),
+  outputHash: sqliteText('output_hash'),
+  status: sqliteText('status').default('success').notNull(),
+  errorMessage: sqliteText('error_message'),
+  executionTimeMs: sqliteInteger('execution_time_ms'),
+  ipAddress: sqliteText('ip_address'),
+  userAgent: sqliteText('user_agent'),
+  success: sqliteInteger('success', { mode: 'boolean' }).default(true).notNull(),
+  createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type AuditLogPg = typeof auditLogsPg.$inferSelect;
+export type NewAuditLogPg = typeof auditLogsPg.$inferInsert;
+
+export type AuditLogSqlite = typeof auditLogsSqlite.$inferSelect;
+export type NewAuditLogSqlite = typeof auditLogsSqlite.$inferInsert;
+
+// Unified types
+export type AuditLog = AuditLogPg | AuditLogSqlite;
+export type NewAuditLog = NewAuditLogPg | NewAuditLogSqlite;
+
+// Action types enum
+export type AuditActionType =
+  | 'chat_message'
+  | 'memory_store'
+  | 'memory_search'
+  | 'memory_delete'
+  | 'document_upload'
+  | 'document_search'
+  | 'document_delete'
+  | 'agent_invocation'
+  | 'tool_execution'
+  | 'safety_block'
+  | 'safety_warning'
+  | 'authentication'
+  | 'authorization'
+  | 'config_change'
+  | 'system_event';
+
+// Status types
+export type AuditStatus = 'success' | 'failure' | 'blocked' | 'warning';

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

@@ -0,0 +1,164 @@
+/**
+ * Checkpoints Schema
+ *
+ * Drizzle ORM schema for LangGraph checkpointing.
+ * Stores execution state for resumable workflows.
+ */
+
+import {
+  pgTable,
+  text,
+  timestamp,
+  jsonb,
+  primaryKey,
+  integer,
+} from 'drizzle-orm/pg-core';
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer as sqliteInteger,
+  primaryKey as sqlitePrimaryKey,
+} from 'drizzle-orm/sqlite-core';
+
+// =============================================================================
+// PostgreSQL Schema
+// =============================================================================
+
+/**
+ * Checkpoints table (PostgreSQL)
+ */
+export const checkpointsPg = pgTable(
+  'checkpoints',
+  {
+    threadId: text('thread_id').notNull(),
+    checkpointNs: text('checkpoint_ns').default('').notNull(),
+    checkpointId: text('checkpoint_id').notNull(),
+    parentCheckpointId: text('parent_checkpoint_id'),
+    type: text('type'),
+    checkpoint: jsonb('checkpoint').notNull(),
+    metadata: jsonb('metadata').default({}).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    pk: primaryKey({
+      columns: [table.threadId, table.checkpointNs, table.checkpointId],
+    }),
+  })
+);
+
+/**
+ * Checkpoint writes table (PostgreSQL)
+ */
+export const checkpointWritesPg = pgTable(
+  'checkpoint_writes',
+  {
+    threadId: text('thread_id').notNull(),
+    checkpointNs: text('checkpoint_ns').default('').notNull(),
+    checkpointId: text('checkpoint_id').notNull(),
+    taskId: text('task_id').notNull(),
+    idx: integer('idx').notNull(),
+    channel: text('channel').notNull(),
+    type: text('type'),
+    value: jsonb('value'),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    pk: primaryKey({
+      columns: [
+        table.threadId,
+        table.checkpointNs,
+        table.checkpointId,
+        table.taskId,
+        table.idx,
+      ],
+    }),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Checkpoints table (SQLite)
+ */
+export const checkpointsSqlite = sqliteTable(
+  'checkpoints',
+  {
+    threadId: sqliteText('thread_id').notNull(),
+    checkpointNs: sqliteText('checkpoint_ns').default('').notNull(),
+    checkpointId: sqliteText('checkpoint_id').notNull(),
+    parentCheckpointId: sqliteText('parent_checkpoint_id'),
+    type: sqliteText('type'),
+    checkpoint: sqliteText('checkpoint', { mode: 'json' })
+      .notNull()
+      .$type<Record<string, unknown>>(),
+    metadata: sqliteText('metadata', { mode: 'json' })
+      .notNull()
+      .$type<Record<string, unknown>>()
+      .default({}),
+    createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+      .notNull()
+      .$defaultFn(() => new Date()),
+  },
+  (table) => ({
+    pk: sqlitePrimaryKey({
+      columns: [table.threadId, table.checkpointNs, table.checkpointId],
+    }),
+  })
+);
+
+/**
+ * Checkpoint writes table (SQLite)
+ */
+export const checkpointWritesSqlite = sqliteTable(
+  'checkpoint_writes',
+  {
+    threadId: sqliteText('thread_id').notNull(),
+    checkpointNs: sqliteText('checkpoint_ns').default('').notNull(),
+    checkpointId: sqliteText('checkpoint_id').notNull(),
+    taskId: sqliteText('task_id').notNull(),
+    idx: sqliteInteger('idx').notNull(),
+    channel: sqliteText('channel').notNull(),
+    type: sqliteText('type'),
+    value: sqliteText('value', { mode: 'json' }).$type<unknown>(),
+    createdAt: sqliteInteger('created_at', { mode: 'timestamp' })
+      .notNull()
+      .$defaultFn(() => new Date()),
+  },
+  (table) => ({
+    pk: sqlitePrimaryKey({
+      columns: [
+        table.threadId,
+        table.checkpointNs,
+        table.checkpointId,
+        table.taskId,
+        table.idx,
+      ],
+    }),
+  })
+);
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type CheckpointPg = typeof checkpointsPg.$inferSelect;
+export type NewCheckpointPg = typeof checkpointsPg.$inferInsert;
+export type CheckpointWritePg = typeof checkpointWritesPg.$inferSelect;
+export type NewCheckpointWritePg = typeof checkpointWritesPg.$inferInsert;
+
+export type CheckpointSqlite = typeof checkpointsSqlite.$inferSelect;
+export type NewCheckpointSqlite = typeof checkpointsSqlite.$inferInsert;
+export type CheckpointWriteSqlite = typeof checkpointWritesSqlite.$inferSelect;
+export type NewCheckpointWriteSqlite = typeof checkpointWritesSqlite.$inferInsert;
+
+// Unified types
+export type Checkpoint = CheckpointPg | CheckpointSqlite;
+export type NewCheckpoint = NewCheckpointPg | NewCheckpointSqlite;
+export type CheckpointWrite = CheckpointWritePg | CheckpointWriteSqlite;
+export type NewCheckpointWrite = NewCheckpointWritePg | NewCheckpointWriteSqlite;

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

@@ -0,0 +1,138 @@
+/**
+ * Conversations Schema
+ *
+ * Drizzle ORM schema for conversations and messages tables.
+ * Supports both PostgreSQL and SQLite.
+ */
+
+import {
+  pgTable,
+  uuid,
+  text,
+  timestamp,
+  jsonb,
+  index,
+} from 'drizzle-orm/pg-core';
+import {
+  sqliteTable,
+  text as sqliteText,
+  integer,
+} from 'drizzle-orm/sqlite-core';
+import { sql } from 'drizzle-orm';
+
+// =============================================================================
+// PostgreSQL Schema
+// =============================================================================
+
+/**
+ * Conversations table (PostgreSQL)
+ */
+export const conversationsPg = pgTable(
+  'conversations',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    threadId: text('thread_id').notNull(),
+    userId: text('user_id'),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+    updatedAt: timestamp('updated_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    threadIdIdx: index('conversations_thread_id_idx').on(table.threadId),
+    userIdIdx: index('conversations_user_id_idx').on(table.userId),
+  })
+);
+
+/**
+ * Messages table (PostgreSQL)
+ */
+export const messagesPg = pgTable(
+  'messages',
+  {
+    id: uuid('id')
+      .primaryKey()
+      .default(sql`gen_random_uuid()`),
+    conversationId: uuid('conversation_id')
+      .notNull()
+      .references(() => conversationsPg.id, { onDelete: 'cascade' }),
+    role: text('role').notNull(), // 'user' | 'assistant' | 'system'
+    content: text('content').notNull(),
+    metadata: jsonb('metadata').default({}).notNull(),
+    createdAt: timestamp('created_at', { withTimezone: true })
+      .defaultNow()
+      .notNull(),
+  },
+  (table) => ({
+    conversationIdIdx: index('messages_conversation_id_idx').on(
+      table.conversationId
+    ),
+    createdAtIdx: index('messages_created_at_idx').on(table.createdAt),
+  })
+);
+
+// =============================================================================
+// SQLite Schema
+// =============================================================================
+
+/**
+ * Conversations table (SQLite)
+ */
+export const conversationsSqlite = sqliteTable('conversations', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  threadId: sqliteText('thread_id').notNull(),
+  userId: sqliteText('user_id'),
+  createdAt: integer('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+  updatedAt: integer('updated_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+/**
+ * Messages table (SQLite)
+ */
+export const messagesSqlite = sqliteTable('messages', {
+  id: sqliteText('id')
+    .primaryKey()
+    .$defaultFn(() => crypto.randomUUID()),
+  conversationId: sqliteText('conversation_id')
+    .notNull()
+    .references(() => conversationsSqlite.id, { onDelete: 'cascade' }),
+  role: sqliteText('role').notNull(),
+  content: sqliteText('content').notNull(),
+  metadata: sqliteText('metadata', { mode: 'json' })
+    .notNull()
+    .$type<Record<string, unknown>>()
+    .default({}),
+  createdAt: integer('created_at', { mode: 'timestamp' })
+    .notNull()
+    .$defaultFn(() => new Date()),
+});
+
+// =============================================================================
+// TypeScript Types
+// =============================================================================
+
+export type ConversationPg = typeof conversationsPg.$inferSelect;
+export type NewConversationPg = typeof conversationsPg.$inferInsert;
+export type MessagePg = typeof messagesPg.$inferSelect;
+export type NewMessagePg = typeof messagesPg.$inferInsert;
+
+export type ConversationSqlite = typeof conversationsSqlite.$inferSelect;
+export type NewConversationSqlite = typeof conversationsSqlite.$inferInsert;
+export type MessageSqlite = typeof messagesSqlite.$inferSelect;
+export type NewMessageSqlite = typeof messagesSqlite.$inferInsert;
+
+// Unified types
+export type Conversation = ConversationPg | ConversationSqlite;
+export type NewConversation = NewConversationPg | NewConversationSqlite;
+export type Message = MessagePg | MessageSqlite;
+export type NewMessage = NewMessagePg | NewMessageSqlite;

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;
+}