haroo 1.0.0

package/src/infrastructure/llm/openai.ts

@@ -0,0 +1,148 @@
+import type { LLMResponse, ToolDefinition, ToolCall, ILanguageModel } from "../../domain";
+import type { BaseMessage } from "@langchain/core/messages";
+import { zodToJsonSchema } from "zod-to-json-schema";
+import { BaseLLMAdapter } from "./base";
+
+interface OpenAIToolCall {
+  id: string;
+  type: "function";
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface OpenAIMessage {
+  role: string;
+  content: string | null;
+  tool_calls?: OpenAIToolCall[];
+  tool_call_id?: string;
+}
+
+interface OpenAIChoice {
+  message: OpenAIMessage;
+  finish_reason: string;
+}
+
+interface OpenAIResponse {
+  choices: OpenAIChoice[];
+}
+
+export class OpenAIAdapter extends BaseLLMAdapter {
+  private apiKey: string;
+  private structuredSchema: unknown = null;
+
+  constructor(model: string = "gpt-5-nano", apiKey?: string) {
+    super(model);
+    this.apiKey = apiKey ?? process.env.OPENAI_API_KEY ?? "";
+  }
+
+  async generate(messages: BaseMessage[], tools?: ToolDefinition[]): Promise<LLMResponse> {
+    if (!this.apiKey) {
+      throw new Error("OPENAI_API_KEY is required");
+    }
+
+    const formattedMessages = messages.map((m) => {
+      const type = m._getType();
+      const baseMsg: OpenAIMessage = {
+        role: type === "human" ? "user" : type === "ai" ? "assistant" : type,
+        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+      };
+
+      // Handle tool messages
+      if (type === "tool") {
+        baseMsg.role = "tool";
+        baseMsg.tool_call_id = (m as { tool_call_id?: string }).tool_call_id;
+      }
+
+      // Handle AI messages with tool calls
+      if (type === "ai" && m.additional_kwargs?.tool_calls) {
+        baseMsg.tool_calls = m.additional_kwargs.tool_calls as OpenAIToolCall[];
+      }
+
+      return baseMsg;
+    });
+
+    const requestBody: Record<string, unknown> = {
+      model: this.model,
+      messages: formattedMessages,
+    };
+
+    // Use function calling for structured output (most reliable approach)
+    if (this.structuredSchema && (!tools || tools.length === 0)) {
+      const jsonSchema = zodToJsonSchema(this.structuredSchema as any);
+      requestBody.tools = [
+        {
+          type: "function",
+          function: {
+            name: "structured_response",
+            description: "Return structured data matching the schema",
+            parameters: jsonSchema,
+          },
+        },
+      ];
+      requestBody.tool_choice = {
+        type: "function",
+        function: { name: "structured_response" },
+      };
+    } else if (tools && tools.length > 0) {
+      // Add tools if provided (regular tool use, not structured output)
+      requestBody.tools = tools.map((t) => ({
+        type: "function",
+        function: {
+          name: t.name,
+          description: t.description,
+          parameters: t.parameters,
+        },
+      }));
+    }
+
+    const response = await fetch("https://api.openai.com/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`OpenAI API error: ${response.statusText} - ${errorBody}`);
+    }
+
+    const data = (await response.json()) as OpenAIResponse;
+    const choice = data.choices?.[0];
+    const message = choice?.message;
+
+    // Handle structured output via function calling
+    if (this.structuredSchema && message?.tool_calls?.[0]) {
+      // Return the function arguments as content (already a JSON string)
+      return {
+        content: message.tool_calls[0].function.arguments,
+        toolCalls: undefined,
+      };
+    }
+
+    // Parse tool calls if present (regular tool use)
+    let toolCalls: ToolCall[] | undefined;
+    if (message?.tool_calls && message.tool_calls.length > 0) {
+      toolCalls = message.tool_calls.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        arguments: JSON.parse(tc.function.arguments),
+      }));
+    }
+
+    return {
+      content: message?.content ?? "",
+      toolCalls,
+    };
+  }
+
+  withStructuredOutput<T>(schema: unknown): ILanguageModel {
+    const adapter = new OpenAIAdapter(this.model, this.apiKey);
+    adapter.structuredSchema = schema;
+    return adapter;
+  }
+}

package/src/infrastructure/memory/checkpointer.ts

