family-ai-agent 1.0.5 → 1.0.7

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];

package/src/database/health/circuit-breaker.ts

@@ -0,0 +1,214 @@
+/**
+ * Circuit Breaker
+ *
+ * Prevents cascade failures by temporarily blocking calls to failing services.
+ * Implements the circuit breaker pattern for database resilience.
+ */
+
+import type { CircuitBreakerState, CircuitBreakerOptions } from '../types.js';
+import { createLogger } from '../../utils/logger.js';
+
+const logger = createLogger('CircuitBreaker');
+
+/**
+ * Error thrown when circuit is open
+ */
+export class CircuitOpenError extends Error {
+  constructor(message: string = 'Circuit breaker is open') {
+    super(message);
+    this.name = 'CircuitOpenError';
+  }
+}
+
+/**
+ * Default circuit breaker options
+ */
+const DEFAULT_OPTIONS: CircuitBreakerOptions = {
+  failureThreshold: 5,
+  resetTimeoutMs: 60000,
+  halfOpenMaxAttempts: 3,
+};
+
+/**
+ * Circuit breaker for database operations
+ */
+export class CircuitBreaker {
+  private state: CircuitBreakerState = 'closed';
+  private failureCount: number = 0;
+  private successCount: number = 0;
+  private lastFailureTime: number = 0;
+  private options: CircuitBreakerOptions;
+  private stateChangeListeners: Array<(state: CircuitBreakerState) => void> = [];
+
+  constructor(options: Partial<CircuitBreakerOptions> = {}) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+
+  /**
+   * Execute a function with circuit breaker protection
+   */
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    // Check if circuit should transition from open to half-open
+    if (this.state === 'open') {
+      const timeSinceLastFailure = Date.now() - this.lastFailureTime;
+      if (timeSinceLastFailure >= this.options.resetTimeoutMs) {
+        this.transitionTo('half-open');
+      } else {
+        throw new CircuitOpenError(
+          `Circuit breaker is open. Retry in ${Math.ceil(
+            (this.options.resetTimeoutMs - timeSinceLastFailure) / 1000
+          )} seconds.`
+        );
+      }
+    }
+
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  /**
+   * Handle successful execution
+   */
+  private onSuccess(): void {
+    this.failureCount = 0;
+
+    if (this.state === 'half-open') {
+      this.successCount++;
+      if (this.successCount >= this.options.halfOpenMaxAttempts) {
+        this.transitionTo('closed');
+      }
+    }
+  }
+
+  /**
+   * Handle failed execution
+   */
+  private onFailure(): void {
+    this.failureCount++;
+    this.lastFailureTime = Date.now();
+    this.successCount = 0;
+
+    if (this.state === 'half-open') {
+      // Immediately open on failure in half-open state
+      this.transitionTo('open');
+    } else if (this.failureCount >= this.options.failureThreshold) {
+      this.transitionTo('open');
+    }
+  }
+
+  /**
+   * Transition to a new state
+   */
+  private transitionTo(newState: CircuitBreakerState): void {
+    if (this.state === newState) return;
+
+    const oldState = this.state;
+    this.state = newState;
+
+    if (newState === 'closed') {
+      this.failureCount = 0;
+      this.successCount = 0;
+    } else if (newState === 'half-open') {
+      this.successCount = 0;
+    }
+
+    logger.info('Circuit breaker state changed', {
+      from: oldState,
+      to: newState,
+    });
+
+    // Notify listeners
+    for (const listener of this.stateChangeListeners) {
+      try {
+        listener(newState);
+      } catch (error) {
+        logger.error('State change listener error', { error });
+      }
+    }
+  }
+
+  /**
+   * Register a state change listener
+   */
+  onStateChange(listener: (state: CircuitBreakerState) => void): () => void {
+    this.stateChangeListeners.push(listener);
+    return () => {
+      const index = this.stateChangeListeners.indexOf(listener);
+      if (index >= 0) {
+        this.stateChangeListeners.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Get current state
+   */
+  getState(): CircuitBreakerState {
+    return this.state;
+  }
+
+  /**
+   * Check if circuit is open
+   */
+  isOpen(): boolean {
+    return this.state === 'open';
+  }
+
+  /**
+   * Check if circuit is half-open
+   */
+  isHalfOpen(): boolean {
+    return this.state === 'half-open';
+  }
+
+  /**
+   * Check if circuit is closed
+   */
+  isClosed(): boolean {
+    return this.state === 'closed';
+  }
+
+  /**
+   * Force circuit to open state
+   */
+  trip(): void {
+    this.lastFailureTime = Date.now();
+    this.transitionTo('open');
+  }
+
+  /**
+   * Force circuit to closed state
+   */
+  reset(): void {
+    this.transitionTo('closed');
+  }
+
+  /**
+   * Get circuit breaker statistics
+   */
+  getStats(): {
+    state: CircuitBreakerState;
+    failureCount: number;
+    successCount: number;
+    lastFailureTime: number | null;
+    timeSinceLastFailure: number | null;
+  } {
+    return {
+      state: this.state,
+      failureCount: this.failureCount,
+      successCount: this.successCount,
+      lastFailureTime: this.lastFailureTime || null,
+      timeSinceLastFailure: this.lastFailureTime
+        ? Date.now() - this.lastFailureTime
+        : null,
+    };
+  }
+}
+
+export default CircuitBreaker;