haroo 1.0.0

package/src/interface/cli/commands.ts

@@ -0,0 +1,337 @@
+import { Command } from "commander";
+import { EventService, DiaryService } from "../../application/services";
+import { createRepositoriesFromEnv } from "../../infrastructure/database/factory";
+import { createLLM } from "../../infrastructure/llm";
+import {
+  getSettings,
+  saveSettings,
+  getEffectiveProvider,
+  getEffectiveModel,
+} from "../../infrastructure/settings";
+import { formatTodayEvents, formatUpcomingEvents } from "./calendar";
+import { startChat } from "./chat";
+import { printer } from "./printer";
+
+export type LLMProvider = "openai" | "gemini" | "ollama";
+const VALID_PROVIDERS: LLMProvider[] = ["openai", "gemini", "ollama"];
+
+export function createProgram(): Command {
+  const program = new Command();
+
+  program.name("haroo").description("AI-powered personal logging CLI").version("1.0.0");
+
+  program
+    .command("chat")
+    .description("Start an interactive chat session")
+    .option("-p, --provider <provider>", "LLM provider (openai, gemini, ollama)")
+    .option("-m, --model <model>", "Model name to use")
+    .option("-t, --thread <id>", "Resume a previous thread")
+    .action(async (options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const provider = getEffectiveProvider(options.provider);
+        const model = getEffectiveModel(options.model);
+
+        await startChat({
+          provider,
+          model,
+          threadId: options.thread,
+          repositories,
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to start chat: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("calendar")
+    .description("Show calendar events")
+    .option("-d, --days <number>", "Number of upcoming days to show", "7")
+    .option("--today", "Show only today's events")
+    .action(async (options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const eventService = new EventService(repositories.events);
+
+        if (options.today) {
+          const events = await eventService.getToday();
+          console.log(formatTodayEvents(events));
+        } else {
+          const days = parseInt(options.days, 10);
+          const events = await eventService.getUpcoming(days);
+          console.log(formatUpcomingEvents(events, days));
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to load calendar: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  program
+    .command("sessions")
+    .description("List saved sessions")
+    .action(async () => {
+      printer.warn("Sessions listing not yet implemented");
+    });
+
+  // Model configuration command
+  program
+    .command("model")
+    .description("View or set default LLM provider and model")
+    .argument("[provider]", "Provider to set (openai, gemini, ollama)")
+    .argument("[model]", "Model name to use")
+    .action((provider?: string, model?: string) => {
+      // If no arguments, show current settings
+      if (!provider) {
+        const settings = getSettings();
+        const effectiveProvider = getEffectiveProvider();
+        const effectiveModel = getEffectiveModel();
+
+        printer.blank();
+        printer.info("Current Model Settings");
+        printer.divider();
+        printer.system(
+          `Provider: ${effectiveProvider}${settings.defaultProvider ? "" : " (default)"}`
+        );
+        if (effectiveModel) {
+          printer.system(`Model: ${effectiveModel}${settings.defaultModel ? "" : " (default)"}`);
+        } else {
+          printer.system("Model: (provider default)");
+        }
+        printer.blank();
+        printer.system("Saved settings file: ~/.log/settings.json");
+        printer.blank();
+        return;
+      }
+
+      // Validate provider
+      if (!VALID_PROVIDERS.includes(provider as LLMProvider)) {
+        printer.error(`Invalid provider: ${provider}`);
+        printer.info(`Valid providers: ${VALID_PROVIDERS.join(", ")}`);
+        process.exit(1);
+      }
+
+      // Save settings
+      saveSettings({
+        defaultProvider: provider as LLMProvider,
+        defaultModel: model,
+      });
+
+      if (model) {
+        printer.success(`Default model set to: ${provider} / ${model}`);
+      } else {
+        printer.success(`Default provider set to: ${provider}`);
+      }
+    });
+
+  // Diary commands
+  const diaryCmd = program.command("diary").description("Diary/journal operations");
+
+  diaryCmd
+    .command("generate")
+    .description("Generate diary entry for a date")
+    .option("-d, --date <date>", "Date to generate (YYYY-MM-DD), defaults to yesterday")
+    .option("-p, --provider <provider>", "LLM provider (openai, gemini, ollama)")
+    .option("-m, --model <model>", "Model name to use")
+    .action(async (options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const provider = getEffectiveProvider(options.provider);
+        const model = getEffectiveModel(options.model);
+        const llm = createLLM(provider, model);
+        const diaryService = new DiaryService(repositories.diary, repositories.checkpointer, llm);
+
+        let targetDate: Date;
+        if (options.date) {
+          targetDate = new Date(options.date);
+          targetDate.setHours(0, 0, 0, 0);
+        } else {
+          // Default to yesterday
+          targetDate = new Date();
+          targetDate.setDate(targetDate.getDate() - 1);
+          targetDate.setHours(0, 0, 0, 0);
+        }
+
+        const dateStr = targetDate.toISOString().split("T")[0];
+        const spinner = printer.spinner(`Generating diary entry for ${dateStr}...`);
+        spinner.start();
+
+        const entry = await diaryService.generateDiaryEntry(targetDate);
+        spinner.stop();
+
+        if (entry) {
+          printer.success(`Diary entry created for ${dateStr}`);
+          printer.blank();
+          printer.info(`Mood: ${entry.mood} (${entry.moodScore}/10)`);
+          printer.blank();
+          printer.system("Summary:");
+          console.log(`  ${entry.summary}`);
+          printer.blank();
+          printer.system("Therapeutic Advice:");
+          console.log(`  ${entry.therapeuticAdvice}`);
+          printer.blank();
+          printer.system(`Messages analyzed: ${entry.messageCount}`);
+        } else {
+          printer.warn(`No conversations found for ${dateStr}`);
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to generate diary entry: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  diaryCmd
+    .command("show")
+    .description("Show recent diary entries")
+    .option("-n, --count <number>", "Number of entries to show", "7")
+    .action(async (options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const count = parseInt(options.count, 10);
+
+        const entries = await repositories.diary.getRecent(count);
+
+        if (entries.length === 0) {
+          printer.warn("No diary entries found");
+          return;
+        }
+
+        printer.blank();
+        printer.divider();
+        printer.success(`Recent Diary Entries (${entries.length})`);
+        printer.divider();
+
+        for (const entry of entries) {
+          const dateStr = entry.entryDate.toISOString().split("T")[0];
+          printer.blank();
+          printer.info(`${dateStr} - ${entry.mood} (${entry.moodScore}/10)`);
+          console.log(`  ${entry.summary}`);
+          printer.system(`  Advice: ${entry.therapeuticAdvice}`);
+        }
+
+        printer.blank();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to load diary entries: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  // Memory commands
+  const memoryCmd = program.command("memory").description("Manage stored memories");
+
+  memoryCmd
+    .command("list", { isDefault: true })
+    .description("View stored memories")
+    .option("-t, --type <type>", "Filter by type")
+    .option("-n, --count <number>", "Number to show", "20")
+    .action(async (options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const count = parseInt(options.count, 10);
+
+        let memories;
+        if (options.type) {
+          memories = await repositories.memories.getByType(options.type);
+        } else {
+          memories = await repositories.memories.getAll(count);
+        }
+
+        if (memories.length === 0) {
+          printer.warn("No memories stored yet");
+          return;
+        }
+
+        printer.blank();
+        printer.success(`Memories (${memories.length})`);
+        printer.divider();
+
+        for (const memory of memories) {
+          printer.info(`[${memory.id.slice(0, 8)}] [${memory.type}] ${memory.content}`);
+          printer.system(`  Importance: ${memory.importance}/10`);
+        }
+        printer.blank();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to load memories: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  memoryCmd
+    .command("add <content>")
+    .description("Add a new memory")
+    .option("-t, --type <type>", "Memory type", "fact")
+    .option("-i, --importance <number>", "Importance 1-10", "5")
+    .action(async (content, options) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+
+        const memory = {
+          id: crypto.randomUUID(),
+          type: options.type as
+            | "fact"
+            | "preference"
+            | "routine"
+            | "relationship"
+            | "communication_style"
+            | "interest",
+          content: content,
+          importance: parseInt(options.importance, 10),
+          createdAt: new Date(),
+          lastAccessed: new Date(),
+        };
+
+        await repositories.memories.create(memory);
+        printer.success(`Memory added: ${memory.id.slice(0, 8)}`);
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to add memory: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  memoryCmd
+    .command("edit <id> <content>")
+    .description("Edit a memory")
+    .action(async (id, content) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const result = await repositories.memories.update(id, { content });
+        if (result) {
+          printer.success("Memory updated");
+        } else {
+          printer.error("Memory not found");
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to edit memory: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  memoryCmd
+    .command("delete <id>")
+    .description("Delete a memory")
+    .action(async (id) => {
+      try {
+        const repositories = createRepositoriesFromEnv();
+        const deleted = await repositories.memories.delete(id);
+        if (deleted) {
+          printer.success("Memory deleted");
+        } else {
+          printer.error("Memory not found");
+        }
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        printer.error(`Failed to delete memory: ${errorMessage}`);
+        process.exit(1);
+      }
+    });
+
+  return program;
+}

package/src/interface/cli/printer.ts

@@ -0,0 +1,65 @@
+import chalk from "chalk";
+import ora, { type Ora } from "ora";
+
+export interface Printer {
+  info(message: string): void;
+  success(message: string): void;
+  error(message: string): void;
+  warn(message: string): void;
+  user(message: string): void;
+  assistant(message: string): void;
+  system(message: string): void;
+  blank(): void;
+  divider(): void;
+  spinner(message: string): Ora;
+}
+
+export function createPrinter(): Printer {
+  return {
+    info(message: string): void {
+      console.log(chalk.blue("ℹ"), message);
+    },
+
+    success(message: string): void {
+      console.log(chalk.green("✓"), message);
+    },
+
+    error(message: string): void {
+      console.log(chalk.red("✗"), message);
+    },
+
+    warn(message: string): void {
+      console.log(chalk.yellow("⚠"), message);
+    },
+
+    user(message: string): void {
+      console.log(chalk.cyan.bold("You:"), message);
+    },
+
+    assistant(message: string): void {
+      console.log(chalk.magenta.bold("Assistant:"), message);
+    },
+
+    system(message: string): void {
+      console.log(chalk.dim(`[${message}]`));
+    },
+
+    blank(): void {
+      console.log();
+    },
+
+    divider(): void {
+      console.log(chalk.dim("─".repeat(50)));
+    },
+
+    spinner(message: string): Ora {
+      return ora({
+        text: message,
+        color: "cyan",
+        discardStdin: false,
+      });
+    },
+  };
+}
+
+export const printer = createPrinter();

package/src/interface/index.ts

@@ -0,0 +1 @@
+export { createProgram } from "./cli/commands";