haroo 1.0.0

package/src/infrastructure/database/sqlite-checkpointer.ts

@@ -0,0 +1,179 @@
+import type { BaseMessage } from "@langchain/core/messages";
+import type { Database } from "bun:sqlite";
+import type { ICheckpointer, CheckpointMetadata } from "../../domain/interfaces/IMemory";
+import type { GraphStateType } from "../../domain/state/AgentState";
+
+interface CheckpointRow {
+  session_id: string;
+  state: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export class SqliteCheckpointer implements ICheckpointer {
+  constructor(private readonly db: Database) {}
+
+  async save(sessionId: string, state: GraphStateType): Promise<void> {
+    const serializedState = JSON.stringify(this.serializeState(state));
+    const now = new Date().toISOString();
+
+    this.db
+      .prepare(
+        `
+      INSERT INTO checkpoints (session_id, state, created_at, updated_at)
+      VALUES (?, ?, ?, ?)
+      ON CONFLICT (session_id)
+      DO UPDATE SET
+        state = excluded.state,
+        updated_at = excluded.updated_at
+    `
+      )
+      .run(sessionId, serializedState, now, now);
+  }
+
+  async load(sessionId: string): Promise<GraphStateType | null> {
+    const row = this.db
+      .prepare(
+        "SELECT session_id, state, created_at, updated_at FROM checkpoints WHERE session_id = ?"
+      )
+      .get(sessionId) as CheckpointRow | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return this.deserializeState(JSON.parse(row.state));
+  }
+
+  async list(): Promise<string[]> {
+    const rows = this.db
+      .prepare("SELECT session_id FROM checkpoints ORDER BY updated_at DESC")
+      .all() as { session_id: string }[];
+
+    return rows.map((row) => row.session_id);
+  }
+
+  async delete(sessionId: string): Promise<boolean> {
+    const result = this.db.prepare("DELETE FROM checkpoints WHERE session_id = ?").run(sessionId);
+
+    return result.changes > 0;
+  }
+
+  async getMetadata(sessionId: string): Promise<CheckpointMetadata | null> {
+    const row = this.db
+      .prepare("SELECT created_at, updated_at FROM checkpoints WHERE session_id = ?")
+      .get(sessionId) as { created_at: string; updated_at: string } | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return {
+      createdAt: new Date(row.created_at),
+      updatedAt: new Date(row.updated_at),
+    };
+  }
+
+  async getSessionsForDate(date: Date): Promise<string[]> {
+    const startOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const endOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1);
+
+    const rows = this.db
+      .prepare(
+        `
+      SELECT session_id
+      FROM checkpoints
+      WHERE updated_at >= ? AND updated_at < ?
+      ORDER BY updated_at DESC
+    `
+      )
+      .all(startOfDay.toISOString(), endOfDay.toISOString()) as {
+      session_id: string;
+    }[];
+
+    return rows.map((row) => row.session_id);
+  }
+
+  private serializeState(state: GraphStateType): Record<string, unknown> {
+    const messages = state.messages.map((msg: BaseMessage) => ({
+      type: msg._getType(),
+      content: msg.content,
+      additional_kwargs: msg.additional_kwargs,
+      response_metadata: msg.response_metadata,
+      id: msg.id,
+      name: msg.name,
+    }));
+
+    return {
+      messages,
+      intent: state.intent,
+      pendingEvent: state.pendingEvent,
+      queryResult: state.queryResult,
+      relevantMemories: state.relevantMemories,
+      todayEvents: state.todayEvents,
+      response: state.response,
+    };
+  }
+
+  private deserializeState(data: unknown): GraphStateType {
+    const obj = data as Record<string, unknown>;
+
+    const {
+      HumanMessage,
+      AIMessage,
+      SystemMessage,
+      ToolMessage,
+    } = require("@langchain/core/messages");
+
+    const messageData = obj.messages as Array<{
+      type: string;
+      content: string;
+      additional_kwargs?: Record<string, unknown>;
+      id?: string;
+      name?: string;
+    }>;
+
+    const messages = messageData.map((msg) => {
+      switch (msg.type) {
+        case "human":
+          return new HumanMessage({
+            content: msg.content,
+            additional_kwargs: msg.additional_kwargs,
+            id: msg.id,
+          });
+        case "ai":
+          return new AIMessage({
+            content: msg.content,
+            additional_kwargs: msg.additional_kwargs,
+            id: msg.id,
+          });
+        case "system":
+          return new SystemMessage({
+            content: msg.content,
+            additional_kwargs: msg.additional_kwargs,
+            id: msg.id,
+          });
+        case "tool":
+          return new ToolMessage({
+            content: msg.content,
+            additional_kwargs: msg.additional_kwargs,
+            id: msg.id,
+            name: msg.name,
+            tool_call_id: (msg.additional_kwargs?.tool_call_id as string) ?? "",
+          });
+        default:
+          return new HumanMessage({ content: msg.content });
+      }
+    });
+
+    return {
+      messages,
+      intent: obj.intent as GraphStateType["intent"],
+      pendingEvent: obj.pendingEvent as GraphStateType["pendingEvent"],
+      queryResult: obj.queryResult as GraphStateType["queryResult"],
+      relevantMemories: obj.relevantMemories as GraphStateType["relevantMemories"],
+      todayEvents: obj.todayEvents as GraphStateType["todayEvents"],
+      response: obj.response as GraphStateType["response"],
+    };
+  }
+}

