haroo 1.0.0

package/src/application/tools/diaryTool.ts

@@ -0,0 +1,182 @@
+import { z } from "zod";
+import type { ToolDefinition } from "../../domain/interfaces/ILanguageModel";
+import type { ToolExecutor } from "../graph/nodes";
+import type { IDiaryRepository } from "../../domain/interfaces/IDiaryRepository";
+
+// ============================================================================
+// Schemas
+// ============================================================================
+
+export const QueryDiarySchema = z.object({
+  type: z.enum(["today", "yesterday", "week", "date", "range"]),
+  date: z.string().optional().describe("Specific date (YYYY-MM-DD) for 'date' type"),
+  startDate: z.string().optional().describe("Start date for 'range' type"),
+  endDate: z.string().optional().describe("End date for 'range' type"),
+});
+
+export type QueryDiaryInput = z.infer<typeof QueryDiarySchema>;
+
+export const GetMoodTrendSchema = z.object({
+  days: z.number().optional().describe("Number of days for trend analysis (default: 30)"),
+});
+
+export type GetMoodTrendInput = z.infer<typeof GetMoodTrendSchema>;
+
+// ============================================================================
+// Tool Definitions (for LLM binding)
+// ============================================================================
+
+export const queryDiaryToolDefinition: ToolDefinition = {
+  name: "query_diary",
+  description:
+    "Query diary/journal entries by date or range. Returns conversation summaries, mood, and therapeutic advice from past days.",
+  parameters: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["today", "yesterday", "week", "date", "range"],
+        description: "Query type",
+      },
+      date: { type: "string", description: "Specific date (YYYY-MM-DD) for 'date' type" },
+      startDate: { type: "string", description: "Start date for 'range' type (YYYY-MM-DD)" },
+      endDate: { type: "string", description: "End date for 'range' type (YYYY-MM-DD)" },
+    },
+    required: ["type"],
+  },
+};
+
+export const getMoodTrendToolDefinition: ToolDefinition = {
+  name: "get_mood_trend",
+  description:
+    "Get mood trend analysis over time to understand emotional patterns. Returns mood scores and labels for recent days.",
+  parameters: {
+    type: "object",
+    properties: {
+      days: { type: "number", description: "Number of days for trend analysis (default: 30)" },
+    },
+    required: [],
+  },
+};
+
+export const diaryToolDefinitions: ToolDefinition[] = [
+  queryDiaryToolDefinition,
+  getMoodTrendToolDefinition,
+];
+
+// ============================================================================
+// Tool Executor Factory - Creates executors with database repository
+// ============================================================================
+
+export function createDiaryToolExecutors(
+  diaryRepository: IDiaryRepository
+): Record<string, ToolExecutor> {
+  const queryDiaryExecutor: ToolExecutor = async (args) => {
+    const result = QueryDiarySchema.safeParse(args);
+    if (!result.success) {
+      throw new Error(`Validation Failed: ${result.error.message}`);
+    }
+
+    const input = result.data;
+    const now = new Date();
+    let startDate: Date;
+    let endDate: Date;
+
+    switch (input.type) {
+      case "today":
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        break;
+      case "yesterday": {
+        const yesterday = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 1);
+        startDate = yesterday;
+        endDate = yesterday;
+        break;
+      }
+      case "week":
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() - 7);
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        break;
+      case "date":
+        if (!input.date) {
+          throw new Error("Validation Failed: 'date' field is required for type 'date'");
+        }
+        startDate = new Date(input.date);
+        endDate = new Date(input.date);
+        break;
+      case "range":
+        if (!input.startDate || !input.endDate) {
+          throw new Error(
+            "Validation Failed: 'startDate' and 'endDate' are required for type 'range'"
+          );
+        }
+        startDate = new Date(input.startDate);
+        endDate = new Date(input.endDate);
+        break;
+    }
+
+    const entries = await diaryRepository.getByDateRange(startDate, endDate);
+
+    return JSON.stringify({
+      success: true,
+      query: {
+        type: input.type,
+        startDate: startDate.toISOString().split("T")[0],
+        endDate: endDate.toISOString().split("T")[0],
+      },
+      entries: entries.map((e) => ({
+        id: e.id,
+        date: e.entryDate.toISOString().split("T")[0],
+        summary: e.summary,
+        mood: e.mood,
+        moodScore: e.moodScore,
+        therapeuticAdvice: e.therapeuticAdvice,
+        messageCount: e.messageCount,
+      })),
+    });
+  };
+
+  const getMoodTrendExecutor: ToolExecutor = async (args) => {
+    const result = GetMoodTrendSchema.safeParse(args);
+    if (!result.success) {
+      throw new Error(`Validation Failed: ${result.error.message}`);
+    }
+
+    const input = result.data;
+    const days = input.days ?? 30;
+
+    const trend = await diaryRepository.getMoodTrend(days);
+
+    // Calculate average mood score
+    const avgMoodScore =
+      trend.length > 0 ? trend.reduce((sum, t) => sum + t.moodScore, 0) / trend.length : null;
+
+    // Find most common mood
+    const moodCounts = trend.reduce(
+      (acc, t) => {
+        acc[t.mood] = (acc[t.mood] || 0) + 1;
+        return acc;
+      },
+      {} as Record<string, number>
+    );
+    const dominantMood = Object.entries(moodCounts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null;
+
+    return JSON.stringify({
+      success: true,
+      days,
+      entryCount: trend.length,
+      averageMoodScore: avgMoodScore ? Math.round(avgMoodScore * 10) / 10 : null,
+      dominantMood,
+      trend: trend.map((t) => ({
+        date: t.date.toISOString().split("T")[0],
+        mood: t.mood,
+        moodScore: t.moodScore,
+      })),
+    });
+  };
+
+  return {
+    query_diary: queryDiaryExecutor,
+    get_mood_trend: getMoodTrendExecutor,
+  };
+}

