haroo 1.0.0

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

@@ -0,0 +1,284 @@
+import type { Database } from "bun:sqlite";
+import { z } from "zod";
+import { type Memory, MemorySchema } from "../../domain/entities/Memory";
+import type {
+  EmbeddingFunction,
+  IMemoriesRepository,
+} from "../../domain/interfaces/IMemoriesRepository";
+import type { IVectorStore } from "../../domain/interfaces/IMemory";
+
+const MemoryRowSchema = z.object({
+  id: z.string().uuid(),
+  type: z.enum([
+    "fact",
+    "preference",
+    "routine",
+    "relationship",
+    "communication_style",
+    "interest",
+  ]),
+  content: z.string(),
+  source: z.string().nullable(),
+  importance: z.number(),
+  last_accessed: z.string(),
+  created_at: z.string(),
+});
+
+type MemoryRow = z.infer<typeof MemoryRowSchema>;
+
+function rowToMemory(row: MemoryRow): Memory {
+  return MemorySchema.parse({
+    id: row.id,
+    type: row.type,
+    content: row.content,
+    source: row.source ?? undefined,
+    importance: row.importance,
+    lastAccessed: new Date(row.last_accessed),
+    createdAt: new Date(row.created_at),
+  });
+}
+
+export class SqliteMemoriesRepository implements IMemoriesRepository, IVectorStore {
+  private embedFn: EmbeddingFunction | null = null;
+
+  constructor(private readonly db: Database) {}
+
+  setEmbeddingFunction(fn: EmbeddingFunction): void {
+    this.embedFn = fn;
+  }
+
+  async create(memory: Memory, embedding?: number[]): Promise<Memory> {
+    // Insert metadata
+    this.db
+      .prepare(
+        `
+      INSERT INTO memories (id, type, content, source, importance, last_accessed, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?)
+    `
+      )
+      .run(
+        memory.id,
+        memory.type,
+        memory.content,
+        memory.source ?? null,
+        memory.importance,
+        memory.lastAccessed.toISOString(),
+        memory.createdAt.toISOString()
+      );
+
+    // Insert embedding if provided
+    if (embedding) {
+      this.db
+        .prepare("INSERT INTO vec_memories (memory_id, embedding) VALUES (?, ?)")
+        .run(memory.id, new Float32Array(embedding));
+    }
+
+    return memory;
+  }
+
+  async getById(id: string): Promise<Memory | null> {
+    const row = this.db
+      .prepare(
+        `
+      SELECT id, type, content, source, importance, last_accessed, created_at
+      FROM memories WHERE id = ?
+    `
+      )
+      .get(id) as MemoryRow | undefined;
+
+    if (!row) {
+      return null;
+    }
+
+    return rowToMemory(MemoryRowSchema.parse(row));
+  }
+
+  async getByType(type: Memory["type"]): Promise<Memory[]> {
+    const rows = this.db
+      .prepare(
+        `
+      SELECT id, type, content, source, importance, last_accessed, created_at
+      FROM memories
+      WHERE type = ?
+      ORDER BY importance DESC
+    `
+      )
+      .all(type) as MemoryRow[];
+
+    return rows.map((row) => rowToMemory(MemoryRowSchema.parse(row)));
+  }
+
+  async getAll(limit = 20): Promise<Memory[]> {
+    const rows = this.db
+      .prepare(
+        `
+      SELECT id, type, content, source, importance, last_accessed, created_at
+      FROM memories
+      ORDER BY importance DESC, created_at DESC
+      LIMIT ?
+    `
+      )
+      .all(limit) as MemoryRow[];
+
+    return rows.map((row) => rowToMemory(MemoryRowSchema.parse(row)));
+  }
+
+  async semanticSearch(embedding: number[], limit = 5, threshold = 0.7): Promise<Memory[]> {
+    // sqlite-vec uses cosine distance, so convert similarity threshold to distance
+    // similarity = 1 - distance, so distance = 1 - similarity
+    const maxDistance = 1 - threshold;
+
+    const rows = this.db
+      .prepare(
+        `
+      SELECT
+        m.id, m.type, m.content, m.source, m.importance, m.last_accessed, m.created_at,
+        v.distance
+      FROM vec_memories v
+      JOIN memories m ON m.id = v.memory_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+      ORDER BY v.distance
+    `
+      )
+      .all(new Float32Array(embedding), limit) as (MemoryRow & {
+      distance: number;
+    })[];
+
+    // Filter by threshold after query (sqlite-vec doesn't support WHERE on distance in MATCH)
+    return rows
+      .filter((row) => row.distance <= maxDistance)
+      .map((row) => rowToMemory(MemoryRowSchema.parse(row)));
+  }
+
+  async update(
+    id: string,
+    updates: Partial<Omit<Memory, "id" | "createdAt">>
+  ): Promise<Memory | null> {
+    const setters: string[] = [];
+    const values: (string | number | null)[] = [];
+
+    if (updates.type !== undefined) {
+      setters.push("type = ?");
+      values.push(updates.type);
+    }
+    if (updates.content !== undefined) {
+      setters.push("content = ?");
+      values.push(updates.content);
+    }
+    if (updates.source !== undefined) {
+      setters.push("source = ?");
+      values.push(updates.source ?? null);
+    }
+    if (updates.importance !== undefined) {
+      setters.push("importance = ?");
+      values.push(updates.importance);
+    }
+    if (updates.lastAccessed !== undefined) {
+      setters.push("last_accessed = ?");
+      values.push(updates.lastAccessed.toISOString());
+    }
+
+    if (setters.length === 0) {
+      return this.getById(id);
+    }
+
+    values.push(id);
+
+    const result = this.db
+      .prepare(`UPDATE memories SET ${setters.join(", ")} WHERE id = ?`)
+      .run(...values);
+
+    if (result.changes === 0) {
+      return null;
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: string): Promise<boolean> {
+    // Delete from both tables (vector table first due to foreign key logic)
+    this.db.prepare("DELETE FROM vec_memories WHERE memory_id = ?").run(id);
+    const result = this.db.prepare("DELETE FROM memories WHERE id = ?").run(id);
+
+    return result.changes > 0;
+  }
+
+  async updateLastAccessed(id: string): Promise<void> {
+    this.db
+      .prepare("UPDATE memories SET last_accessed = ? WHERE id = ?")
+      .run(new Date().toISOString(), id);
+  }
+
+  async getRecent(limit = 10): Promise<Memory[]> {
+    const rows = this.db
+      .prepare(
+        `
+      SELECT id, type, content, source, importance, last_accessed, created_at
+      FROM memories
+      ORDER BY last_accessed DESC
+      LIMIT ?
+    `
+      )
+      .all(limit) as MemoryRow[];
+
+    return rows.map((row) => rowToMemory(MemoryRowSchema.parse(row)));
+  }
+
+  // IVectorStore implementation
+  async addDocuments(
+    docs: { content: string; metadata?: Record<string, unknown> }[]
+  ): Promise<void> {
+    if (!this.embedFn) {
+      throw new Error("Embedding function not set. Call setEmbeddingFunction first.");
+    }
+
+    for (const doc of docs) {
+      const embedding = await this.embedFn(doc.content);
+      const id = crypto.randomUUID();
+      const now = new Date();
+
+      const memory: Memory = {
+        id,
+        type: (doc.metadata?.type as Memory["type"]) ?? "fact",
+        content: doc.content,
+        source: doc.metadata?.source as string | undefined,
+        importance: (doc.metadata?.importance as number) ?? 5,
+        lastAccessed: now,
+        createdAt: now,
+      };
+
+      await this.create(memory, embedding);
+    }
+  }
+
+  async search(query: string, limit = 5): Promise<{ content: string; score: number }[]> {
+    if (!this.embedFn) {
+      throw new Error("Embedding function not set. Call setEmbeddingFunction first.");
+    }
+
+    const queryEmbedding = await this.embedFn(query);
+
+    const rows = this.db
+      .prepare(
+        `
+      SELECT m.content, v.distance
+      FROM vec_memories v
+      JOIN memories m ON m.id = v.memory_id
+      WHERE v.embedding MATCH ?
+        AND k = ?
+      ORDER BY v.distance
+    `
+      )
+      .all(new Float32Array(queryEmbedding), limit) as {
+      content: string;
+      distance: number;
+    }[];
+
+    // Convert distance to similarity score (1 - distance for cosine)
+    return rows.map((row) => ({
+      content: row.content,
+      score: 1 - row.distance,
+    }));
+  }
+}

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

@@ -0,0 +1,98 @@
+import type { Database } from "bun:sqlite";
+
+/**
+ * Initialize SQLite schema with all required tables.
+ * Safe to call multiple times (uses IF NOT EXISTS).
+ */
+export function initializeSqliteSchema(db: Database): void {
+  // Events table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id TEXT PRIMARY KEY,
+      title TEXT NOT NULL,
+      datetime TEXT NOT NULL,
+      end_time TEXT,
+      notes TEXT,
+      tags TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_events_datetime ON events(datetime)
+  `);
+
+  // Memories metadata table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      type TEXT CHECK (type IN ('fact', 'preference', 'routine', 'relationship', 'communication_style', 'interest')),
+      content TEXT NOT NULL,
+      source TEXT,
+      importance INTEGER CHECK (importance BETWEEN 1 AND 10),
+      last_accessed TEXT,
+      created_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_memories_importance ON memories(importance DESC)
+  `);
+
+  // Vector table for memory embeddings (sqlite-vec)
+  // Note: vec0 tables don't support IF NOT EXISTS, so we check manually
+  const vecTableExists = db
+    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='vec_memories'")
+    .get();
+
+  if (!vecTableExists) {
+    db.exec(`
+      CREATE VIRTUAL TABLE vec_memories USING vec0(
+        memory_id TEXT PRIMARY KEY,
+        embedding float[1536] distance_metric=cosine
+      )
+    `);
+  }
+
+  // Checkpoints table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS checkpoints (
+      session_id TEXT PRIMARY KEY,
+      state TEXT NOT NULL,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_checkpoints_updated ON checkpoints(updated_at DESC)
+  `);
+
+  // Diary entries table
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS diary_entries (
+      id TEXT PRIMARY KEY,
+      entry_date TEXT NOT NULL UNIQUE,
+      summary TEXT NOT NULL,
+      mood TEXT NOT NULL,
+      mood_score INTEGER CHECK (mood_score BETWEEN 1 AND 10),
+      therapeutic_advice TEXT NOT NULL,
+      session_ids TEXT,
+      message_count INTEGER,
+      created_at TEXT DEFAULT (datetime('now')),
+      updated_at TEXT DEFAULT (datetime('now'))
+    )
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_diary_entry_date ON diary_entries(entry_date DESC)
+  `);
+
+  db.exec(`
+    CREATE INDEX IF NOT EXISTS idx_diary_mood ON diary_entries(mood)
+  `);
+}

