heyhank 0.1.0 → 0.2.0

package/server/memory-service.ts

@@ -0,0 +1,296 @@
+// ─── Memory Service ─────────────────────────────────────────────────────────
+// 100% local semantic memory using vectra + transformers.js embeddings.
+// When obsidianVaultPath is set, vault .md files are the primary store
+// and Vectra becomes a search-only index rebuilt from vault files.
+
+import { getEmbedding, isEmbeddingReady } from "./embedding-service.js";
+import * as vectorStore from "./vector-store.js";
+import { getSettings } from "./settings-manager.js";
+import * as vaultMd from "./vault-markdown.js";
+import { markPendingWrite } from "./vault-watcher.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+export interface Memory {
+  id: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+// ─── Vault Helpers ──────────────────────────────────────────────────────────
+
+function getMemoryDir(): string | null {
+  const vaultPath = getSettings().obsidianVaultPath;
+  if (!vaultPath) return null;
+  const dir = join(vaultPath, "HeyHank", "Memory");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+export async function addMemory(content: string, metadata?: Record<string, unknown>): Promise<Memory> {
+  const id = crypto.randomUUID();
+  const createdAt = new Date().toISOString();
+  const meta = { ...metadata, createdAt };
+
+  // Write to vault if configured (primary store)
+  const dir = getMemoryDir();
+  if (dir) {
+    const memObj: vaultMd.Memory = {
+      id,
+      content,
+      createdAt,
+      updatedAt: createdAt,
+      category: metadata?.category as string | undefined,
+      source: metadata?.source as string | undefined,
+    };
+    markPendingWrite(`memory-${id}.md`);
+    writeFileSync(join(dir, `memory-${id}.md`), vaultMd.memoryToMarkdown(memObj), "utf-8");
+  }
+
+  // Index in Vectra (search index)
+  let embedding: number[];
+  try {
+    embedding = await getEmbedding(content, "passage: ");
+  } catch (err) {
+    console.log(`[memory] Embedding failed, storing with zero vector: ${err}`);
+    embedding = new Array(384).fill(0);
+  }
+  await vectorStore.addItem(id, content, embedding, meta);
+
+  return { id, content, metadata, createdAt };
+}
+
+export async function searchMemories(query: string, limit = 5): Promise<Memory[]> {
+  try {
+    const embedding = await getEmbedding(query, "query: ");
+    const results = await vectorStore.searchByVector(embedding, limit);
+    return results.map(toMemory);
+  } catch (err) {
+    console.log(`[memory] Semantic search failed, falling back to keyword: ${err}`);
+    const results = await vectorStore.keywordSearch(query, limit);
+    return results.map(toMemory);
+  }
+}
+
+export async function listMemories(limit = 50): Promise<Memory[]> {
+  const dir = getMemoryDir();
+  if (dir) {
+    // Read from vault (primary)
+    const files = readdirSync(dir).filter(f => f.startsWith("memory-") && f.endsWith(".md"));
+    const memories: Memory[] = [];
+    for (const file of files) {
+      try {
+        const raw = readFileSync(join(dir, file), "utf-8");
+        const mem = vaultMd.markdownToMemory(raw);
+        memories.push({
+          id: mem.id,
+          content: mem.content,
+          metadata: {
+            createdAt: mem.createdAt,
+            ...(mem.category ? { category: mem.category } : {}),
+            ...(mem.source ? { source: mem.source } : {}),
+          },
+          createdAt: mem.createdAt,
+          updatedAt: mem.updatedAt || undefined,
+        });
+      } catch { /* skip malformed files */ }
+    }
+    return memories
+      .sort((a, b) => {
+        const ta = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+        const tb = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+        return tb - ta;
+      })
+      .slice(0, limit);
+  }
+
+  // Fallback: read from Vectra
+  const items = await vectorStore.listAll();
+  return items
+    .map(toMemory)
+    .sort((a, b) => {
+      const ta = a.createdAt ? new Date(a.createdAt).getTime() : 0;
+      const tb = b.createdAt ? new Date(b.createdAt).getTime() : 0;
+      return tb - ta;
+    })
+    .slice(0, limit);
+}
+
+export async function updateMemory(id: string, content: string, metadata?: Record<string, unknown>): Promise<Memory | null> {
+  const dir = getMemoryDir();
+  const updatedAt = new Date().toISOString();
+
+  if (dir) {
+    // Update in vault (primary)
+    const filepath = join(dir, `memory-${id}.md`);
+    if (!existsSync(filepath)) return null;
+    const oldRaw = readFileSync(filepath, "utf-8");
+    const oldMem = vaultMd.markdownToMemory(oldRaw);
+    const memObj: vaultMd.Memory = {
+      id,
+      content,
+      createdAt: oldMem.createdAt,
+      updatedAt,
+      category: (metadata?.category as string | undefined) || oldMem.category,
+      source: (metadata?.source as string | undefined) || oldMem.source,
+    };
+    markPendingWrite(`memory-${id}.md`);
+    writeFileSync(filepath, vaultMd.memoryToMarkdown(memObj), "utf-8");
+
+    // Re-index in Vectra
+    const mergedMeta = { ...metadata, createdAt: oldMem.createdAt, updatedAt };
+    let embedding: number[];
+    try { embedding = await getEmbedding(content, "passage: "); } catch { embedding = new Array(384).fill(0); }
+    await vectorStore.deleteItem(id);
+    await vectorStore.addItem(id, content, embedding, mergedMeta);
+
+    return { id, content, metadata: mergedMeta, createdAt: oldMem.createdAt, updatedAt };
+  }
+
+  // Fallback: original Vectra-only logic
+  const items = await vectorStore.listAll();
+  const existing = items.find(i => i.id === id);
+  if (!existing) return null;
+  const mergedMeta = { ...existing.metadata, ...metadata, updatedAt };
+  let embedding: number[];
+  try { embedding = await getEmbedding(content, "passage: "); } catch { embedding = new Array(384).fill(0); }
+  await vectorStore.deleteItem(id);
+  await vectorStore.addItem(id, content, embedding, mergedMeta);
+  return { id, content, metadata: mergedMeta, createdAt: (mergedMeta as Record<string, unknown>).createdAt as string | undefined, updatedAt };
+}
+
+export async function deleteMemory(id: string): Promise<boolean> {
+  const dir = getMemoryDir();
+  if (dir) {
+    const filepath = join(dir, `memory-${id}.md`);
+    try {
+      if (existsSync(filepath)) {
+        markPendingWrite(`memory-${id}.md`);
+        unlinkSync(filepath);
+      }
+    } catch { /* ignore */ }
+  }
+  return vectorStore.deleteItem(id);
+}
+
+/** Get relevant memory context for a user message (for system prompt injection) */
+export async function getContextForMessage(message: string): Promise<string> {
+  try {
+    const memories = await searchMemories(message, 5);
+    if (memories.length === 0) return "";
+    return `\nUSER MEMORY (known facts about the user):\n${memories.map(m => `- ${m.content}`).join("\n")}\nUse this context to personalize your responses.`;
+  } catch {
+    return "";
+  }
+}
+
+/** Memory is always configured — no external API key needed */
+export function isMemoryConfigured(): boolean {
+  return true;
+}
+
+/** Returns "semantic" when embedding model is loaded, "local-keyword" otherwise */
+export function getBackendName(): string {
+  return isEmbeddingReady() ? "semantic" : "local-keyword";
+}
+
+// ─── Auto-Detection ─────────────────────────────────────────────────────────
+
+export interface DetectedFact {
+  fact: string;
+  category: string;
+}
+
+/**
+ * Extract memorable facts from a conversation using an LLM.
+ * Returns only genuinely new facts (deduplicated against existing memories).
+ */
+export async function detectMemorableFacts(
+  messages: Array<{ role: string; content: string }>,
+  llmCall: (systemPrompt: string, userPrompt: string) => Promise<string>,
+): Promise<DetectedFact[]> {
+  // Only process conversations with at least 1 user message
+  const userMessages = messages.filter(m => m.role === "user");
+  if (userMessages.length === 0) return [];
+
+  // Get existing memories to avoid duplicates
+  const existing = await listMemories(100);
+  const existingFacts = existing.map(m => m.content).join("\n- ");
+
+  const systemPrompt = `You extract personal facts about the user from conversations.
+Return ONLY a JSON array of objects with "fact" and "category" fields.
+Categories: preference, personal, technical, habit, schedule, contact
+Rules:
+- Only extract FACTS the user explicitly stated about themselves
+- Skip greetings, questions, commands, and transient requests
+- Skip facts that are already known (see EXISTING below)
+- Keep facts concise (one sentence max)
+- Return [] if no new facts found
+EXISTING MEMORIES:
+${existingFacts ? `- ${existingFacts}` : "(none)"}`;
+
+  const conversationText = messages
+    .filter(m => m.role === "user" || m.role === "assistant")
+    .slice(-10) // last 10 messages max
+    .map(m => `${m.role}: ${m.content}`)
+    .join("\n");
+
+  const userPrompt = `Extract new personal facts from this conversation:\n\n${conversationText}\n\nRespond with ONLY a JSON array, no markdown.`;
+
+  try {
+    const response = await llmCall(systemPrompt, userPrompt);
+    // Parse JSON from response (handle markdown code fences)
+    const cleaned = response.replace(/```json?\n?/g, "").replace(/```/g, "").trim();
+    const parsed = JSON.parse(cleaned);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((f: any) => f.fact && f.category && typeof f.fact === "string");
+  } catch {
+    return [];
+  }
+}
+
+// ─── Vault Sync ─────────────────────────────────────────────────────────────
+
+/** Initialize vault sync — call once at server startup */
+export async function initVaultSync(): Promise<void> {
+  const dir = getMemoryDir();
+  if (!dir) return;
+
+  // Rebuild Vectra index from vault files (for memories not yet indexed)
+  await vectorStore.rebuildFromVault(dir);
+
+  // Start file watcher for Memory/ subfolder only
+  const { startMemoryWatcher } = await import("./vault-watcher.js");
+  startMemoryWatcher(dir, async (id, content) => {
+    // External edit — re-index in Vectra
+    let embedding: number[];
+    try { embedding = await getEmbedding(content, "passage: "); } catch { embedding = new Array(384).fill(0); }
+    await vectorStore.deleteItem(id);
+    await vectorStore.addItem(id, content, embedding, {});
+  }, async (id) => {
+    // External delete — remove from Vectra
+    await vectorStore.deleteItem(id);
+  });
+}
+
+/** Restart vault sync (called when settings change) */
+export async function restartVaultSync(): Promise<void> {
+  const { stopMemoryWatcher } = await import("./vault-watcher.js");
+  stopMemoryWatcher();
+  await initVaultSync();
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function toMemory(item: vectorStore.VectorItem): Memory {
+  return {
+    id: item.id,
+    content: item.content,
+    metadata: item.metadata,
+    createdAt: item.metadata?.createdAt as string | undefined,
+  };
+}

package/server/obsidian-sync.ts

@@ -0,0 +1,184 @@
+// ─── Obsidian Vault Sync ─────────────────────────────────────────────────────
+// Mirrors HeyHank memories as Markdown files in an Obsidian vault.
+// Bi-directional: changes in either system sync to the other.
+
+import { watch, existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
+import { join, basename } from "node:path";
+import type { FSWatcher } from "node:fs";
+import { getSettings } from "./settings-manager.js";
+
+const SUBFOLDER = "HeyHank";
+
+// Track which writes we initiated to avoid re-importing our own changes
+const pendingWrites = new Set<string>();
+let watcher: FSWatcher | null = null;
+let currentVaultPath = "";
+
+// Callbacks for syncing changes back to memory service
+let onExternalEdit: ((id: string, content: string) => Promise<void>) | null = null;
+let onExternalDelete: ((id: string) => Promise<void>) | null = null;
+
+function getVaultDir(): string | null {
+  const vaultPath = getSettings().obsidianVaultPath;
+  if (!vaultPath) return null;
+  return join(vaultPath, SUBFOLDER);
+}
+
+function filenameForId(id: string): string {
+  return `memory-${id}.md`;
+}
+
+function idFromFilename(filename: string): string | null {
+  const match = filename.match(/^memory-(.+)\.md$/);
+  return match ? match[1] : null;
+}
+
+/** Build markdown content from a memory */
+function toMarkdown(content: string, metadata?: Record<string, unknown>): string {
+  const lines: string[] = ["---"];
+  if (metadata?.createdAt) lines.push(`created: ${metadata.createdAt}`);
+  if (metadata?.updatedAt) lines.push(`updated: ${metadata.updatedAt}`);
+  if (metadata?.category) lines.push(`category: ${metadata.category}`);
+  if (metadata?.source) lines.push(`source: ${metadata.source}`);
+  lines.push("synced: true");
+  lines.push("---");
+  lines.push("");
+  lines.push(content);
+  return lines.join("\n");
+}
+
+/** Parse markdown back to content (strip frontmatter) */
+function fromMarkdown(md: string): string {
+  const fmMatch = md.match(/^---\n[\s\S]*?\n---\n\n?([\s\S]*)$/);
+  return fmMatch ? fmMatch[1].trim() : md.trim();
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/** Write a memory to the vault as a .md file */
+export function syncToVault(id: string, content: string, metadata?: Record<string, unknown>): void {
+  const dir = getVaultDir();
+  if (!dir) return;
+
+  try {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const filepath = join(dir, filenameForId(id));
+    const md = toMarkdown(content, metadata);
+    pendingWrites.add(filenameForId(id));
+    writeFileSync(filepath, md, "utf-8");
+    // Clear pending after a short delay to allow watcher to see it
+    setTimeout(() => pendingWrites.delete(filenameForId(id)), 500);
+  } catch (err) {
+    console.warn("[obsidian-sync] Failed to write:", err instanceof Error ? err.message : err);
+  }
+}
+
+/** Remove a memory's .md file from the vault */
+export function removeFromVault(id: string): void {
+  const dir = getVaultDir();
+  if (!dir) return;
+
+  try {
+    const filepath = join(dir, filenameForId(id));
+    if (existsSync(filepath)) {
+      pendingWrites.add(filenameForId(id));
+      unlinkSync(filepath);
+      setTimeout(() => pendingWrites.delete(filenameForId(id)), 500);
+    }
+  } catch (err) {
+    console.warn("[obsidian-sync] Failed to delete:", err instanceof Error ? err.message : err);
+  }
+}
+
+/** Start watching the vault subfolder for external changes */
+export function startWatcher(
+  onEdit: (id: string, content: string) => Promise<void>,
+  onDelete: (id: string) => Promise<void>,
+): void {
+  stopWatcher();
+  onExternalEdit = onEdit;
+  onExternalDelete = onDelete;
+
+  const dir = getVaultDir();
+  if (!dir) return;
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  currentVaultPath = dir;
+
+  try {
+    watcher = watch(dir, (eventType, filename) => {
+      if (!filename || !filename.endsWith(".md")) return;
+      if (pendingWrites.has(filename)) return; // Our own write, skip
+
+      const id = idFromFilename(filename);
+      if (!id) return;
+
+      const filepath = join(dir, filename);
+
+      // Small debounce to let file writes complete
+      setTimeout(async () => {
+        try {
+          if (existsSync(filepath)) {
+            const md = readFileSync(filepath, "utf-8");
+            const content = fromMarkdown(md);
+            if (content && onExternalEdit) {
+              await onExternalEdit(id, content);
+              console.log(`[obsidian-sync] Imported edit for memory ${id}`);
+            }
+          } else {
+            // File was deleted externally
+            if (onExternalDelete) {
+              await onExternalDelete(id);
+              console.log(`[obsidian-sync] Imported delete for memory ${id}`);
+            }
+          }
+        } catch (err) {
+          console.warn("[obsidian-sync] Watcher error:", err instanceof Error ? err.message : err);
+        }
+      }, 300);
+    });
+    console.log(`[obsidian-sync] Watching ${dir}`);
+  } catch (err) {
+    console.warn("[obsidian-sync] Failed to start watcher:", err instanceof Error ? err.message : err);
+  }
+}
+
+/** Stop the file watcher */
+export function stopWatcher(): void {
+  if (watcher) {
+    watcher.close();
+    watcher = null;
+    if (currentVaultPath) {
+      console.log(`[obsidian-sync] Stopped watching ${currentVaultPath}`);
+    }
+    currentVaultPath = "";
+  }
+}
+
+/** Export all existing memories to the vault (initial sync) */
+export function bulkExportToVault(memories: Array<{ id: string; content: string; metadata?: Record<string, unknown> }>): void {
+  const dir = getVaultDir();
+  if (!dir) return;
+
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
+  let count = 0;
+  for (const mem of memories) {
+    try {
+      const filepath = join(dir, filenameForId(mem.id));
+      if (!existsSync(filepath)) {
+        const md = toMarkdown(mem.content, mem.metadata);
+        pendingWrites.add(filenameForId(mem.id));
+        writeFileSync(filepath, md, "utf-8");
+        setTimeout(() => pendingWrites.delete(filenameForId(mem.id)), 500);
+        count++;
+      }
+    } catch { /* skip individual failures */ }
+  }
+  if (count > 0) console.log(`[obsidian-sync] Exported ${count} memories to vault`);
+}
+
+/** Check if Obsidian sync is enabled */
+export function isEnabled(): boolean {
+  return !!getSettings().obsidianVaultPath;
+}

package/server/provider-manager.ts

@@ -1,10 +1,11 @@
 /**
  * Provider config storage — persists user's provider credentials to ~/.heyhank/providers.json
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { readFileSync, existsSync, mkdirSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { getProviderById } from "./provider-registry.js";
+import { atomicWriteFileSync } from "./fs-utils.js";
 
 export interface ProviderConfig {
   providerId: string;
@@ -35,7 +36,9 @@ function readAll(): ProviderConfig[] {
 
 function writeAll(configs: ProviderConfig[]): void {
   ensureDir();
-  writeFileSync(PROVIDERS_FILE, JSON.stringify(configs, null, 2), { mode: 0o600 });
+  atomicWriteFileSync(PROVIDERS_FILE, JSON.stringify(configs, null, 2));
+  // chmod separately — atomic rename preserves temp file's mode (0o644 by default)
+  try { chmodSync(PROVIDERS_FILE, 0o600); } catch { /* best-effort */ }
 }
 
 export function listProviderConfigs(): ProviderConfig[] {

package/server/provider-registry.ts

@@ -106,6 +106,18 @@ const PROVIDER_REGISTRY: ProviderDefinition[] = [
       { key: "OPENROUTER_API_KEY", label: "API Key", required: true, secret: true, placeholder: "sk-or-..." },
     ],
   },
+  {
+    id: "groq",
+    name: "Groq",
+    description: "Ultra-low-latency inference (Llama, Mixtral, Whisper). Ideal for real-time voice.",
+    cliProviderFlag: "groq",
+    category: "cloud",
+    defaultModel: "llama-3.3-70b-versatile",
+    docsUrl: "https://console.groq.com/docs",
+    envFields: [
+      { key: "GROQ_API_KEY", label: "API Key", required: true, secret: true, placeholder: "gsk_..." },
+    ],
+  },
   {
     id: "together",
     name: "Together AI",

package/server/reminder-scheduler.ts

@@ -1,11 +1,16 @@
 // ─── Reminder Scheduler ──────────────────────────────────────────────────────
 // Checks every 60 seconds for due reminders and sends push notifications.
 
-import { getDueReminders, fireReminder } from "./assistant-store.js";
+import { getDueReminders, fireReminder, listTodos } from "./assistant-store.js";
 import { sendNotification } from "./push-notifications.js";
 
 let intervalId: ReturnType<typeof setInterval> | null = null;
 
+// Dedup set for delegation notifications: key `${todoId}:${dueDate}`.
+// Prevents the same "delegation is due today/tomorrow" notification from
+// firing every minute. Cleared on process restart (at most one duplicate).
+const notifiedDelegations = new Set<string>();
+
 async function checkReminders(): Promise<void> {
   const due = getDueReminders();
   for (const reminder of due) {
@@ -20,6 +25,37 @@ async function checkReminders(): Promise<void> {
     }
     fireReminder(reminder.id);
   }
+
+  // Check for delegated todos with approaching due dates.
+  // Notify once per (todoId, dueDate) pair to avoid per-minute spam.
+  try {
+    const today = new Date().toISOString().slice(0, 10);
+    const tomorrow = new Date(Date.now() + 86_400_000).toISOString().slice(0, 10);
+    const todos = listTodos({ done: false });
+
+    // Garbage-collect keys whose dueDate is neither today nor tomorrow anymore
+    for (const key of notifiedDelegations) {
+      const dueDate = key.split(":")[1];
+      if (dueDate !== today && dueDate !== tomorrow) notifiedDelegations.delete(key);
+    }
+
+    for (const todo of todos) {
+      if (!todo.delegatedTo || !todo.dueDate) continue;
+      if (todo.dueDate !== today && todo.dueDate !== tomorrow) continue;
+      const key = `${todo.id}:${todo.dueDate}`;
+      if (notifiedDelegations.has(key)) continue;
+
+      const label = todo.dueDate === today ? "heute" : "morgen";
+      await sendNotification(
+        "Delegation fällig",
+        `${todo.delegatedTo}: "${todo.text}" — fällig ${label}`,
+        { tag: `delegation-${todo.id}-${todo.dueDate}`, icon: "/icon-192.png" },
+      );
+      notifiedDelegations.add(key);
+    }
+  } catch (err) {
+    console.error("[reminder-scheduler] Failed to check delegation due dates:", err);
+  }
 }
 
 export function startReminderScheduler(): void {

package/server/routes/agent-routes.ts

@@ -164,8 +164,9 @@ export function registerAgentRoutes(
     if (!agent) return c.json({ error: "Agent not found" }, 404);
     const body = await c.req.json().catch(() => ({}));
     const input = typeof body.input === "string" ? body.input : undefined;
+    const cwdOverride = typeof body.cwd === "string" ? body.cwd : undefined;
     try {
-      const sessionInfo = await agentExecutor?.executeAgent(id, input, { force: true, triggerType: "manual" });
+      const sessionInfo = await agentExecutor?.executeAgent(id, input, { force: true, triggerType: "manual", cwdOverride });
       return c.json({
         ok: true,
         message: "Agent triggered",