package/src/application/tools/index.ts

@@ -0,0 +1,68 @@
+import type { ToolRegistry, ToolExecutor } from "../graph/nodes";
+import type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+import type { IDiaryRepository } from "../../domain/interfaces/IDiaryRepository";
+import {
+  createCalendarToolExecutors,
+  calendarToolDefinitions,
+  AddEventSchema,
+  QueryEventsSchema,
+  type AddEventInput,
+  type QueryEventsInput,
+} from "./calendarTool";
+import {
+  createDiaryToolExecutors,
+  diaryToolDefinitions,
+  QueryDiarySchema,
+  GetMoodTrendSchema,
+  type QueryDiaryInput,
+  type GetMoodTrendInput,
+} from "./diaryTool";
+
+export interface ToolRegistryDeps {
+  eventsRepository: IEventsRepository;
+  diaryRepository?: IDiaryRepository;
+}
+
+export function createToolRegistry(deps: ToolRegistryDeps): ToolRegistry {
+  const registry: ToolRegistry = new Map();
+
+  // Register calendar tools with database repository
+  const calendarExecutors = createCalendarToolExecutors(deps.eventsRepository);
+  for (const [name, executor] of Object.entries(calendarExecutors)) {
+    registry.set(name, executor);
+  }
+
+  // Register diary tools if repository provided
+  if (deps.diaryRepository) {
+    const diaryExecutors = createDiaryToolExecutors(deps.diaryRepository);
+    for (const [name, executor] of Object.entries(diaryExecutors)) {
+      registry.set(name, executor);
+    }
+  }
+
+  return registry;
+}
+
+// Re-export calendar tool components
+export {
+  createCalendarToolExecutors,
+  calendarToolDefinitions,
+  AddEventSchema,
+  QueryEventsSchema,
+  type AddEventInput,
+  type QueryEventsInput,
+};
+
+// Re-export diary tool components
+export {
+  createDiaryToolExecutors,
+  diaryToolDefinitions,
+  QueryDiarySchema,
+  GetMoodTrendSchema,
+  type QueryDiaryInput,
+  type GetMoodTrendInput,
+};
+
+export function registerTool(registry: ToolRegistry, name: string, executor: ToolExecutor): void {
+  registry.set(name, executor);
+}

