heyhank 0.1.0 → 0.2.0

package/server/ceo/memory-import.ts

@@ -0,0 +1,277 @@
+import { randomUUID } from "crypto";
+
+// ─── Platform Detection ─────────────────────────────────────────────────────
+
+export type ImportPlatform = "chatgpt" | "claude" | "gemini" | "unknown";
+
+export interface ImportResult {
+  platform: ImportPlatform;
+  memories: string[];
+  conversations: number;
+  messagesProcessed: number;
+  skipped: number;
+  errors: string[];
+}
+
+/**
+ * Auto-detect which platform a JSON export belongs to.
+ */
+export function detectPlatform(data: unknown): ImportPlatform {
+  if (!data) return "unknown";
+
+  // ChatGPT: array of objects with "mapping" field (tree structure)
+  if (Array.isArray(data) && data.length > 0 && data[0].mapping) return "chatgpt";
+
+  // ChatGPT memories: array with "id" starting with "mem_"
+  if (Array.isArray(data) && data.length > 0 && typeof data[0].id === "string" && data[0].id.startsWith("mem_")) return "chatgpt";
+
+  // Claude: array of objects with "chat_messages" field
+  if (Array.isArray(data) && data.length > 0 && data[0].chat_messages) return "claude";
+
+  // Claude: object with uuid and chat_messages
+  if (typeof data === "object" && !Array.isArray(data) && (data as any).chat_messages) return "claude";
+
+  // Gemini: object with "messages" array where role is "model"
+  if (typeof data === "object" && !Array.isArray(data) && Array.isArray((data as any).messages)) {
+    const msgs = (data as any).messages;
+    if (msgs.some((m: any) => m.role === "model")) return "gemini";
+  }
+
+  // Gemini: array of conversation objects with messages containing role "model"
+  if (Array.isArray(data) && data.length > 0 && Array.isArray(data[0].messages)) {
+    if (data[0].messages.some((m: any) => m.role === "model")) return "gemini";
+  }
+
+  return "unknown";
+}
+
+// ─── ChatGPT Import ─────────────────────────────────────────────────────────
+
+/**
+ * Import ChatGPT memories (memories.json) — direct facts.
+ */
+export function parseChatGPTMemories(data: any[]): string[] {
+  return data
+    .filter(item => item.content && typeof item.content === "string")
+    .map(item => item.content.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Extract user messages from ChatGPT conversations.json tree structure.
+ * Walk from current_node back through parent pointers to reconstruct linear thread.
+ */
+export function parseChatGPTConversations(data: any[]): { conversations: number; messages: Array<{ role: string; content: string; conversationTitle?: string }> } {
+  const allMessages: Array<{ role: string; content: string; conversationTitle?: string }> = [];
+  let conversations = 0;
+
+  for (const conv of data) {
+    if (!conv.mapping) continue;
+    conversations++;
+    const title = conv.title || "Untitled";
+
+    // Reconstruct linear thread from tree
+    let nodeId = conv.current_node;
+    const chain: any[] = [];
+    while (nodeId && conv.mapping[nodeId]) {
+      const node = conv.mapping[nodeId];
+      if (node.message?.content?.parts) {
+        const text = node.message.content.parts
+          .filter((p: any) => typeof p === "string")
+          .join("\n")
+          .trim();
+        if (text) {
+          chain.push({
+            role: node.message.author?.role === "user" ? "user" : "assistant",
+            content: text,
+            conversationTitle: title,
+          });
+        }
+      }
+      nodeId = node.parent;
+    }
+    chain.reverse();
+    allMessages.push(...chain);
+  }
+
+  return { conversations, messages: allMessages };
+}
+
+// ─── Claude Import ──────────────────────────────────────────────────────────
+
+/**
+ * Extract messages from Claude conversations.json export.
+ */
+export function parseClaudeConversations(data: any[]): { conversations: number; messages: Array<{ role: string; content: string; conversationTitle?: string }> } {
+  const allMessages: Array<{ role: string; content: string; conversationTitle?: string }> = [];
+  let conversations = 0;
+
+  const convList = Array.isArray(data) ? data : [data];
+
+  for (const conv of convList) {
+    if (!conv.chat_messages) continue;
+    conversations++;
+    const title = conv.name || "Untitled";
+
+    for (const msg of conv.chat_messages) {
+      const text = typeof msg.text === "string" ? msg.text.trim() : "";
+      if (!text) continue;
+      allMessages.push({
+        role: msg.sender === "human" ? "user" : "assistant",
+        content: text,
+        conversationTitle: title,
+      });
+    }
+  }
+
+  return { conversations, messages: allMessages };
+}
+
+// ─── Gemini Import ──────────────────────────────────────────────────────────
+
+/**
+ * Extract messages from Gemini export (Google Takeout format).
+ */
+export function parseGeminiConversations(data: any): { conversations: number; messages: Array<{ role: string; content: string; conversationTitle?: string }> } {
+  const allMessages: Array<{ role: string; content: string; conversationTitle?: string }> = [];
+  let conversations = 0;
+
+  const convList = Array.isArray(data) ? data : [data];
+
+  for (const conv of convList) {
+    if (!Array.isArray(conv.messages)) continue;
+    conversations++;
+    const title = conv.title || "Untitled";
+
+    for (const msg of conv.messages) {
+      const text = typeof msg.content === "string" ? msg.content.trim() : "";
+      if (!text) continue;
+      allMessages.push({
+        role: msg.role === "user" ? "user" : "assistant",
+        content: text,
+        conversationTitle: title,
+      });
+    }
+  }
+
+  return { conversations, messages: allMessages };
+}
+
+// ─── Fact Extraction ────────────────────────────────────────────────────────
+
+/**
+ * Extract memorable facts from user messages without LLM.
+ * Simple heuristic: look for "I am", "I work", "I prefer", "My name", etc.
+ */
+export function extractFactsHeuristic(messages: Array<{ role: string; content: string }>): string[] {
+  const userMessages = messages.filter(m => m.role === "user");
+  const facts: Set<string> = new Set();
+
+  const patterns = [
+    /\b(?:I am|I'm|Ich bin)\s+(.{5,80})/gi,
+    /\b(?:my name is|mein name ist)\s+(.{2,40})/gi,
+    /\b(?:I work|I'm working|Ich arbeite)\s+(.{5,80})/gi,
+    /\b(?:I prefer|I like|Ich bevorzuge|Ich mag)\s+(.{5,80})/gi,
+    /\b(?:I use|I'm using|Ich verwende|Ich nutze)\s+(.{5,80})/gi,
+    /\b(?:I live|I'm from|Ich wohne|Ich komme aus)\s+(.{3,60})/gi,
+    /\b(?:my company|my business|meine firma|mein unternehmen)\s+(.{3,60})/gi,
+    /\b(?:I always|Ich immer)\s+(.{5,80})/gi,
+    /\b(?:I need|I want|Ich brauche|Ich will)\s+(.{5,80})/gi,
+    /\b(?:my timezone|my language|my email)\s+(.{3,60})/gi,
+    /\b(?:remember that|merke dir|vergiss nicht)\s+(.{5,120})/gi,
+  ];
+
+  for (const msg of userMessages) {
+    const content = msg.content;
+    // Skip very long messages (likely code or documents)
+    if (content.length > 500) continue;
+
+    for (const pattern of patterns) {
+      pattern.lastIndex = 0;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        // Clean up the match — take first sentence
+        let fact = match[0].trim();
+        const dotIdx = fact.indexOf(".");
+        if (dotIdx > 10) fact = fact.slice(0, dotIdx + 1);
+        // Remove trailing punctuation patterns
+        fact = fact.replace(/[,;:]\s*$/, "").trim();
+        if (fact.length >= 10 && fact.length <= 200) {
+          facts.add(fact);
+        }
+      }
+    }
+  }
+
+  return [...facts];
+}
+
+// ─── Main Import Function ───────────────────────────────────────────────────
+
+export interface ImportOptions {
+  mode: "memories" | "conversations" | "both";
+  extractFacts: boolean; // use heuristic extraction from conversations
+  maxConversations?: number; // limit for large exports
+}
+
+export function processImport(data: unknown, platform: ImportPlatform, options: ImportOptions): ImportResult {
+  const result: ImportResult = {
+    platform,
+    memories: [],
+    conversations: 0,
+    messagesProcessed: 0,
+    skipped: 0,
+    errors: [],
+  };
+
+  try {
+    // Direct memories import (ChatGPT memories.json)
+    if (Array.isArray(data) && data.length > 0 && data[0].id?.startsWith?.("mem_")) {
+      const mems = parseChatGPTMemories(data);
+      result.memories.push(...mems);
+      result.platform = "chatgpt";
+      return result;
+    }
+
+    // Conversation-based import
+    let parsed: { conversations: number; messages: Array<{ role: string; content: string }> };
+
+    switch (platform) {
+      case "chatgpt":
+        parsed = parseChatGPTConversations(data as any[]);
+        break;
+      case "claude":
+        parsed = parseClaudeConversations(data as any[]);
+        break;
+      case "gemini":
+        parsed = parseGeminiConversations(data);
+        break;
+      default:
+        result.errors.push("Unknown platform format. Please select the correct platform.");
+        return result;
+    }
+
+    result.conversations = parsed.conversations;
+    result.messagesProcessed = parsed.messages.length;
+
+    // Limit conversations if needed
+    const maxMsgs = (options.maxConversations || 1000) * 20; // ~20 msgs per conversation
+    const msgs = parsed.messages.slice(0, maxMsgs);
+    if (parsed.messages.length > maxMsgs) {
+      result.skipped = parsed.messages.length - maxMsgs;
+    }
+
+    // Extract facts from conversations
+    if (options.extractFacts || options.mode === "both") {
+      const facts = extractFactsHeuristic(msgs);
+      result.memories.push(...facts);
+    }
+  } catch (err) {
+    result.errors.push(err instanceof Error ? err.message : "Import failed");
+  }
+
+  // Deduplicate memories
+  result.memories = [...new Set(result.memories)];
+
+  return result;
+}

package/server/ceo/news-store.ts

@@ -0,0 +1,208 @@
+import { join } from "path";
+import { readFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import { atomicWriteFileSync } from "../fs-utils.js";
+
+export interface NewsSource {
+  id: string;
+  name: string;
+  type: "rss" | "website" | "keyword";
+  url?: string; // for rss/website
+  keywords?: string[]; // for keyword monitoring
+  category: string;
+  enabled: boolean;
+  checkInterval: number; // minutes
+  lastChecked?: string;
+  createdAt: string;
+}
+
+export interface NewsItem {
+  id: string;
+  sourceId: string;
+  sourceName: string;
+  title: string;
+  summary: string;
+  url?: string;
+  category: string;
+  publishedAt: string;
+  fetchedAt: string;
+  read: boolean;
+  saved: boolean;
+  relevance?: number; // 0-100, AI-scored
+}
+
+const DATA_DIR = join(process.env.HEYHANK_HOME || join(process.env.HOME || "/root", ".heyhank"), "news");
+const SOURCES_FILE = join(DATA_DIR, "sources.json");
+const ITEMS_FILE = join(DATA_DIR, "items.json");
+
+function ensureDir() {
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function loadSources(): NewsSource[] {
+  ensureDir();
+  if (!existsSync(SOURCES_FILE)) return [];
+  try { return JSON.parse(readFileSync(SOURCES_FILE, "utf-8")); }
+  catch { return []; }
+}
+
+function saveSources(sources: NewsSource[]) {
+  ensureDir();
+  atomicWriteFileSync(SOURCES_FILE, JSON.stringify(sources, null, 2));
+}
+
+function loadItems(): NewsItem[] {
+  ensureDir();
+  if (!existsSync(ITEMS_FILE)) return [];
+  try { return JSON.parse(readFileSync(ITEMS_FILE, "utf-8")); }
+  catch { return []; }
+}
+
+function saveItems(items: NewsItem[]) {
+  ensureDir();
+  // Keep max 500 items
+  const trimmed = items.slice(0, 500);
+  atomicWriteFileSync(ITEMS_FILE, JSON.stringify(trimmed, null, 2));
+}
+
+// Sources
+export function addSource(name: string, type: NewsSource["type"], category: string, url?: string, keywords?: string[], checkInterval?: number): NewsSource {
+  const sources = loadSources();
+  const source: NewsSource = {
+    id: randomUUID(),
+    name,
+    type,
+    url,
+    keywords,
+    category,
+    enabled: true,
+    checkInterval: checkInterval || 60,
+    createdAt: new Date().toISOString()
+  };
+  sources.push(source);
+  saveSources(sources);
+  return source;
+}
+
+export function listSources(): NewsSource[] {
+  return loadSources();
+}
+
+export function updateSource(id: string, patch: Partial<Pick<NewsSource, "name" | "enabled" | "checkInterval" | "keywords" | "url" | "category">>): NewsSource | null {
+  const sources = loadSources();
+  const idx = sources.findIndex(s => s.id === id);
+  if (idx === -1) return null;
+  Object.assign(sources[idx], patch);
+  saveSources(sources);
+  return sources[idx];
+}
+
+export function deleteSource(id: string): boolean {
+  const sources = loadSources();
+  const idx = sources.findIndex(s => s.id === id);
+  if (idx === -1) return false;
+  sources.splice(idx, 1);
+  saveSources(sources);
+  // Also remove items from this source
+  const items = loadItems().filter(i => i.sourceId !== id);
+  saveItems(items);
+  return true;
+}
+
+export function markSourceChecked(id: string): void {
+  const sources = loadSources();
+  const idx = sources.findIndex(s => s.id === id);
+  if (idx !== -1) {
+    sources[idx].lastChecked = new Date().toISOString();
+    saveSources(sources);
+  }
+}
+
+// Items
+export function addNewsItem(sourceId: string, sourceName: string, title: string, summary: string, category: string, url?: string, relevance?: number): NewsItem {
+  const items = loadItems();
+  // Dedup by title+source
+  if (items.some(i => i.sourceId === sourceId && i.title === title)) {
+    return items.find(i => i.sourceId === sourceId && i.title === title)!;
+  }
+  const item: NewsItem = {
+    id: randomUUID(),
+    sourceId,
+    sourceName,
+    title,
+    summary,
+    url,
+    category,
+    publishedAt: new Date().toISOString(),
+    fetchedAt: new Date().toISOString(),
+    read: false,
+    saved: false,
+    relevance
+  };
+  items.unshift(item);
+  saveItems(items);
+  return item;
+}
+
+export function listNews(category?: string, unreadOnly?: boolean, savedOnly?: boolean, limit?: number): NewsItem[] {
+  let items = loadItems();
+  if (category) items = items.filter(i => i.category === category);
+  if (unreadOnly) items = items.filter(i => !i.read);
+  if (savedOnly) items = items.filter(i => i.saved);
+  return items.slice(0, limit || 50);
+}
+
+export function markRead(id: string): boolean {
+  const items = loadItems();
+  const idx = items.findIndex(i => i.id === id);
+  if (idx === -1) return false;
+  items[idx].read = true;
+  saveItems(items);
+  return true;
+}
+
+export function markAllRead(category?: string): number {
+  const items = loadItems();
+  let count = 0;
+  for (const item of items) {
+    if (!item.read && (!category || item.category === category)) {
+      item.read = true;
+      count++;
+    }
+  }
+  saveItems(items);
+  return count;
+}
+
+export function toggleSaved(id: string): NewsItem | null {
+  const items = loadItems();
+  const idx = items.findIndex(i => i.id === id);
+  if (idx === -1) return null;
+  items[idx].saved = !items[idx].saved;
+  saveItems(items);
+  return items[idx];
+}
+
+export function searchNews(query: string): NewsItem[] {
+  const q = query.toLowerCase();
+  return loadItems().filter(i =>
+    i.title.toLowerCase().includes(q) ||
+    i.summary.toLowerCase().includes(q) ||
+    i.sourceName.toLowerCase().includes(q)
+  );
+}
+
+export function getNewsStats(): { total: number; unread: number; sources: number; byCategory: Record<string, number> } {
+  const items = loadItems();
+  const sources = loadSources();
+  const byCategory: Record<string, number> = {};
+  for (const item of items.filter(i => !i.read)) {
+    byCategory[item.category] = (byCategory[item.category] || 0) + 1;
+  }
+  return {
+    total: items.length,
+    unread: items.filter(i => !i.read).length,
+    sources: sources.filter(s => s.enabled).length,
+    byCategory
+  };
+}

package/server/ceo/template-store.ts

@@ -0,0 +1,134 @@
+import { join } from "path";
+import { readFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import { atomicWriteFileSync } from "../fs-utils.js";
+
+export interface TemplateVariable {
+  name: string;
+  description?: string;
+  defaultValue?: string;
+  required?: boolean;
+}
+
+export interface Template {
+  id: string;
+  name: string;
+  category: string; // email, contract, meeting, invoice, report, custom
+  content: string;  // with {{variable}} placeholders
+  variables: TemplateVariable[];
+  tags: string[];
+  createdAt: string;
+  updatedAt: string;
+  usageCount: number;
+  lastUsed?: string;
+}
+
+const DATA_DIR = join(process.env.HEYHANK_HOME || join(process.env.HOME || "/root", ".heyhank"), "templates");
+const STORE_FILE = join(DATA_DIR, "templates.json");
+
+function ensureDir() {
+  if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+}
+
+function load(): Template[] {
+  ensureDir();
+  if (!existsSync(STORE_FILE)) return [];
+  try { return JSON.parse(readFileSync(STORE_FILE, "utf-8")); }
+  catch { return []; }
+}
+
+function save(templates: Template[]) {
+  ensureDir();
+  atomicWriteFileSync(STORE_FILE, JSON.stringify(templates, null, 2));
+}
+
+export function listTemplates(category?: string): Template[] {
+  let templates = load();
+  if (category) templates = templates.filter(t => t.category === category);
+  return templates.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+export function createTemplate(name: string, content: string, category: string, variables?: TemplateVariable[], tags?: string[]): Template {
+  const templates = load();
+
+  // Auto-detect variables from {{...}} placeholders if not provided
+  const detectedVars = [...content.matchAll(/\{\{(\w+)\}\}/g)].map(m => m[1]);
+  const vars: TemplateVariable[] = variables || detectedVars.map(v => ({ name: v, required: true }));
+
+  const template: Template = {
+    id: randomUUID(),
+    name,
+    category,
+    content,
+    variables: vars,
+    tags: tags || [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    usageCount: 0
+  };
+
+  templates.push(template);
+  save(templates);
+  return template;
+}
+
+export function getTemplate(id: string): Template | null {
+  return load().find(t => t.id === id) || null;
+}
+
+export function updateTemplate(id: string, patch: Partial<Pick<Template, "name" | "content" | "category" | "variables" | "tags">>): Template | null {
+  const templates = load();
+  const idx = templates.findIndex(t => t.id === id);
+  if (idx === -1) return null;
+
+  if (patch.name !== undefined) templates[idx].name = patch.name;
+  if (patch.content !== undefined) templates[idx].content = patch.content;
+  if (patch.category !== undefined) templates[idx].category = patch.category;
+  if (patch.variables !== undefined) templates[idx].variables = patch.variables;
+  if (patch.tags !== undefined) templates[idx].tags = patch.tags;
+  templates[idx].updatedAt = new Date().toISOString();
+
+  save(templates);
+  return templates[idx];
+}
+
+export function deleteTemplate(id: string): boolean {
+  const templates = load();
+  const idx = templates.findIndex(t => t.id === id);
+  if (idx === -1) return false;
+  templates.splice(idx, 1);
+  save(templates);
+  return true;
+}
+
+export function useTemplate(id: string, variables: Record<string, string>): { result: string; template: Template } | null {
+  const templates = load();
+  const idx = templates.findIndex(t => t.id === id);
+  if (idx === -1) return null;
+
+  let result = templates[idx].content;
+  for (const [key, value] of Object.entries(variables)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+
+  // Update usage stats
+  templates[idx].usageCount++;
+  templates[idx].lastUsed = new Date().toISOString();
+  save(templates);
+
+  return { result, template: templates[idx] };
+}
+
+export function searchTemplates(query: string): Template[] {
+  const q = query.toLowerCase();
+  return load().filter(t =>
+    t.name.toLowerCase().includes(q) ||
+    t.category.toLowerCase().includes(q) ||
+    t.tags.some(tag => tag.toLowerCase().includes(q)) ||
+    t.content.toLowerCase().includes(q)
+  );
+}
+
+export function listCategories(): string[] {
+  return [...new Set(load().map(t => t.category))].sort();
+}