package/src/infrastructure/index.ts

@@ -0,0 +1,3 @@
+export * from "./database";
+export * from "./llm";
+export * from "./memory";

package/src/infrastructure/llm/base.ts

@@ -0,0 +1,14 @@
+import type { ILanguageModel, LLMResponse, ToolDefinition } from "../../domain";
+import type { BaseMessage } from "@langchain/core/messages";
+
+export abstract class BaseLLMAdapter implements ILanguageModel {
+  protected model: string;
+
+  constructor(model: string) {
+    this.model = model;
+  }
+
+  abstract generate(messages: BaseMessage[], tools?: ToolDefinition[]): Promise<LLMResponse>;
+
+  abstract withStructuredOutput<T>(schema: unknown): ILanguageModel;
+}

package/src/infrastructure/llm/gemini.ts

@@ -0,0 +1,139 @@
+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 GeminiFunctionCall {
+  name: string;
+  args: Record<string, unknown>;
+}
+
+interface GeminiPart {
+  text?: string;
+  functionCall?: GeminiFunctionCall;
+}
+
+interface GeminiCandidate {
+  content: {
+    parts: GeminiPart[];
+  };
+}
+
+interface GeminiResponse {
+  candidates: GeminiCandidate[];
+}
+
+export class GeminiAdapter extends BaseLLMAdapter {
+  private apiKey: string;
+  private structuredSchema: unknown = null;
+
+  constructor(model: string = "gemini-pro", apiKey?: string) {
+    super(model);
+    this.apiKey = apiKey ?? process.env.GEMINI_API_KEY ?? "";
+  }
+
+  async generate(messages: BaseMessage[], tools?: ToolDefinition[]): Promise<LLMResponse> {
+    if (!this.apiKey) {
+      throw new Error("GEMINI_API_KEY is required");
+    }
+
+    const formattedMessages = messages.map((m) => {
+      const type = m._getType();
+      return {
+        role: type === "human" ? "user" : "model",
+        parts: [{ text: typeof m.content === "string" ? m.content : JSON.stringify(m.content) }],
+      };
+    });
+
+    const requestBody: Record<string, unknown> = {
+      contents: formattedMessages,
+    };
+
+    // Use function calling for structured output
+    if (this.structuredSchema && (!tools || tools.length === 0)) {
+      const jsonSchema = zodToJsonSchema(this.structuredSchema as any);
+      requestBody.tools = [
+        {
+          functionDeclarations: [
+            {
+              name: "structured_response",
+              description: "Return structured data matching the schema",
+              parameters: jsonSchema,
+            },
+          ],
+        },
+      ];
+      requestBody.toolConfig = {
+        functionCallingConfig: {
+          mode: "ANY",
+          allowedFunctionNames: ["structured_response"],
+        },
+      };
+    } else if (tools && tools.length > 0) {
+      // Add tools if provided (regular tool use, not structured output)
+      requestBody.tools = [
+        {
+          functionDeclarations: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters,
+          })),
+        },
+      ];
+    }
+
+    const response = await fetch(
+      `https://generativelanguage.googleapis.com/v1beta/models/${this.model}:generateContent?key=${this.apiKey}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(requestBody),
+      }
+    );
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Gemini API error: ${response.statusText} - ${errorBody}`);
+    }
+
+    const data = (await response.json()) as GeminiResponse;
+    const parts = data.candidates?.[0]?.content?.parts ?? [];
+
+    // Check for function calls
+    const functionCalls = parts.filter((p) => p.functionCall);
+
+    // Handle structured output via function calling
+    if (this.structuredSchema && functionCalls.length > 0) {
+      // Return the function arguments as content
+      return {
+        content: JSON.stringify(functionCalls[0].functionCall!.args),
+        toolCalls: undefined,
+      };
+    }
+
+    // Parse tool calls if present (regular tool use)
+    let toolCalls: ToolCall[] | undefined;
+    if (functionCalls.length > 0) {
+      toolCalls = functionCalls.map((p, idx) => ({
+        id: `call_${idx}`,
+        name: p.functionCall!.name,
+        arguments: p.functionCall!.args,
+      }));
+    }
+
+    // Get text content
+    const textParts = parts.filter((p) => p.text);
+    const content = textParts.map((p) => p.text).join("");
+
+    return {
+      content,
+      toolCalls,
+    };
+  }
+
+  withStructuredOutput<T>(schema: unknown): ILanguageModel {
+    const adapter = new GeminiAdapter(this.model, this.apiKey);
+    adapter.structuredSchema = schema;
+    return adapter;
+  }
+}

