haroo 1.0.0

package/src/application/graph/nodes/toolExecutor.ts

@@ -0,0 +1,79 @@
+import { ToolMessage } from "@langchain/core/messages";
+import type { GraphStateType } from "../../../domain/state/AgentState";
+import type { ToolCall } from "../../../domain/interfaces/ILanguageModel";
+import type { ToolRegistry } from "./types";
+
+export interface ToolExecutorNodeDeps {
+  tools: ToolRegistry;
+}
+
+/**
+ * Executes tool calls from the LLM response and adds results as ToolMessages.
+ * This node processes pending tool calls and returns their results.
+ */
+export async function toolExecutorNode(
+  state: GraphStateType,
+  deps: ToolExecutorNodeDeps
+): Promise<Partial<GraphStateType>> {
+  const lastMessage = state.messages[state.messages.length - 1];
+
+  // Check if there are tool calls to execute
+  const toolCalls = (lastMessage as { additional_kwargs?: { tool_calls?: ToolCall[] } })
+    ?.additional_kwargs?.tool_calls;
+
+  if (!toolCalls || toolCalls.length === 0) {
+    return {};
+  }
+
+  const toolMessages: ToolMessage[] = [];
+
+  for (const toolCall of toolCalls) {
+    const executor = deps.tools.get(toolCall.name);
+
+    if (!executor) {
+      toolMessages.push(
+        new ToolMessage({
+          content: JSON.stringify({ error: `Unknown tool: ${toolCall.name}` }),
+          tool_call_id: toolCall.id,
+          name: toolCall.name,
+        })
+      );
+      continue;
+    }
+
+    try {
+      const result = await executor(toolCall.arguments);
+      toolMessages.push(
+        new ToolMessage({
+          content: result,
+          tool_call_id: toolCall.id,
+          name: toolCall.name,
+        })
+      );
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      toolMessages.push(
+        new ToolMessage({
+          content: JSON.stringify({ error: errorMessage }),
+          tool_call_id: toolCall.id,
+          name: toolCall.name,
+        })
+      );
+    }
+  }
+
+  return {
+    messages: toolMessages,
+  };
+}
+
+/**
+ * Checks if the last message contains tool calls that need to be executed.
+ */
+export function hasToolCalls(state: GraphStateType): boolean {
+  const lastMessage = state.messages[state.messages.length - 1];
+  const toolCalls = (lastMessage as { additional_kwargs?: { tool_calls?: ToolCall[] } })
+    ?.additional_kwargs?.tool_calls;
+
+  return Array.isArray(toolCalls) && toolCalls.length > 0;
+}

package/src/application/graph/nodes/types.ts

@@ -0,0 +1,2 @@
+export type ToolExecutor = (args: Record<string, unknown>) => Promise<string>;
+export type ToolRegistry = Map<string, ToolExecutor>;

package/src/application/index.ts

@@ -0,0 +1,4 @@
+export { type GraphConfig, runGraph } from "./graph/builder";
+export * from "./graph/nodes";
+export { EventService } from "./services";
+export { createToolRegistry, registerTool } from "./tools";