@@ -0,0 +1,19 @@
+import type { ICheckpointer } from "../../domain";
+import type { GraphStateType } from "../../domain/state/AgentState";
+
+export class InMemoryCheckpointer implements ICheckpointer {
+  private store: Map<string, GraphStateType> = new Map();
+
+  async save(sessionId: string, state: GraphStateType): Promise<void> {
+    this.store.set(sessionId, structuredClone(state));
+  }
+
+  async load(sessionId: string): Promise<GraphStateType | null> {
+    const state = this.store.get(sessionId);
+    return state ? structuredClone(state) : null;
+  }
+
+  async list(): Promise<string[]> {
+    return Array.from(this.store.keys());
+  }
+}

package/src/infrastructure/memory/index.ts

@@ -0,0 +1,2 @@
+// Re-export factory for convenience
+export { createBackend, createRepositories, createRepositoriesFromEnv } from "../database";

package/src/infrastructure/settings/index.ts

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { z } from "zod";
+
+const SETTINGS_DIR = join(homedir(), ".log");
+const SETTINGS_PATH = join(SETTINGS_DIR, "settings.json");
+
+const UserSettingsSchema = z.object({
+  defaultProvider: z.enum(["openai", "gemini", "ollama"]).optional(),
+  defaultModel: z.string().optional(),
+});
+
+export type UserSettings = z.infer<typeof UserSettingsSchema>;
+
+/**
+ * Get the path to the settings file.
+ */
+export function getSettingsPath(): string {
+  return SETTINGS_PATH;
+}
+
+/**
+ * Load user settings from disk.
+ * Returns empty object if file doesn't exist.
+ */
+export function getSettings(): UserSettings {
+  if (!existsSync(SETTINGS_PATH)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(SETTINGS_PATH, "utf-8");
+    const parsed = JSON.parse(content);
+    return UserSettingsSchema.parse(parsed);
+  } catch {
+    // If file is corrupted or invalid, return empty settings
+    return {};
+  }
+}
+
+/**
+ * Save user settings to disk.
+ * Merges with existing settings.
+ */
+export function saveSettings(updates: Partial<UserSettings>): void {
+  // Ensure directory exists
+  if (!existsSync(SETTINGS_DIR)) {
+    mkdirSync(SETTINGS_DIR, { recursive: true });
+  }
+
+  const current = getSettings();
+  const merged: UserSettings = { ...current, ...updates };
+
+  // Remove undefined values
+  const cleaned = Object.fromEntries(Object.entries(merged).filter(([, v]) => v !== undefined));
+
+  writeFileSync(SETTINGS_PATH, JSON.stringify(cleaned, null, 2) + "\n");
+}
+
+/**
+ * Get the effective provider, checking settings then env then default.
+ */
+export function getEffectiveProvider(cliOption?: string): "openai" | "gemini" | "ollama" {
+  if (cliOption && ["openai", "gemini", "ollama"].includes(cliOption)) {
+    return cliOption as "openai" | "gemini" | "ollama";
+  }
+
+  const settings = getSettings();
+  if (settings.defaultProvider) {
+    return settings.defaultProvider;
+  }
+
+  const envProvider = process.env.DEFAULT_PROVIDER;
+  if (envProvider && ["openai", "gemini", "ollama"].includes(envProvider)) {
+    return envProvider as "openai" | "gemini" | "ollama";
+  }
+
+  return "ollama";
+}
+
+/**
+ * Get the effective model, checking settings then env.
+ */
+export function getEffectiveModel(cliOption?: string): string | undefined {
+  if (cliOption) {
+    return cliOption;
+  }
+
+  const settings = getSettings();
+  if (settings.defaultModel) {
+    return settings.defaultModel;
+  }
+
+  return process.env.DEFAULT_MODEL;
+}

package/src/interface/cli/calendar.ts