package/src/infrastructure/llm/index.ts

@@ -0,0 +1,22 @@
+import type { ILanguageModel } from "../../domain";
+import type { LLMProvider } from "../../interface/cli/commands";
+import { GeminiAdapter } from "./gemini";
+import { OllamaAdapter } from "./ollama";
+import { OpenAIAdapter } from "./openai";
+
+export { GeminiAdapter } from "./gemini";
+export { OllamaAdapter } from "./ollama";
+export { OpenAIAdapter } from "./openai";
+
+export function createLLM(provider: LLMProvider, model?: string): ILanguageModel {
+  switch (provider) {
+    case "ollama":
+      return new OllamaAdapter(model);
+    case "openai":
+      return new OpenAIAdapter(model);
+    case "gemini":
+      return new GeminiAdapter(model);
+    default:
+      throw new Error(`Unknown provider: ${provider}`);
+  }
+}

package/src/infrastructure/llm/ollama.ts

@@ -0,0 +1,126 @@
+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 OllamaToolCall {
+  function: {
+    name: string;
+    arguments: Record<string, unknown>;
+  };
+}
+
+interface OllamaMessage {
+  role: string;
+  content: string;
+  tool_calls?: OllamaToolCall[];
+}
+
+interface OllamaResponse {
+  message: OllamaMessage;
+}
+
+export class OllamaAdapter extends BaseLLMAdapter {
+  private baseUrl: string;
+  private structuredSchema: unknown = null;
+
+  constructor(model: string = "llama3.1:latest", baseUrl: string = "http://localhost:11434") {
+    super(model);
+    this.baseUrl = baseUrl;
+  }
+
+  async generate(messages: BaseMessage[], tools?: ToolDefinition[]): Promise<LLMResponse> {
+    const formattedMessages = messages.map((m) => {
+      const type = m._getType();
+      return {
+        role: type === "human" ? "user" : type === "ai" ? "assistant" : type,
+        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+      };
+    });
+
+    const requestBody: Record<string, unknown> = {
+      model: this.model,
+      messages: formattedMessages,
+      stream: false,
+    };
+
+    // Use function calling for structured output
+    if (this.structuredSchema && (!tools || tools.length === 0)) {
+      const jsonSchema = zodToJsonSchema(this.structuredSchema as any);
+      // Ollama accepts JSON schema directly in format parameter
+      requestBody.format = jsonSchema;
+      // Also add as tool for models that support function calling
+      requestBody.tools = [
+        {
+          type: "function",
+          function: {
+            name: "structured_response",
+            description: "Return structured data matching the schema",
+            parameters: jsonSchema,
+          },
+        },
+      ];
+    } 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(`${this.baseUrl}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new Error(`Ollama API error: ${response.statusText} - ${errorBody}`);
+    }
+
+    const data = (await response.json()) as OllamaResponse;
+    const message = data.message;
+
+    // Handle structured output - Ollama returns content directly with format schema
+    if (this.structuredSchema) {
+      // For structured output, the response comes in content (format parameter enforces schema)
+      // If model supports function calling, it might also come via tool_calls
+      if (message?.tool_calls?.[0]) {
+        return {
+          content: JSON.stringify(message.tool_calls[0].function.arguments),
+          toolCalls: undefined,
+        };
+      }
+      return {
+        content: message?.content ?? "",
+        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, idx) => ({
+        id: `call_${idx}`,
+        name: tc.function.name,
+        arguments: tc.function.arguments,
+      }));
+    }
+
+    return {
+      content: message?.content ?? "",
+      toolCalls,
+    };
+  }
+
+  withStructuredOutput<T>(schema: unknown): ILanguageModel {
+    const adapter = new OllamaAdapter(this.model, this.baseUrl);
+    adapter.structuredSchema = schema;
+    return adapter;
+  }
+}