family-ai-agent 1.0.6 → 1.0.8

package/src/database/db-config.ts

@@ -0,0 +1,194 @@
+/**
+ * Database Configuration
+ *
+ * Configuration management for the database layer.
+ * Supports both PostgreSQL and SQLite with validation.
+ */
+
+import { z } from 'zod';
+import { homedir } from 'os';
+import { join } from 'path';
+import type { DatabaseConfig, DatabaseDetectionMode } from './types.js';
+
+/**
+ * Database configuration schema with Zod validation
+ */
+export const databaseConfigSchema = z.object({
+  // Detection mode
+  DATABASE_TYPE: z
+    .enum(['auto', 'postgresql', 'sqlite'])
+    .default('auto')
+    .describe('Database type selection mode'),
+
+  // PostgreSQL settings
+  DATABASE_URL: z
+    .string()
+    .url()
+    .optional()
+    .describe('Full PostgreSQL connection URL'),
+  DB_HOST: z.string().default('localhost').describe('PostgreSQL host'),
+  DB_PORT: z.coerce.number().default(5432).describe('PostgreSQL port'),
+  DB_USER: z.string().default('familyai').describe('PostgreSQL user'),
+  DB_PASSWORD: z.string().default('familyai123').describe('PostgreSQL password'),
+  DB_NAME: z.string().default('familyai').describe('PostgreSQL database name'),
+  DB_POOL_MAX: z.coerce.number().default(20).describe('Maximum pool connections'),
+  DB_POOL_IDLE_TIMEOUT_MS: z.coerce
+    .number()
+    .default(30000)
+    .describe('Pool idle timeout'),
+  DB_POOL_CONNECTION_TIMEOUT_MS: z.coerce
+    .number()
+    .default(5000)
+    .describe('Connection timeout'),
+
+  // SQLite settings
+  SQLITE_PATH: z
+    .string()
+    .optional()
+    .describe('SQLite database file path'),
+
+  // Health monitoring
+  DB_HEALTH_CHECK_INTERVAL_MS: z.coerce
+    .number()
+    .default(30000)
+    .describe('Health check interval'),
+  DB_CIRCUIT_BREAKER_THRESHOLD: z.coerce
+    .number()
+    .default(5)
+    .describe('Circuit breaker failure threshold'),
+  DB_CIRCUIT_BREAKER_TIMEOUT_MS: z.coerce
+    .number()
+    .default(60000)
+    .describe('Circuit breaker reset timeout'),
+
+  // Cache settings
+  DB_CACHE_MAX_SIZE: z.coerce
+    .number()
+    .default(1000)
+    .describe('Maximum cache entries'),
+  DB_CACHE_TTL_MS: z.coerce
+    .number()
+    .default(300000)
+    .describe('Cache TTL in milliseconds'),
+
+  // Vector settings
+  VECTOR_DIMENSION: z.coerce
+    .number()
+    .default(1536)
+    .describe('Embedding vector dimension'),
+  VECTOR_MIN_SIMILARITY: z.coerce
+    .number()
+    .default(0.7)
+    .describe('Minimum similarity threshold'),
+});
+
+export type RawDatabaseConfig = z.infer<typeof databaseConfigSchema>;
+
+/**
+ * Default SQLite database path
+ */
+export function getDefaultSqlitePath(): string {
+  return join(homedir(), '.family-ai-agent', 'data', 'family-ai.db');
+}
+
+/**
+ * Build PostgreSQL connection URL from config
+ */
+export function buildPostgresUrl(config: RawDatabaseConfig): string {
+  if (config.DATABASE_URL) {
+    return config.DATABASE_URL;
+  }
+  return `postgresql://${config.DB_USER}:${config.DB_PASSWORD}@${config.DB_HOST}:${config.DB_PORT}/${config.DB_NAME}`;
+}
+
+/**
+ * Load and validate database configuration from environment
+ */
+export function loadDatabaseConfig(
+  env: Record<string, string | undefined> = process.env
+): DatabaseConfig {
+  const parsed = databaseConfigSchema.safeParse(env);
+
+  if (!parsed.success) {
+    // Return defaults on validation failure
+    const defaults = databaseConfigSchema.parse({});
+    return convertToConfig(defaults);
+  }
+
+  return convertToConfig(parsed.data);
+}
+
+/**
+ * Convert raw config to DatabaseConfig interface
+ */
+function convertToConfig(raw: RawDatabaseConfig): DatabaseConfig {
+  return {
+    type: raw.DATABASE_TYPE as DatabaseDetectionMode,
+
+    // PostgreSQL
+    postgresUrl: raw.DATABASE_URL,
+    postgresHost: raw.DB_HOST,
+    postgresPort: raw.DB_PORT,
+    postgresUser: raw.DB_USER,
+    postgresPassword: raw.DB_PASSWORD,
+    postgresDatabase: raw.DB_NAME,
+    postgresPoolMax: raw.DB_POOL_MAX,
+    postgresIdleTimeoutMs: raw.DB_POOL_IDLE_TIMEOUT_MS,
+    postgresConnectionTimeoutMs: raw.DB_POOL_CONNECTION_TIMEOUT_MS,
+
+    // SQLite
+    sqlitePath: raw.SQLITE_PATH ?? getDefaultSqlitePath(),
+
+    // Health monitoring
+    healthCheckIntervalMs: raw.DB_HEALTH_CHECK_INTERVAL_MS,
+    circuitBreakerThreshold: raw.DB_CIRCUIT_BREAKER_THRESHOLD,
+    circuitBreakerTimeoutMs: raw.DB_CIRCUIT_BREAKER_TIMEOUT_MS,
+
+    // Cache
+    cacheMaxSize: raw.DB_CACHE_MAX_SIZE,
+    cacheTtlMs: raw.DB_CACHE_TTL_MS,
+
+    // Vector
+    vectorDimension: raw.VECTOR_DIMENSION,
+    vectorMinSimilarity: raw.VECTOR_MIN_SIMILARITY,
+  };
+}
+
+/**
+ * Global database configuration instance
+ */
+let dbConfig: DatabaseConfig | null = null;
+
+/**
+ * Get database configuration
+ */
+export function getDatabaseConfig(): DatabaseConfig {
+  if (!dbConfig) {
+    dbConfig = loadDatabaseConfig();
+  }
+  return dbConfig;
+}
+
+/**
+ * Reset configuration (for testing)
+ */
+export function resetDatabaseConfig(): void {
+  dbConfig = null;
+}
+
+/**
+ * Set custom configuration (for testing)
+ */
+export function setDatabaseConfig(config: Partial<DatabaseConfig>): void {
+  const defaults = loadDatabaseConfig();
+  dbConfig = { ...defaults, ...config };
+}
+
+export default {
+  loadDatabaseConfig,
+  getDatabaseConfig,
+  resetDatabaseConfig,
+  setDatabaseConfig,
+  getDefaultSqlitePath,
+  buildPostgresUrl,
+};

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;