heyhank 0.1.0 → 0.2.0

package/server/assistant-store.ts

@@ -1,10 +1,18 @@
 // ─── Assistant Store ──────────────────────────────────────────────────────────
 // Persistent storage for personal assistant features: todos, notes, reminders.
 // All data stored as JSON in ~/.heyhank/assistant/
+// When an Obsidian vault is configured, delegates to vault-store.ts instead.
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { readFileSync, mkdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { HEYHANK_HOME } from "./paths.js";
+import { atomicWriteFileSync } from "./fs-utils.js";
+import { getSettings } from "./settings-manager.js";
+import * as vaultStore from "./vault-store.js";
+
+function useVault(): boolean {
+  return !!getSettings().obsidianVaultPath;
+}
 
 const ASSISTANT_DIR = join(HEYHANK_HOME, "assistant");
 
@@ -27,7 +35,7 @@ function readJson<T>(filename: string, fallback: T): T {
 
 function writeJson(filename: string, data: unknown): void {
   ensureDir();
-  writeFileSync(join(ASSISTANT_DIR, filename), JSON.stringify(data, null, 2), "utf-8");
+  atomicWriteFileSync(join(ASSISTANT_DIR, filename), JSON.stringify(data, null, 2));
 }
 
 // ─── Todos ────────────────────────────────────────────────────────────────────
@@ -40,6 +48,10 @@ export interface Todo {
   createdAt: string;
   doneAt?: string;
   category?: string;
+  delegatedTo?: string;
+  dueDate?: string;
+  followUpDate?: string;
+  project?: string;
 }
 
 function genId(): string {
@@ -47,6 +59,7 @@ function genId(): string {
 }
 
 export function listTodos(filter?: { done?: boolean; priority?: string; category?: string }): Todo[] {
+  if (useVault()) return vaultStore.listTodos(filter);
   const todos = readJson<Todo[]>("todos.json", []);
   return todos.filter((t) => {
     if (filter?.done !== undefined && t.done !== filter.done) return false;
@@ -56,7 +69,8 @@ export function listTodos(filter?: { done?: boolean; priority?: string; category
   });
 }
 
-export function addTodo(text: string, priority: string = "medium", category?: string): Todo {
+export function addTodo(text: string, priority: string = "medium", category?: string, extra?: { delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }): Todo {
+  if (useVault()) return vaultStore.addTodo(text, priority, category, extra);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo: Todo = {
     id: genId(),
@@ -65,6 +79,7 @@ export function addTodo(text: string, priority: string = "medium", category?: st
     done: false,
     createdAt: new Date().toISOString(),
     category,
+    ...extra,
   };
   todos.push(todo);
   writeJson("todos.json", todos);
@@ -72,6 +87,7 @@ export function addTodo(text: string, priority: string = "medium", category?: st
 }
 
 export function completeTodo(id: string): Todo | null {
+  if (useVault()) return vaultStore.completeTodo(id);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo = todos.find((t) => t.id === id);
   if (!todo) return null;
@@ -82,6 +98,7 @@ export function completeTodo(id: string): Todo | null {
 }
 
 export function deleteTodo(id: string): boolean {
+  if (useVault()) return vaultStore.deleteTodo(id);
   const todos = readJson<Todo[]>("todos.json", []);
   const idx = todos.findIndex((t) => t.id === id);
   if (idx === -1) return false;
@@ -90,7 +107,8 @@ export function deleteTodo(id: string): boolean {
   return true;
 }
 
-export function updateTodo(id: string, patch: { text?: string; priority?: string; category?: string }): Todo | null {
+export function updateTodo(id: string, patch: { text?: string; priority?: string; category?: string; delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }): Todo | null {
+  if (useVault()) return vaultStore.updateTodo(id, patch);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo = todos.find((t) => t.id === id);
   if (!todo) return null;
@@ -99,10 +117,24 @@ export function updateTodo(id: string, patch: { text?: string; priority?: string
     todo.priority = patch.priority as Todo["priority"];
   }
   if (patch.category !== undefined) todo.category = patch.category;
+  if (patch.delegatedTo !== undefined) todo.delegatedTo = patch.delegatedTo;
+  if (patch.dueDate !== undefined) todo.dueDate = patch.dueDate;
+  if (patch.followUpDate !== undefined) todo.followUpDate = patch.followUpDate;
+  if (patch.project !== undefined) todo.project = patch.project;
   writeJson("todos.json", todos);
   return todo;
 }
 
+export function listDelegations(person?: string): Todo[] {
+  const todos = listTodos();
+  const delegated = todos.filter((t) => t.delegatedTo && (!person || t.delegatedTo.toLowerCase() === person.toLowerCase()));
+  return delegated.sort((a, b) => {
+    if (!a.dueDate) return 1;
+    if (!b.dueDate) return -1;
+    return a.dueDate.localeCompare(b.dueDate);
+  });
+}
+
 // ─── Notes ────────────────────────────────────────────────────────────────────
 
 export interface Note {
@@ -115,6 +147,7 @@ export interface Note {
 }
 
 export function listNotes(search?: string): Note[] {
+  if (useVault()) return vaultStore.listNotes(search);
   const notes = readJson<Note[]>("notes.json", []);
   if (!search) return notes;
   const q = search.toLowerCase();
@@ -126,6 +159,7 @@ export function listNotes(search?: string): Note[] {
 }
 
 export function addNote(title: string, content: string, tags: string[] = []): Note {
+  if (useVault()) return vaultStore.addNote(title, content, tags);
   const notes = readJson<Note[]>("notes.json", []);
   const note: Note = {
     id: genId(),
@@ -141,11 +175,13 @@ export function addNote(title: string, content: string, tags: string[] = []): No
 }
 
 export function getNote(id: string): Note | null {
+  if (useVault()) return vaultStore.getNote(id);
   const notes = readJson<Note[]>("notes.json", []);
   return notes.find((n) => n.id === id) || null;
 }
 
 export function updateNote(id: string, patch: { title?: string; content?: string; tags?: string[] }): Note | null {
+  if (useVault()) return vaultStore.updateNote(id, patch);
   const notes = readJson<Note[]>("notes.json", []);
   const note = notes.find((n) => n.id === id);
   if (!note) return null;
@@ -158,6 +194,7 @@ export function updateNote(id: string, patch: { title?: string; content?: string
 }
 
 export function deleteNote(id: string): boolean {
+  if (useVault()) return vaultStore.deleteNote(id);
   const notes = readJson<Note[]>("notes.json", []);
   const idx = notes.findIndex((n) => n.id === id);
   if (idx === -1) return false;
@@ -174,14 +211,17 @@ export interface Reminder {
   triggerAt: string; // ISO datetime
   fired: boolean;
   createdAt: string;
+  calendarEventUid?: string;
 }
 
 export function listReminders(includeFired = false): Reminder[] {
+  if (useVault()) return vaultStore.listReminders(includeFired);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   return includeFired ? reminders : reminders.filter((r) => !r.fired);
 }
 
-export function addReminder(text: string, triggerAt: string): Reminder {
+export function addReminder(text: string, triggerAt: string, calendarEventUid?: string): Reminder {
+  if (useVault()) return vaultStore.addReminder(text, triggerAt, calendarEventUid);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const reminder: Reminder = {
     id: genId(),
@@ -189,13 +229,27 @@ export function addReminder(text: string, triggerAt: string): Reminder {
     triggerAt,
     fired: false,
     createdAt: new Date().toISOString(),
+    ...(calendarEventUid ? { calendarEventUid } : {}),
   };
   reminders.push(reminder);
   writeJson("reminders.json", reminders);
   return reminder;
 }
 
+export function updateReminder(id: string, updates: { text?: string; triggerAt?: string; calendarEventUid?: string }): Reminder | null {
+  if (useVault()) return vaultStore.updateReminder(id, updates);
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  const r = reminders.find((rem) => rem.id === id);
+  if (!r) return null;
+  if (updates.text !== undefined) r.text = updates.text;
+  if (updates.triggerAt !== undefined) r.triggerAt = updates.triggerAt;
+  if (updates.calendarEventUid !== undefined) r.calendarEventUid = updates.calendarEventUid;
+  writeJson("reminders.json", reminders);
+  return r;
+}
+
 export function fireReminder(id: string): Reminder | null {
+  if (useVault()) return vaultStore.fireReminder(id);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const r = reminders.find((rem) => rem.id === id);
   if (!r) return null;
@@ -205,6 +259,7 @@ export function fireReminder(id: string): Reminder | null {
 }
 
 export function deleteReminder(id: string): boolean {
+  if (useVault()) return vaultStore.deleteReminder(id);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const idx = reminders.findIndex((r) => r.id === id);
   if (idx === -1) return false;
@@ -215,12 +270,179 @@ export function deleteReminder(id: string): boolean {
 
 /** Get all reminders that should have fired by now */
 export function getDueReminders(): Reminder[] {
+  if (useVault()) return vaultStore.getDueReminders();
   const now = new Date().toISOString();
   const reminders = readJson<Reminder[]>("reminders.json", []);
   return reminders.filter((r) => !r.fired && r.triggerAt <= now);
 }
 
-// ─── Gemini Conversations ──────��─────────────────────────────────────────────
+// ─── Contacts/CRM ────────────────────────────────────────────────────────────
+
+export interface ContactInteraction {
+  date: string;
+  type: "call" | "email" | "meeting" | "note";
+  summary: string;
+}
+
+export interface Contact {
+  id: string;
+  name: string;
+  company?: string;
+  email?: string;
+  phone?: string;
+  notes?: string;
+  tags: string[];
+  lastContactDate?: string;
+  interactions: ContactInteraction[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function listContacts(search?: string): Contact[] {
+  if (useVault()) return vaultStore.listContacts(search);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  if (!search) return contacts;
+  const q = search.toLowerCase();
+  return contacts.filter((c) =>
+    c.name.toLowerCase().includes(q) ||
+    (c.company && c.company.toLowerCase().includes(q)) ||
+    (c.email && c.email.toLowerCase().includes(q)) ||
+    (c.phone && c.phone.includes(q)) ||
+    c.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+
+export function addContact(name: string, company?: string, email?: string, phone?: string, notes?: string, tags: string[] = []): Contact {
+  if (useVault()) return vaultStore.addContact(name, company, email, phone, notes, tags);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact: Contact = {
+    id: genId(),
+    name,
+    company,
+    email,
+    phone,
+    notes,
+    tags,
+    interactions: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  contacts.push(contact);
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+export function getContact(id: string): Contact | null {
+  if (useVault()) return vaultStore.getContact(id);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  return contacts.find((c) => c.id === id) || null;
+}
+
+export function updateContact(id: string, patch: { name?: string; company?: string; email?: string; phone?: string; notes?: string; tags?: string[] }): Contact | null {
+  if (useVault()) return vaultStore.updateContact(id, patch);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact = contacts.find((c) => c.id === id);
+  if (!contact) return null;
+  if (patch.name) contact.name = patch.name;
+  if (patch.company !== undefined) contact.company = patch.company;
+  if (patch.email !== undefined) contact.email = patch.email;
+  if (patch.phone !== undefined) contact.phone = patch.phone;
+  if (patch.notes !== undefined) contact.notes = patch.notes;
+  if (patch.tags) contact.tags = patch.tags;
+  contact.updatedAt = new Date().toISOString();
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+export function deleteContact(id: string): boolean {
+  if (useVault()) return vaultStore.deleteContact(id);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const idx = contacts.findIndex((c) => c.id === id);
+  if (idx === -1) return false;
+  contacts.splice(idx, 1);
+  writeJson("contacts.json", contacts);
+  return true;
+}
+
+export function logInteraction(contactId: string, interaction: Omit<ContactInteraction, "date">): Contact | null {
+  if (useVault()) return vaultStore.logInteraction(contactId, interaction);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact = contacts.find((c) => c.id === contactId);
+  if (!contact) return null;
+  const entry: ContactInteraction = {
+    date: new Date().toISOString(),
+    type: interaction.type,
+    summary: interaction.summary,
+  };
+  contact.interactions.push(entry);
+  contact.lastContactDate = entry.date;
+  contact.updatedAt = new Date().toISOString();
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+// ─── Decisions ───────────────────────────────────────────────────────────────
+
+export interface Decision {
+  id: string;
+  title: string;
+  context: string;
+  decision: string;
+  alternatives: string[];
+  reasoning: string;
+  tags: string[];
+  createdAt: string;
+}
+
+export function listDecisions(search?: string): Decision[] {
+  if (useVault()) return vaultStore.listDecisions(search);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  if (!search) return decisions;
+  const q = search.toLowerCase();
+  return decisions.filter((d) =>
+    d.title.toLowerCase().includes(q) ||
+    d.context.toLowerCase().includes(q) ||
+    d.decision.toLowerCase().includes(q) ||
+    d.reasoning.toLowerCase().includes(q) ||
+    d.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+
+export function addDecision(title: string, context: string, decision: string, alternatives: string[] = [], reasoning: string = "", tags: string[] = []): Decision {
+  if (useVault()) return vaultStore.addDecision(title, context, decision, alternatives, reasoning, tags);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  const entry: Decision = {
+    id: genId(),
+    title,
+    context,
+    decision,
+    alternatives,
+    reasoning,
+    tags,
+    createdAt: new Date().toISOString(),
+  };
+  decisions.push(entry);
+  writeJson("decisions.json", decisions);
+  return entry;
+}
+
+export function getDecision(id: string): Decision | null {
+  if (useVault()) return vaultStore.getDecision(id);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  return decisions.find((d) => d.id === id) || null;
+}
+
+export function deleteDecision(id: string): boolean {
+  if (useVault()) return vaultStore.deleteDecision(id);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  const idx = decisions.findIndex((d) => d.id === id);
+  if (idx === -1) return false;
+  decisions.splice(idx, 1);
+  writeJson("decisions.json", decisions);
+  return true;
+}
+
+// ─── Gemini Conversations ────────────────────────────────────────────────────
 
 export interface GeminiConversation {
   id: string;
@@ -231,6 +453,7 @@ export interface GeminiConversation {
 }
 
 export function listGeminiConversations(): GeminiConversation[] {
+  if (useVault()) return vaultStore.listGeminiConversations();
   return readJson<GeminiConversation[]>("gemini-conversations.json", [])
     .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
@@ -239,6 +462,7 @@ export function saveGeminiConversation(
   messages: Array<{ role: "user" | "gemini" | "system"; text: string; ts: number }>,
   duration?: number,
 ): GeminiConversation {
+  if (useVault()) return vaultStore.saveGeminiConversation(messages, duration);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   // Generate title from first user message
   const firstUser = messages.find((m) => m.role === "user");
@@ -258,11 +482,13 @@ export function saveGeminiConversation(
 }
 
 export function getGeminiConversation(id: string): GeminiConversation | null {
+  if (useVault()) return vaultStore.getGeminiConversation(id);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   return convos.find((c) => c.id === id) || null;
 }
 
 export function deleteGeminiConversation(id: string): boolean {
+  if (useVault()) return vaultStore.deleteGeminiConversation(id);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   const idx = convos.findIndex((c) => c.id === id);
   if (idx === -1) return false;

package/server/auth-manager.ts

@@ -144,6 +144,15 @@ export function regenerateToken(): string {
   return token;
 }
 
+/**
+ * Check whether a token file already exists on disk (i.e. not a fresh first-run).
+ * Used to decide whether to print the token to console on startup.
+ */
+export function isTokenPersisted(): boolean {
+  if (process.env.HEYHANK_AUTH_TOKEN || process.env.COMPANION_AUTH_TOKEN) return true;
+  return existsSync(AUTH_FILE);
+}
+
 /** Reset cached state — for testing only */
 export function _resetForTest(): void {
   cachedToken = null;

package/server/cache-headers.ts

@@ -31,7 +31,7 @@ export function cacheControlMiddleware(): MiddlewareHandler {
 
     // index.html (served for / and /index.html): must be fresh
     if (path === "/" || path === "/index.html") {
-      c.header("Cache-Control", "no-cache");
+      c.header("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
       return;
     }
 

package/server/calendar-service.ts

@@ -291,6 +291,7 @@ export async function createEvent(
     end: string;         // ISO datetime or YYYY-MM-DD for all-day
     allDay?: boolean;
     calendarUrl?: string;
+    alarm?: number;      // minutes before event to trigger alarm (0 = at event time)
   },
 ): Promise<{ success: boolean; uid: string }> {
   const client = await createClient(account);
@@ -330,6 +331,15 @@ export async function createEvent(
   if (event.description) lines.push(`DESCRIPTION:${escapeICS(event.description)}`);
   if (event.location) lines.push(`LOCATION:${escapeICS(event.location)}`);
   lines.push(`DTSTAMP:${new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "")}`);
+  if (event.alarm !== undefined) {
+    lines.push(
+      "BEGIN:VALARM",
+      "ACTION:DISPLAY",
+      `DESCRIPTION:${escapeICS(event.summary)}`,
+      `TRIGGER:${event.alarm === 0 ? "PT0S" : `-PT${event.alarm}M`}`,
+      "END:VALARM",
+    );
+  }
   lines.push("END:VEVENT", "END:VCALENDAR");
 
   const icsData = lines.join("\r\n");

package/server/ceo/document-store.ts

@@ -0,0 +1,129 @@
+import { join } from "path";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, statSync } from "fs";
+import { randomUUID } from "crypto";
+import { atomicWriteFileSync } from "../fs-utils.js";
+
+export interface Document {
+  id: string;
+  title: string;
+  fileType: string; // pdf, txt, md, docx, etc.
+  size: number; // bytes
+  path: string; // relative storage path
+  tags: string[];
+  folder: string;
+  createdAt: string;
+  updatedAt: string;
+  summary?: string; // AI-generated summary
+}
+
+export interface DocumentMetadata {
+  documents: Document[];
+}
+
+const DATA_DIR = join(process.env.HEYHANK_HOME || join(process.env.HOME || "/root", ".heyhank"), "documents");
+const META_FILE = join(DATA_DIR, "_metadata.json");
+
+function ensureDir() {
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function loadMeta(): DocumentMetadata {
+  ensureDir();
+  if (!existsSync(META_FILE)) return { documents: [] };
+  try { return JSON.parse(readFileSync(META_FILE, "utf-8")); }
+  catch { return { documents: [] }; }
+}
+
+function saveMeta(meta: DocumentMetadata) {
+  ensureDir();
+  atomicWriteFileSync(META_FILE, JSON.stringify(meta, null, 2));
+}
+
+export function listDocuments(folder?: string, tag?: string): Document[] {
+  const meta = loadMeta();
+  let docs = meta.documents;
+  if (folder) docs = docs.filter(d => d.folder === folder);
+  if (tag) docs = docs.filter(d => d.tags.includes(tag));
+  return docs.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+export function addDocument(title: string, content: string, fileType: string, folder?: string, tags?: string[], summary?: string): Document {
+  const meta = loadMeta();
+  const id = randomUUID();
+  const filename = `${id}.${fileType}`;
+  const filePath = join(DATA_DIR, filename);
+
+  writeFileSync(filePath, content);
+  const stat = statSync(filePath);
+
+  const doc: Document = {
+    id,
+    title,
+    fileType,
+    size: stat.size,
+    path: filename,
+    tags: tags || [],
+    folder: folder || "General",
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    summary
+  };
+
+  meta.documents.push(doc);
+  saveMeta(meta);
+  return doc;
+}
+
+export function getDocument(id: string): { meta: Document; content: string } | null {
+  const meta = loadMeta();
+  const doc = meta.documents.find(d => d.id === id);
+  if (!doc) return null;
+  const filePath = join(DATA_DIR, doc.path);
+  if (!existsSync(filePath)) return null;
+  const content = readFileSync(filePath, "utf-8");
+  return { meta: doc, content };
+}
+
+export function updateDocument(id: string, patch: Partial<Pick<Document, "title" | "tags" | "folder" | "summary">>): Document | null {
+  const meta = loadMeta();
+  const idx = meta.documents.findIndex(d => d.id === id);
+  if (idx === -1) return null;
+
+  if (patch.title !== undefined) meta.documents[idx].title = patch.title;
+  if (patch.tags !== undefined) meta.documents[idx].tags = patch.tags;
+  if (patch.folder !== undefined) meta.documents[idx].folder = patch.folder;
+  if (patch.summary !== undefined) meta.documents[idx].summary = patch.summary;
+  meta.documents[idx].updatedAt = new Date().toISOString();
+
+  saveMeta(meta);
+  return meta.documents[idx];
+}
+
+export function deleteDocument(id: string): boolean {
+  const meta = loadMeta();
+  const idx = meta.documents.findIndex(d => d.id === id);
+  if (idx === -1) return false;
+
+  const filePath = join(DATA_DIR, meta.documents[idx].path);
+  if (existsSync(filePath)) unlinkSync(filePath);
+
+  meta.documents.splice(idx, 1);
+  saveMeta(meta);
+  return true;
+}
+
+export function searchDocuments(query: string): Document[] {
+  const meta = loadMeta();
+  const q = query.toLowerCase();
+  return meta.documents.filter(d =>
+    d.title.toLowerCase().includes(q) ||
+    d.tags.some(t => t.toLowerCase().includes(q)) ||
+    d.folder.toLowerCase().includes(q) ||
+    (d.summary && d.summary.toLowerCase().includes(q))
+  );
+}
+
+export function listFolders(): string[] {
+  const meta = loadMeta();
+  return [...new Set(meta.documents.map(d => d.folder))].sort();
+}