package/src/config/env.ts

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import "dotenv/config";
+
+const envSchema = z.object({
+  // LLM Providers
+  OPENAI_API_KEY: z.string().optional(),
+  GEMINI_API_KEY: z.string().optional(),
+  OLLAMA_BASE_URL: z.string().url().default("http://localhost:11434"),
+
+  // Default provider
+  DEFAULT_PROVIDER: z.enum(["openai", "gemini", "ollama"]).default("ollama"),
+  DEFAULT_MODEL: z.string().optional(),
+
+  // App settings
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+});
+
+export type Env = z.infer<typeof envSchema>;
+
+function validateEnv(): Env {
+  const result = envSchema.safeParse(process.env);
+
+  if (!result.success) {
+    console.error("Environment validation failed:");
+    console.error(result.error.format());
+    process.exit(1);
+  }
+
+  return result.data;
+}
+
+export const env = validateEnv();

package/src/config/index.ts

@@ -0,0 +1 @@
+export { type Env, env } from "./env";

package/src/domain/entities/DiaryEntry.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+export const DiaryEntrySchema = z.object({
+  id: z.string().uuid(),
+  entryDate: z.coerce.date(),
+  summary: z.string(),
+  mood: z.string(),
+  moodScore: z.number().min(1).max(10),
+  therapeuticAdvice: z.string(),
+  sessionIds: z.array(z.string()).default([]),
+  messageCount: z.number().default(0),
+  createdAt: z.coerce.date(),
+  updatedAt: z.coerce.date(),
+});
+
+export type DiaryEntry = z.infer<typeof DiaryEntrySchema>;

package/src/domain/entities/Event.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const EventSchema = z.object({
+  id: z.string().uuid(),
+  title: z.string().min(1),
+  datetime: z.coerce.date(),
+  endTime: z.coerce.date().optional(),
+  notes: z.string().optional(),
+  tags: z.array(z.string()).default([]),
+  createdAt: z.coerce.date().default(() => new Date()),
+});
+
+export type Event = z.infer<typeof EventSchema>;

package/src/domain/entities/Memory.ts

@@ -0,0 +1,20 @@
+import { z } from "zod";
+
+export const MemorySchema = z.object({
+  id: z.string().uuid(),
+  type: z.enum([
+    "fact",
+    "preference",
+    "routine",
+    "relationship",
+    "communication_style",
+    "interest",
+  ]),
+  content: z.string(),
+  source: z.string().optional(),
+  importance: z.number().min(1).max(10).default(5),
+  lastAccessed: z.coerce.date(),
+  createdAt: z.coerce.date(),
+});
+
+export type Memory = z.infer<typeof MemorySchema>;

package/src/domain/index.ts

@@ -0,0 +1,5 @@
+export * from "./entities/Event";
+export * from "./entities/Memory";
+export * from "./interfaces/ILanguageModel";
+export * from "./interfaces/IMemory";
+export { GraphState, type GraphStateType, type Intent } from "./state/AgentState";

package/src/domain/interfaces/IDiaryRepository.ts

@@ -0,0 +1,21 @@
+import type { DiaryEntry } from "../entities/DiaryEntry";
+
+export interface MoodTrendEntry {
+  date: Date;
+  mood: string;
+  moodScore: number;
+}
+
+export interface IDiaryRepository {
+  create(entry: DiaryEntry): Promise<DiaryEntry>;
+  getById(id: string): Promise<DiaryEntry | null>;
+  getByDate(date: Date): Promise<DiaryEntry | null>;
+  getByDateRange(startDate: Date, endDate: Date): Promise<DiaryEntry[]>;
+  getRecent(limit?: number): Promise<DiaryEntry[]>;
+  update(
+    id: string,
+    updates: Partial<Omit<DiaryEntry, "id" | "createdAt">>
+  ): Promise<DiaryEntry | null>;
+  delete(id: string): Promise<boolean>;
+  getMoodTrend(days?: number): Promise<MoodTrendEntry[]>;
+}