package/src/application/services/DiaryService.ts

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+import { HumanMessage, AIMessage, SystemMessage, BaseMessage } from "@langchain/core/messages";
+import type { ILanguageModel } from "../../domain/interfaces/ILanguageModel";
+import type { ICheckpointer } from "../../domain/interfaces/IMemory";
+import type { IDiaryRepository } from "../../domain/interfaces/IDiaryRepository";
+import type { DiaryEntry } from "../../domain/entities/DiaryEntry";
+
+const DiaryExtractionSchema = z.object({
+  summary: z.string().describe("2-3 sentence summary of the day's conversations"),
+  mood: z.string().describe("Primary mood/tone detected (e.g., calm, anxious, happy, reflective)"),
+  moodScore: z
+    .number()
+    .min(1)
+    .max(10)
+    .describe("Mood positivity score: 1=very negative, 10=very positive"),
+  therapeuticAdvice: z.string().describe("One sentence of supportive, therapeutic advice"),
+});
+
+type DiaryExtraction = z.infer<typeof DiaryExtractionSchema>;
+
+const DIARY_GENERATION_PROMPT = `You are a compassionate journal writer and emotional wellness assistant.
+Analyze the following conversation(s) and create a diary entry that:
+
+1. Summarizes the key topics and interactions (2-3 sentences)
+2. Identifies the overall mood/emotional tone (use a single word like: calm, anxious, happy, reflective, stressed, content, frustrated, hopeful, etc.)
+3. Rates the mood on a 1-10 scale (1=very negative, 10=very positive)
+4. Provides one sentence of gentle, supportive therapeutic advice
+
+Be warm, understanding, and focus on the human's emotional journey.
+Your response must be valid JSON with the following structure:
+{
+  "summary": "...",
+  "mood": "...",
+  "moodScore": 5,
+  "therapeuticAdvice": "..."
+}`;
+
+export class DiaryService {
+  constructor(
+    private readonly diaryRepository: IDiaryRepository,
+    private readonly checkpointer: ICheckpointer,
+    private readonly llm: ILanguageModel
+  ) {}
+
+  /**
+   * Generate a diary entry for a specific date by summarizing all sessions from that day.
+   */
+  async generateDiaryEntry(targetDate: Date): Promise<DiaryEntry | null> {
+    // Check if entry already exists for this date
+    const existing = await this.diaryRepository.getByDate(targetDate);
+    if (existing) {
+      throw new Error(`Diary entry already exists for ${targetDate.toISOString().split("T")[0]}`);
+    }
+
+    // Get sessions for the target date
+    const sessionIds = await this.getSessionsForDate(targetDate);
+
+    if (sessionIds.length === 0) {
+      return null; // No conversations for this date
+    }
+
+    // Load all messages from the sessions
+    const allMessages: BaseMessage[] = [];
+    for (const sessionId of sessionIds) {
+      const state = await this.checkpointer.load(sessionId);
+      if (state) {
+        allMessages.push(...state.messages);
+      }
+    }
+
+    if (allMessages.length === 0) {
+      return null;
+    }
+
+    // Format messages for the LLM
+    const conversationText = this.formatMessagesForSummary(allMessages);
+
+    // Use LLM to generate diary entry
+    const targetDateStr = targetDate.toISOString().split("T")[0];
+    const response = await this.llm.generate([
+      new SystemMessage(DIARY_GENERATION_PROMPT),
+      new HumanMessage(`Analyze these conversations from ${targetDateStr}:\n\n${conversationText}`),
+    ]);
+
+    // Parse the JSON response
+    const parsed = this.parseExtractionResponse(response.content);
+
+    // Create and save diary entry
+    const now = new Date();
+    const entry: DiaryEntry = {
+      id: randomUUID(),
+      entryDate: targetDate,
+      summary: parsed.summary,
+      mood: parsed.mood,
+      moodScore: parsed.moodScore,
+      therapeuticAdvice: parsed.therapeuticAdvice,
+      sessionIds,
+      messageCount: allMessages.length,
+      createdAt: now,
+      updatedAt: now,
+    };
+
+    return this.diaryRepository.create(entry);
+  }
+
+  /**
+   * Generate diary entry for yesterday (end of day trigger).
+   */
+  async generateYesterdayEntry(): Promise<DiaryEntry | null> {
+    const yesterday = new Date();
+    yesterday.setDate(yesterday.getDate() - 1);
+    yesterday.setHours(0, 0, 0, 0);
+    return this.generateDiaryEntry(yesterday);
+  }
+
+  /**
+   * Get recent diary entries.
+   */
+  async getRecent(limit = 7): Promise<DiaryEntry[]> {
+    return this.diaryRepository.getRecent(limit);
+  }
+
+  /**
+   * Get diary entry by date.
+   */
+  async getByDate(date: Date): Promise<DiaryEntry | null> {
+    return this.diaryRepository.getByDate(date);
+  }
+
+  private async getSessionsForDate(date: Date): Promise<string[]> {
+    // Use the checkpointer's getSessionsForDate if available
+    if (this.checkpointer.getSessionsForDate) {
+      return this.checkpointer.getSessionsForDate(date);
+    }
+
+    // Fallback: list all sessions and filter by metadata
+    const allSessionIds = await this.checkpointer.list();
+    const sessionsForDate: string[] = [];
+
+    for (const sessionId of allSessionIds) {
+      if (this.checkpointer.getMetadata) {
+        const metadata = await this.checkpointer.getMetadata(sessionId);
+        if (metadata) {
+          const sessionDate = metadata.updatedAt;
+          if (
+            sessionDate.getFullYear() === date.getFullYear() &&
+            sessionDate.getMonth() === date.getMonth() &&
+            sessionDate.getDate() === date.getDate()
+          ) {
+            sessionsForDate.push(sessionId);
+          }
+        }
+      }
+    }
+
+    return sessionsForDate;
+  }
+
+  private formatMessagesForSummary(messages: BaseMessage[]): string {
+    return messages
+      .filter((msg) => msg instanceof HumanMessage || msg instanceof AIMessage)
+      .map((msg) => {
+        const role = msg instanceof HumanMessage ? "User" : "Assistant";
+        return `${role}: ${String(msg.content)}`;
+      })
+      .join("\n");
+  }
+
+  private parseExtractionResponse(content: string): DiaryExtraction {
+    // Try to extract JSON from the response
+    let jsonStr = content;
+
+    // If wrapped in markdown code block, extract it
+    const jsonMatch = content.match(/```(?:json)?\s*([\s\S]*?)\s*```/);
+    if (jsonMatch) {
+      jsonStr = jsonMatch[1];
+    }
+
+    // Parse and validate
+    const parsed = DiaryExtractionSchema.safeParse(JSON.parse(jsonStr.trim()));
+    if (!parsed.success) {
+      throw new Error(`Failed to parse diary extraction: ${parsed.error.message}`);
+    }
+
+    return parsed.data;
+  }
+}