package/src/infrastructure/database/sqlite-client.ts

@@ -0,0 +1,69 @@
+import { Database } from "bun:sqlite";
+import * as sqliteVec from "sqlite-vec";
+import { mkdirSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+export interface SqliteClientOptions {
+  dbPath?: string;
+}
+
+const DEFAULT_DB_DIR = join(homedir(), ".log");
+const DEFAULT_DB_PATH = join(DEFAULT_DB_DIR, "data.db");
+
+// macOS requires a custom SQLite library that supports extensions
+// The default Apple SQLite disables extension loading
+function setupMacOSSqlite(): void {
+  if (process.platform !== "darwin") return;
+
+  const possiblePaths = [
+    "/opt/homebrew/opt/sqlite/lib/libsqlite3.dylib", // Apple Silicon
+    "/usr/local/opt/sqlite/lib/libsqlite3.dylib", // Intel Mac
+  ];
+
+  for (const sqlitePath of possiblePaths) {
+    if (existsSync(sqlitePath)) {
+      Database.setCustomSQLite(sqlitePath);
+      return;
+    }
+  }
+
+  console.warn(
+    "Warning: Could not find Homebrew SQLite. Vector search may not work.\n" +
+      "Install with: brew install sqlite"
+  );
+}
+
+// Initialize macOS SQLite on module load
+setupMacOSSqlite();
+
+/**
+ * Creates a SQLite database client with sqlite-vec extension loaded.
+ * Default path: ~/.log/data.db
+ */
+export function createSqliteClient(options: SqliteClientOptions = {}): Database {
+  const dbPath = options.dbPath ?? DEFAULT_DB_PATH;
+
+  // Ensure directory exists
+  const dbDir = join(dbPath, "..");
+  if (!existsSync(dbDir)) {
+    mkdirSync(dbDir, { recursive: true });
+  }
+
+  const db = new Database(dbPath);
+
+  // Load sqlite-vec extension
+  sqliteVec.load(db);
+
+  // Enable WAL mode for better concurrent access
+  db.exec("PRAGMA journal_mode = WAL");
+
+  return db;
+}
+
+/**
+ * Get the default database path.
+ */
+export function getDefaultDbPath(): string {
+  return DEFAULT_DB_PATH;
+}

package/src/infrastructure/database/sqlite-diary-repository.ts

@@ -0,0 +1,209 @@
+import type { Database } from "bun:sqlite";
+import { z } from "zod";
+import { type DiaryEntry, DiaryEntrySchema } from "../../domain/entities/DiaryEntry";
+import type { IDiaryRepository, MoodTrendEntry } from "../../domain/interfaces/IDiaryRepository";
+
+const DiaryRowSchema = z.object({
+  id: z.string().uuid(),
+  entry_date: z.string(),
+  summary: z.string(),
+  mood: z.string(),
+  mood_score: z.number(),
+  therapeutic_advice: z.string(),
+  session_ids: z.string().nullable(),
+  message_count: z.number(),
+  created_at: z.string(),
+  updated_at: z.string(),
+});
+
+type DiaryRow = z.infer<typeof DiaryRowSchema>;
+
+function rowToEntry(row: DiaryRow): DiaryEntry {
+  return DiaryEntrySchema.parse({
+    id: row.id,
+    entryDate: new Date(row.entry_date),
+    summary: row.summary,
+    mood: row.mood,
+    moodScore: row.mood_score,
+    therapeuticAdvice: row.therapeutic_advice,
+    sessionIds: row.session_ids ? JSON.parse(row.session_ids) : [],
+    messageCount: row.message_count,
+    createdAt: new Date(row.created_at),
+    updatedAt: new Date(row.updated_at),
+  });
+}
+
+export class SqliteDiaryRepository implements IDiaryRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(entry: DiaryEntry): Promise<DiaryEntry> {
+    this.db
+      .prepare(
+        `
+      INSERT INTO diary_entries (
+        id, entry_date, summary, mood, mood_score,
+        therapeutic_advice, session_ids, message_count, created_at, updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+      )
+      .run(
+        entry.id,
+        entry.entryDate.toISOString().split("T")[0],
+        entry.summary,
+        entry.mood,
+        entry.moodScore,
+        entry.therapeuticAdvice,
+        JSON.stringify(entry.sessionIds),
+        entry.messageCount,
+        entry.createdAt.toISOString(),
+        entry.updatedAt.toISOString()
+      );
+
+    return entry;
+  }
+
+  async getById(id: string): Promise<DiaryEntry | null> {
+    const row = this.db.prepare("SELECT * FROM diary_entries WHERE id = ?").get(id) as
+      | DiaryRow
+      | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return rowToEntry(DiaryRowSchema.parse(row));
+  }
+
+  async getByDate(date: Date): Promise<DiaryEntry | null> {
+    const dateStr = date.toISOString().split("T")[0];
+
+    const row = this.db.prepare("SELECT * FROM diary_entries WHERE entry_date = ?").get(dateStr) as
+      | DiaryRow
+      | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return rowToEntry(DiaryRowSchema.parse(row));
+  }
+
+  async getByDateRange(startDate: Date, endDate: Date): Promise<DiaryEntry[]> {
+    const startStr = startDate.toISOString().split("T")[0];
+    const endStr = endDate.toISOString().split("T")[0];
+
+    const rows = this.db
+      .prepare(
+        `
+      SELECT * FROM diary_entries
+      WHERE entry_date >= ? AND entry_date <= ?
+      ORDER BY entry_date DESC
+    `
+      )
+      .all(startStr, endStr) as DiaryRow[];
+
+    return rows.map((row) => rowToEntry(DiaryRowSchema.parse(row)));
+  }
+
+  async getRecent(limit = 7): Promise<DiaryEntry[]> {
+    const rows = this.db
+      .prepare(
+        `
+      SELECT * FROM diary_entries
+      ORDER BY entry_date DESC
+      LIMIT ?
+    `
+      )
+      .all(limit) as DiaryRow[];
+
+    return rows.map((row) => rowToEntry(DiaryRowSchema.parse(row)));
+  }
+
+  async update(
+    id: string,
+    updates: Partial<Omit<DiaryEntry, "id" | "createdAt">>
+  ): Promise<DiaryEntry | null> {
+    const setters: string[] = [];
+    const values: (string | number | null)[] = [];
+
+    if (updates.entryDate !== undefined) {
+      setters.push("entry_date = ?");
+      values.push(updates.entryDate.toISOString().split("T")[0]);
+    }
+    if (updates.summary !== undefined) {
+      setters.push("summary = ?");
+      values.push(updates.summary);
+    }
+    if (updates.mood !== undefined) {
+      setters.push("mood = ?");
+      values.push(updates.mood);
+    }
+    if (updates.moodScore !== undefined) {
+      setters.push("mood_score = ?");
+      values.push(updates.moodScore);
+    }
+    if (updates.therapeuticAdvice !== undefined) {
+      setters.push("therapeutic_advice = ?");
+      values.push(updates.therapeuticAdvice);
+    }
+    if (updates.sessionIds !== undefined) {
+      setters.push("session_ids = ?");
+      values.push(JSON.stringify(updates.sessionIds));
+    }
+    if (updates.messageCount !== undefined) {
+      setters.push("message_count = ?");
+      values.push(updates.messageCount);
+    }
+
+    // Always update updated_at
+    setters.push("updated_at = ?");
+    values.push(new Date().toISOString());
+
+    if (setters.length === 1) {
+      // Only updated_at was added
+      return this.getById(id);
+    }
+
+    values.push(id);
+
+    const result = this.db
+      .prepare(`UPDATE diary_entries SET ${setters.join(", ")} WHERE id = ?`)
+      .run(...values);
+
+    if (result.changes === 0) {
+      return null;
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const result = this.db.prepare("DELETE FROM diary_entries WHERE id = ?").run(id);
+
+    return result.changes > 0;
+  }
+
+  async getMoodTrend(days = 30): Promise<MoodTrendEntry[]> {
+    const startDate = new Date();
+    startDate.setDate(startDate.getDate() - days);
+    const startStr = startDate.toISOString().split("T")[0];
+
+    const rows = this.db
+      .prepare(
+        `
+      SELECT entry_date, mood, mood_score
+      FROM diary_entries
+      WHERE entry_date >= ?
+      ORDER BY entry_date ASC
+    `
+      )
+      .all(startStr) as { entry_date: string; mood: string; mood_score: number }[];
+
+    return rows.map((row) => ({
+      date: new Date(row.entry_date),
+      mood: row.mood,
+      moodScore: row.mood_score,
+    }));
+  }
+}

package/src/infrastructure/database/sqlite-events-repository.ts

@@ -0,0 +1,167 @@
+import type { Database } from "bun:sqlite";
+import { z } from "zod";
+import { type Event, EventSchema } from "../../domain/entities/Event";
+import type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+
+const EventRowSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string(),
+  datetime: z.string(),
+  end_time: z.string().nullable(),
+  notes: z.string().nullable(),
+  tags: z.string().nullable(),
+  created_at: z.string(),
+});
+
+type EventRow = z.infer<typeof EventRowSchema>;
+
+function rowToEvent(row: EventRow): Event {
+  return EventSchema.parse({
+    id: row.id,
+    title: row.title,
+    datetime: new Date(row.datetime),
+    endTime: row.end_time ? new Date(row.end_time) : undefined,
+    notes: row.notes ?? undefined,
+    tags: row.tags ? JSON.parse(row.tags) : [],
+    createdAt: new Date(row.created_at),
+  });
+}
+
+export class SqliteEventsRepository implements IEventsRepository {
+  constructor(private readonly db: Database) {}
+
+  async create(event: Event): Promise<Event> {
+    const stmt = this.db.prepare(`
+      INSERT INTO events (id, title, datetime, end_time, notes, tags, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    stmt.run(
+      event.id,
+      event.title,
+      event.datetime.toISOString(),
+      event.endTime?.toISOString() ?? null,
+      event.notes ?? null,
+      JSON.stringify(event.tags),
+      event.createdAt.toISOString()
+    );
+
+    return event;
+  }
+
+  async getById(id: string): Promise<Event | null> {
+    const row = this.db.prepare("SELECT * FROM events WHERE id = ?").get(id) as
+      | EventRow
+      | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return rowToEvent(EventRowSchema.parse(row));
+  }
+
+  async getByDateRange(startDate: Date, endDate: Date): Promise<Event[]> {
+    const rows = this.db
+      .prepare(
+        `
+        SELECT * FROM events
+        WHERE datetime >= ? AND datetime <= ?
+        ORDER BY datetime ASC
+      `
+      )
+      .all(startDate.toISOString(), endDate.toISOString()) as EventRow[];
+
+    return rows.map((row) => rowToEvent(EventRowSchema.parse(row)));
+  }
+
+  async getToday(): Promise<Event[]> {
+    const today = new Date();
+    const startOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate());
+    const endOfDay = new Date(today.getFullYear(), today.getMonth(), today.getDate() + 1);
+
+    return this.getByDateRange(startOfDay, endOfDay);
+  }
+
+  async getUpcoming(limit = 10): Promise<Event[]> {
+    const now = new Date();
+
+    const rows = this.db
+      .prepare(
+        `
+        SELECT * FROM events
+        WHERE datetime >= ?
+        ORDER BY datetime ASC
+        LIMIT ?
+      `
+      )
+      .all(now.toISOString(), limit) as EventRow[];
+
+    return rows.map((row) => rowToEvent(EventRowSchema.parse(row)));
+  }
+
+  async update(
+    id: string,
+    updates: Partial<Omit<Event, "id" | "createdAt">>
+  ): Promise<Event | null> {
+    const setters: string[] = [];
+    const values: (string | null)[] = [];
+
+    if (updates.title !== undefined) {
+      setters.push("title = ?");
+      values.push(updates.title);
+    }
+    if (updates.datetime !== undefined) {
+      setters.push("datetime = ?");
+      values.push(updates.datetime.toISOString());
+    }
+    if (updates.endTime !== undefined) {
+      setters.push("end_time = ?");
+      values.push(updates.endTime?.toISOString() ?? null);
+    }
+    if (updates.notes !== undefined) {
+      setters.push("notes = ?");
+      values.push(updates.notes ?? null);
+    }
+    if (updates.tags !== undefined) {
+      setters.push("tags = ?");
+      values.push(JSON.stringify(updates.tags));
+    }
+
+    if (setters.length === 0) {
+      return this.getById(id);
+    }
+
+    values.push(id);
+
+    const result = this.db
+      .prepare(`UPDATE events SET ${setters.join(", ")} WHERE id = ?`)
+      .run(...values);
+
+    if (result.changes === 0) {
+      return null;
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: string): Promise<boolean> {
+    const result = this.db.prepare("DELETE FROM events WHERE id = ?").run(id);
+
+    return result.changes > 0;
+  }
+
+  async searchByTitle(query: string): Promise<Event[]> {
+    const rows = this.db
+      .prepare(
+        `
+        SELECT * FROM events
+        WHERE title LIKE ?
+        ORDER BY datetime ASC
+      `
+      )
+      .all(`%${query}%`) as EventRow[];
+
+    return rows.map((row) => rowToEvent(EventRowSchema.parse(row)));
+  }
+}