package/src/domain/interfaces/IEventsRepository.ts

@@ -0,0 +1,12 @@
+import type { Event } from "../entities/Event";
+
+export interface IEventsRepository {
+  create(event: Event): Promise<Event>;
+  getById(id: string): Promise<Event | null>;
+  getByDateRange(startDate: Date, endDate: Date): Promise<Event[]>;
+  getToday(): Promise<Event[]>;
+  getUpcoming(limit?: number): Promise<Event[]>;
+  update(id: string, updates: Partial<Omit<Event, "id" | "createdAt">>): Promise<Event | null>;
+  delete(id: string): Promise<boolean>;
+  searchByTitle(query: string): Promise<Event[]>;
+}

package/src/domain/interfaces/ILanguageModel.ts

@@ -0,0 +1,23 @@
+import type { BaseMessage } from "@langchain/core/messages";
+
+export interface ToolDefinition {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface LLMResponse {
+  content: string;
+  toolCalls?: ToolCall[];
+}
+
+export interface ILanguageModel {
+  generate(messages: BaseMessage[], tools?: ToolDefinition[]): Promise<LLMResponse>;
+  withStructuredOutput<_T>(schema: unknown): ILanguageModel;
+}

package/src/domain/interfaces/IMemoriesRepository.ts

@@ -0,0 +1,15 @@
+import type { Memory } from "../entities/Memory";
+
+export type EmbeddingFunction = (text: string) => Promise<number[]>;
+
+export interface IMemoriesRepository {
+  create(memory: Memory, embedding?: number[]): Promise<Memory>;
+  getById(id: string): Promise<Memory | null>;
+  getByType(type: Memory["type"]): Promise<Memory[]>;
+  getAll(limit?: number): Promise<Memory[]>;
+  semanticSearch(embedding: number[], limit?: number, threshold?: number): Promise<Memory[]>;
+  update(id: string, updates: Partial<Omit<Memory, "id" | "createdAt">>): Promise<Memory | null>;
+  delete(id: string): Promise<boolean>;
+  updateLastAccessed(id: string): Promise<void>;
+  getRecent(limit?: number): Promise<Memory[]>;
+}

package/src/domain/interfaces/IMemory.ts

@@ -0,0 +1,19 @@
+import type { GraphStateType } from "../state/AgentState";
+
+export interface CheckpointMetadata {
+  createdAt: Date;
+  updatedAt: Date;
+}
+
+export interface ICheckpointer {
+  save(sessionId: string, state: GraphStateType): Promise<void>;
+  load(sessionId: string): Promise<GraphStateType | null>;
+  list(): Promise<string[]>;
+  getMetadata?(sessionId: string): Promise<CheckpointMetadata | null>;
+  getSessionsForDate?(date: Date): Promise<string[]>;
+}
+
+export interface IVectorStore {
+  addDocuments(docs: { content: string; metadata?: Record<string, unknown> }[]): Promise<void>;
+  search(query: string, limit?: number): Promise<{ content: string; score: number }[]>;
+}

package/src/domain/interfaces/index.ts

@@ -0,0 +1,4 @@
+export type { IEventsRepository } from "./IEventsRepository";
+export type { ILanguageModel } from "./ILanguageModel";
+export type { EmbeddingFunction, IMemoriesRepository } from "./IMemoriesRepository";
+export type { ICheckpointer, IVectorStore } from "./IMemory";

package/src/domain/state/AgentState.ts

@@ -0,0 +1,30 @@
+import type { BaseMessage } from "@langchain/core/messages";
+import { Annotation } from "@langchain/langgraph";
+import type { Event } from "../entities/Event";
+import type { Memory } from "../entities/Memory";
+
+export type Intent = "add_event" | "query" | "chat" | null;
+
+export const GraphState = Annotation.Root({
+  messages: Annotation<BaseMessage[]>({
+    reducer: (prev, next) => [...prev, ...next],
+    default: () => [],
+  }),
+  intent: Annotation<Intent>(),
+  pendingEvent: Annotation<Event | null>(),
+  queryResult: Annotation<string | null>(),
+  relevantMemories: Annotation<Memory[]>({
+    reducer: (_, next) => next,
+    default: () => [],
+  }),
+  todayEvents: Annotation<Event[]>({
+    reducer: (_, next) => next,
+    default: () => [],
+  }),
+  response: Annotation<string>({
+    reducer: (_, next) => next,
+    default: () => "",
+  }),
+});
+
+export type GraphStateType = typeof GraphState.State;

package/src/index.ts

@@ -0,0 +1,5 @@
+#!/usr/bin/env bun
+import { createProgram } from "./interface";
+
+const program = createProgram();
+program.parse();

package/src/infrastructure/database/factory.ts

@@ -0,0 +1,52 @@
+import type { Database } from "bun:sqlite";
+import type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+import type { IMemoriesRepository } from "../../domain/interfaces/IMemoriesRepository";
+import type { IDiaryRepository } from "../../domain/interfaces/IDiaryRepository";
+import type { ICheckpointer } from "../../domain/interfaces/IMemory";
+
+import { SqliteCheckpointer } from "./sqlite-checkpointer";
+import { SqliteEventsRepository } from "./sqlite-events-repository";
+import { SqliteMemoriesRepository } from "./sqlite-memories-repository";
+import { SqliteDiaryRepository } from "./sqlite-diary-repository";
+
+import { createSqliteClient } from "./sqlite-client";
+import { initializeSqliteSchema } from "./sqlite-schema";
+
+export interface RepositoryBundle {
+  checkpointer: ICheckpointer;
+  events: IEventsRepository;
+  memories: IMemoriesRepository & {
+    setEmbeddingFunction?: (fn: (text: string) => Promise<number[]>) => void;
+  };
+  diary: IDiaryRepository;
+}
+
+/**
+ * Creates the complete repository bundle using SQLite backend.
+ */
+export function createRepositories(client: Database): RepositoryBundle {
+  const memories = new SqliteMemoriesRepository(client);
+  return {
+    checkpointer: new SqliteCheckpointer(client),
+    events: new SqliteEventsRepository(client),
+    memories,
+    diary: new SqliteDiaryRepository(client),
+  };
+}
+
+/**
+ * Create SQLite backend client with schema initialized.
+ */
+export function createBackend(): Database {
+  const client = createSqliteClient();
+  initializeSqliteSchema(client);
+  return client;
+}
+
+/**
+ * Convenience function to create repositories with auto-initialized SQLite.
+ */
+export function createRepositoriesFromEnv(): RepositoryBundle {
+  const client = createBackend();
+  return createRepositories(client);
+}

package/src/infrastructure/database/index.ts

@@ -0,0 +1,21 @@
+// Re-export interfaces from domain
+export type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+export type {
+  EmbeddingFunction,
+  IMemoriesRepository,
+} from "../../domain/interfaces/IMemoriesRepository";
+export type { ICheckpointer } from "../../domain/interfaces/IMemory";
+
+// Factory with auto-detection
+export type { RepositoryBundle } from "./factory";
+export { createBackend, createRepositories, createRepositoriesFromEnv } from "./factory";
+
+// SQLite implementations
+export { SqliteCheckpointer } from "./sqlite-checkpointer";
+export { SqliteEventsRepository } from "./sqlite-events-repository";
+export { SqliteMemoriesRepository } from "./sqlite-memories-repository";
+export { SqliteDiaryRepository } from "./sqlite-diary-repository";
+
+// SQLite client
+export { createSqliteClient, getDefaultDbPath } from "./sqlite-client";
+export { initializeSqliteSchema } from "./sqlite-schema";