package/src/application/services/EventService.ts

@@ -0,0 +1,61 @@
+import { randomUUID } from "node:crypto";
+import type { Event } from "../../domain/entities/Event";
+import type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+
+export class EventService {
+  constructor(private readonly repository: IEventsRepository) {}
+
+  async add(event: Omit<Event, "id" | "createdAt">): Promise<Event> {
+    const newEvent: Event = {
+      ...event,
+      id: randomUUID(),
+      createdAt: new Date(),
+    };
+
+    return this.repository.create(newEvent);
+  }
+
+  async getById(id: string): Promise<Event | null> {
+    return this.repository.getById(id);
+  }
+
+  async getByDate(date: Date): Promise<Event[]> {
+    const startOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const endOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1);
+
+    return this.repository.getByDateRange(startOfDay, endOfDay);
+  }
+
+  async getByRange(start: Date, end: Date): Promise<Event[]> {
+    return this.repository.getByDateRange(start, end);
+  }
+
+  async getToday(): Promise<Event[]> {
+    return this.repository.getToday();
+  }
+
+  async getUpcoming(days: number): Promise<Event[]> {
+    const now = new Date();
+    const futureDate = new Date(now.getTime() + days * 24 * 60 * 60 * 1000);
+
+    return this.repository.getByDateRange(now, futureDate);
+  }
+
+  async search(query: string): Promise<Event[]> {
+    return this.repository.searchByTitle(query);
+  }
+
+  async update(id: string, data: Partial<Omit<Event, "id" | "createdAt">>): Promise<Event> {
+    const updated = await this.repository.update(id, data);
+
+    if (!updated) {
+      throw new Error(`Event with id ${id} not found`);
+    }
+
+    return updated;
+  }
+
+  async delete(id: string): Promise<boolean> {
+    return this.repository.delete(id);
+  }
+}

package/src/application/services/index.ts

@@ -0,0 +1,2 @@
+export { EventService } from "./EventService";
+export { DiaryService } from "./DiaryService";

package/src/application/tools/calendarTool.ts