@@ -0,0 +1,120 @@
+import chalk from "chalk";
+import type { Event } from "../../domain/entities/Event";
+
+function formatTime(date: Date): string {
+  return date.toLocaleTimeString("en-US", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: true,
+  });
+}
+
+function formatDate(date: Date): string {
+  return date.toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+  });
+}
+
+function formatEventLine(event: Event): string {
+  const time = formatTime(event.datetime);
+  const endTime = event.endTime ? ` - ${formatTime(event.endTime)}` : "";
+  const tags = event.tags.length > 0 ? ` ${chalk.dim(`[${event.tags.join(", ")}]`)}` : "";
+
+  return `  ${chalk.cyan(time)}${chalk.dim(endTime)} ${chalk.white(event.title)}${tags}`;
+}
+
+export function formatTodayEvents(events: Event[]): string {
+  const lines: string[] = [];
+  const today = new Date();
+
+  lines.push("");
+  lines.push(chalk.bold.blue(`  Today: ${formatDate(today)}`));
+  lines.push(chalk.dim(`  ${"─".repeat(40)}`));
+
+  if (events.length === 0) {
+    lines.push(chalk.dim("  No events scheduled for today"));
+  } else {
+    const sortedEvents = [...events].sort((a, b) => a.datetime.getTime() - b.datetime.getTime());
+
+    for (const event of sortedEvents) {
+      lines.push(formatEventLine(event));
+      if (event.notes) {
+        lines.push(chalk.dim(`    ${event.notes}`));
+      }
+    }
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+export function formatEventsForRange(events: Event[], startDate: Date, endDate: Date): string {
+  const lines: string[] = [];
+
+  lines.push("");
+  lines.push(chalk.bold.blue(`  Events: ${formatDate(startDate)} - ${formatDate(endDate)}`));
+  lines.push(chalk.dim(`  ${"─".repeat(40)}`));
+
+  if (events.length === 0) {
+    lines.push(chalk.dim("  No events in this range"));
+  } else {
+    const sortedEvents = [...events].sort((a, b) => a.datetime.getTime() - b.datetime.getTime());
+
+    let currentDateStr = "";
+
+    for (const event of sortedEvents) {
+      const eventDateStr = event.datetime.toDateString();
+
+      if (eventDateStr !== currentDateStr) {
+        currentDateStr = eventDateStr;
+        lines.push("");
+        lines.push(chalk.yellow(`  ${formatDate(event.datetime)}`));
+      }
+
+      lines.push(formatEventLine(event));
+      if (event.notes) {
+        lines.push(chalk.dim(`    ${event.notes}`));
+      }
+    }
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+export function formatUpcomingEvents(events: Event[], days: number): string {
+  const lines: string[] = [];
+
+  lines.push("");
+  lines.push(chalk.bold.blue(`  Upcoming ${days} days`));
+  lines.push(chalk.dim(`  ${"─".repeat(40)}`));
+
+  if (events.length === 0) {
+    lines.push(chalk.dim("  No upcoming events"));
+  } else {
+    const sortedEvents = [...events].sort((a, b) => a.datetime.getTime() - b.datetime.getTime());
+
+    let currentDateStr = "";
+
+    for (const event of sortedEvents) {
+      const eventDateStr = event.datetime.toDateString();
+
+      if (eventDateStr !== currentDateStr) {
+        currentDateStr = eventDateStr;
+        lines.push("");
+        lines.push(chalk.yellow(`  ${formatDate(event.datetime)}`));
+      }
+
+      lines.push(formatEventLine(event));
+      if (event.notes) {
+        lines.push(chalk.dim(`    ${event.notes}`));
+      }
+    }
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}

package/src/interface/cli/chat.ts

@@ -0,0 +1,185 @@
+import * as readline from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { HumanMessage } from "@langchain/core/messages";
+import { randomUUID } from "crypto";
+import { MemorySaver } from "@langchain/langgraph";
+
+import type { LLMProvider } from "./commands";
+import { buildGraph, type GraphConfig } from "../../application/graph/builder";
+import { createToolRegistry } from "../../application/tools";
+import { EventService } from "../../application/services";
+import type { RepositoryBundle } from "../../infrastructure/database/factory";
+import { createLLM } from "../../infrastructure/llm";
+import { printer } from "./printer";
+import { formatTodayEvents } from "./calendar";
+import type { GraphStateType } from "../../domain/state/AgentState";
+
+const EXIT_COMMANDS = new Set(["exit", "quit", "/exit", "/quit", "/q"]);
+const CLEAR_COMMANDS = new Set(["clear", "/clear", "/c"]);
+const HELP_COMMANDS = new Set(["help", "/help", "/h", "?"]);
+const CALENDAR_COMMANDS = new Set(["/today", "/cal", "/calendar"]);
+
+function printHelp(): void {
+  printer.blank();
+  printer.info("Available commands:");
+  printer.system("  /help, /h, ?        - Show this help message");
+  printer.system("  /today, /cal        - Show today's events");
+  printer.system("  /clear, /c          - Clear conversation history");
+  printer.system("  /exit, /quit, /q    - Exit the chat");
+  printer.blank();
+}
+
+export interface ChatLoopOptions {
+  provider: LLMProvider;
+  threadId?: string;
+  model?: string;
+  repositories: RepositoryBundle;
+}
+
+export async function startChat(options: ChatLoopOptions): Promise<void> {
+  const { provider, model, repositories } = options;
+  const threadId = options.threadId || randomUUID();
+
+  const llm = createLLM(provider, model);
+  const tools = createToolRegistry({
+    eventsRepository: repositories.events,
+    diaryRepository: repositories.diary,
+  });
+  const eventService = new EventService(repositories.events);
+
+  // Use MemorySaver for in-session state persistence
+  // This enables conversation history across turns within a session
+  const checkpointer = new MemorySaver();
+
+  const graphConfig: GraphConfig = {
+    llm,
+    tools,
+    eventService,
+    memoriesRepository: repositories.memories,
+    checkpointer,
+  };
+
+  const graph = buildGraph(graphConfig);
+
+  // Track conversation state for persistence to DB
+  let lastState: GraphStateType | null = null;
+
+  const rl = readline.createInterface({ input, output, terminal: true });
+
+  // Handle SIGINT (Ctrl+C) to save checkpoint before exit
+  process.on("SIGINT", async () => {
+    printer.blank();
+    printer.warn("Session interrupted, saving state...");
+    if (lastState) {
+      try {
+        await repositories.checkpointer.save(threadId, lastState);
+        printer.system(`Session saved: ${threadId}`);
+      } catch (error) {
+        printer.error(
+          `Failed to save session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    rl.close();
+    process.exit(0);
+  });
+
+  printer.blank();
+  printer.divider();
+  printer.success("Interactive Chat Session");
+  printer.system(`Thread: ${threadId}`);
+  printer.system(`Provider: ${provider}${model ? ` (${model})` : ""}`);
+  printer.divider();
+
+  // Show today's events on start
+  const spinner = printer.spinner("Loading today's events...");
+  spinner.start();
+  try {
+    const todayEvents = await eventService.getToday();
+    spinner.stop();
+    console.log(formatTodayEvents(todayEvents));
+  } catch (_error) {
+    spinner.stop();
+    printer.warn("Could not load today's events");
+  }
+
+  printer.info("Type /help for commands, /exit to quit");
+  printer.blank();
+
+  try {
+    while (true) {
+      const userInput = await rl.question("You: ");
+      const trimmedInput = userInput.trim();
+
+      if (!trimmedInput) {
+        continue;
+      }
+
+      if (EXIT_COMMANDS.has(trimmedInput.toLowerCase())) {
+        printer.blank();
+        printer.success("Goodbye!");
+        break;
+      }
+
+      if (CLEAR_COMMANDS.has(trimmedInput.toLowerCase())) {
+        printer.success("Conversation cleared");
+        continue;
+      }
+
+      if (HELP_COMMANDS.has(trimmedInput.toLowerCase())) {
+        printHelp();
+        continue;
+      }
+
+      if (CALENDAR_COMMANDS.has(trimmedInput.toLowerCase())) {
+        const calSpinner = printer.spinner("Loading today's events...");
+        calSpinner.start();
+        try {
+          const todayEvents = await eventService.getToday();
+          calSpinner.stop();
+          console.log(formatTodayEvents(todayEvents));
+        } catch (_error) {
+          calSpinner.stop();
+          printer.error("Could not load today's events");
+        }
+        continue;
+      }
+
+      const thinking = printer.spinner("Thinking...");
+      thinking.start();
+
+      try {
+        // Invoke with thread_id for checkpointer to track state
+        const result = (await graph.invoke(
+          { messages: [new HumanMessage(trimmedInput)] },
+          { configurable: { thread_id: threadId } }
+        )) as GraphStateType;
+        thinking.stop();
+
+        lastState = result;
+        const assistantContent = result.response || "(No response)";
+
+        printer.blank();
+        printer.assistant(assistantContent);
+        printer.blank();
+      } catch (error) {
+        thinking.stop();
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to get response: ${errorMessage}`);
+      }
+    }
+  } finally {
+    // Save final state to database checkpointer for cross-session persistence
+    if (lastState) {
+      try {
+        await repositories.checkpointer.save(threadId, lastState);
+        printer.system(`Session saved: ${threadId}`);
+      } catch (error) {
+        printer.error(
+          `Failed to save session: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    rl.close();
+  }
+}