@@ -0,0 +1,179 @@
+import { z } from "zod";
+import type { ToolDefinition } from "../../domain/interfaces/ILanguageModel";
+import type { ToolExecutor } from "../graph/nodes";
+import type { IEventsRepository } from "../../domain/interfaces/IEventsRepository";
+
+// ============================================================================
+// Schemas
+// ============================================================================
+
+export const AddEventSchema = z.object({
+  title: z.string().describe("Event title"),
+  datetime: z.string().describe("ISO 8601 datetime"),
+  endTime: z.string().optional().describe("ISO 8601 end time"),
+  notes: z.string().optional().describe("Additional notes"),
+  tags: z.array(z.string()).optional().describe("Event tags"),
+});
+
+export type AddEventInput = z.infer<typeof AddEventSchema>;
+
+export const QueryEventsSchema = z.object({
+  type: z.enum(["today", "tomorrow", "week", "date", "range"]),
+  date: z.string().optional().describe("Specific date 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 QueryEventsInput = z.infer<typeof QueryEventsSchema>;
+
+// ============================================================================
+// Tool Definitions (for LLM binding)
+// ============================================================================
+
+export const addEventToolDefinition: ToolDefinition = {
+  name: "add_calendar_event",
+  description: "Add a new event to the calendar",
+  parameters: {
+    type: "object",
+    properties: {
+      title: { type: "string", description: "Event title" },
+      datetime: { type: "string", description: "ISO 8601 datetime" },
+      endTime: { type: "string", description: "ISO 8601 end time" },
+      notes: { type: "string", description: "Additional notes" },
+      tags: { type: "array", items: { type: "string" }, description: "Event tags" },
+    },
+    required: ["title", "datetime"],
+  },
+};
+
+export const queryEventsToolDefinition: ToolDefinition = {
+  name: "query_calendar_events",
+  description: "Query calendar events by date or range",
+  parameters: {
+    type: "object",
+    properties: {
+      type: {
+        type: "string",
+        enum: ["today", "tomorrow", "week", "date", "range"],
+        description: "Query type",
+      },
+      date: { type: "string", description: "Specific date for 'date' type (YYYY-MM-DD)" },
+      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 calendarToolDefinitions: ToolDefinition[] = [
+  addEventToolDefinition,
+  queryEventsToolDefinition,
+];
+
+// ============================================================================
+// Tool Executor Factory - Creates executors with database repository
+// ============================================================================
+
+export function createCalendarToolExecutors(
+  eventsRepository: IEventsRepository
+): Record<string, ToolExecutor> {
+  const addEventExecutor: ToolExecutor = async (args) => {
+    const result = AddEventSchema.safeParse(args);
+    if (!result.success) {
+      throw new Error(`Validation Failed: ${result.error.message}`);
+    }
+
+    const input = result.data;
+    const id = crypto.randomUUID();
+    const now = new Date();
+
+    const event = await eventsRepository.create({
+      id,
+      title: input.title,
+      datetime: new Date(input.datetime),
+      endTime: input.endTime ? new Date(input.endTime) : undefined,
+      notes: input.notes,
+      tags: input.tags ?? [],
+      createdAt: now,
+    });
+
+    return JSON.stringify({
+      success: true,
+      event: {
+        id: event.id,
+        title: event.title,
+        datetime: event.datetime.toISOString(),
+        endTime: event.endTime?.toISOString(),
+        notes: event.notes,
+        tags: event.tags,
+      },
+    });
+  };
+
+  const queryEventsExecutor: ToolExecutor = async (args) => {
+    const result = QueryEventsSchema.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() + 1);
+        break;
+      case "tomorrow":
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 2);
+        break;
+      case "week":
+        startDate = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        endDate = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 7);
+        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(startDate.getTime() + 24 * 60 * 60 * 1000);
+        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 events = await eventsRepository.getByDateRange(startDate, endDate);
+
+    return JSON.stringify({
+      success: true,
+      query: {
+        type: input.type,
+        startDate: startDate.toISOString(),
+        endDate: endDate.toISOString(),
+      },
+      events: events.map((e) => ({
+        id: e.id,
+        title: e.title,
+        datetime: e.datetime.toISOString(),
+        endTime: e.endTime?.toISOString(),
+        notes: e.notes,
+        tags: e.tags,
+      })),
+    });
+  };
+
+  return {
+    add_calendar_event: addEventExecutor,
+    query_calendar_events: queryEventsExecutor,
+  };
+}