multis 0.1.0

package/src/llm/prompts.js

@@ -0,0 +1,71 @@
+/**
+ * RAG prompt builder — formats search chunks into LLM prompts.
+ */
+
+const SYSTEM_PROMPT = `You are multis, a personal assistant. Answer based on the provided documents. Cite sources as [filename, page X] or [filename, section]. If the documents don't contain the answer, say so clearly.`;
+
+/**
+ * Build a RAG prompt from a question and search chunks.
+ * @param {string} question - The user's question
+ * @param {Array} chunks - Search result chunks from the indexer
+ * @returns {{ system: string, user: string }}
+ */
+function buildRAGPrompt(question, chunks) {
+  if (!chunks || chunks.length === 0) {
+    return {
+      system: SYSTEM_PROMPT,
+      user: `No matching documents found.\n\nQuestion: ${question}`
+    };
+  }
+
+  const formattedChunks = chunks.map((chunk, i) => {
+    const source = chunk.name || 'unknown';
+    const section = chunk.sectionPath?.join(' > ') || '';
+    const pages = chunk.pageStart != null
+      ? chunk.pageEnd && chunk.pageEnd !== chunk.pageStart
+        ? `pages ${chunk.pageStart}-${chunk.pageEnd}`
+        : `page ${chunk.pageStart}`
+      : '';
+    const meta = [source, section, pages].filter(Boolean).join(', ');
+    return `--- Document ${i + 1} [${meta}] ---\n${chunk.content}`;
+  });
+
+  return {
+    system: SYSTEM_PROMPT,
+    user: `${formattedChunks.join('\n\n')}\n\n---\nQuestion: ${question}`
+  };
+}
+
+/**
+ * Build a system prompt that includes durable memory and optional RAG chunks.
+ * Used by the memory-aware conversation flow.
+ * @param {string} memoryMd - Contents of memory.md (durable notes)
+ * @param {Array} chunks - Optional RAG search chunks
+ * @returns {string} - Combined system prompt
+ */
+function buildMemorySystemPrompt(memoryMd, chunks) {
+  const parts = [SYSTEM_PROMPT];
+
+  if (memoryMd && memoryMd.trim()) {
+    parts.push(`\n## Memory (durable notes about this conversation)\n${memoryMd.trim()}`);
+  }
+
+  if (chunks && chunks.length > 0) {
+    const formattedChunks = chunks.map((chunk, i) => {
+      const source = chunk.name || 'unknown';
+      const section = chunk.sectionPath?.join(' > ') || '';
+      const pages = chunk.pageStart != null
+        ? chunk.pageEnd && chunk.pageEnd !== chunk.pageStart
+          ? `pages ${chunk.pageStart}-${chunk.pageEnd}`
+          : `page ${chunk.pageStart}`
+        : '';
+      const meta = [source, section, pages].filter(Boolean).join(', ');
+      return `--- Document ${i + 1} [${meta}] ---\n${chunk.content}`;
+    });
+    parts.push(`\n## Relevant documents\n${formattedChunks.join('\n\n')}`);
+  }
+
+  return parts.join('\n');
+}
+
+module.exports = { buildRAGPrompt, buildMemorySystemPrompt };

package/src/memory/capture.js

@@ -0,0 +1,85 @@
+/**
+ * Memory capture orchestrator — summarizes conversation when rolling window overflows.
+ * Runs fire-and-forget after responding (recent.json + daily log preserve raw data).
+ */
+
+const CAPTURE_SYSTEM = `You are a memory capture assistant. Your job is to extract durable, useful notes from a conversation.
+
+Rules:
+- Extract facts, preferences, decisions, and action items
+- Use concise bullet points
+- Include names, dates, and specific details
+- Skip greetings, small talk, and meta-conversation
+- If nothing noteworthy, respond with "No notable information."
+- Do NOT repeat information that already exists in the memory section below`;
+
+/**
+ * Run memory capture: summarize recent messages and store as durable notes.
+ * @param {string} chatId - Chat identifier
+ * @param {import('./manager').ChatMemoryManager} mem - Memory manager instance
+ * @param {import('../llm/base').LLMProvider} llm - LLM provider
+ * @param {import('../indexer/index').DocumentIndexer} indexer - Document indexer
+ * @param {Object} options - { keepLast: 5 }
+ */
+async function runCapture(chatId, mem, llm, indexer, options = {}) {
+  const keepLast = options.keepLast || 5;
+
+  try {
+    const recent = mem.loadRecent();
+    if (recent.length === 0) return;
+
+    const existingMemory = mem.loadMemory();
+
+    // Format conversation for LLM
+    const conversationText = recent
+      .map(m => `[${m.role}]: ${m.content}`)
+      .join('\n');
+
+    const system = existingMemory.trim()
+      ? `${CAPTURE_SYSTEM}\n\n## Existing memory\n${existingMemory}`
+      : CAPTURE_SYSTEM;
+
+    const summary = await llm.generate(
+      `Summarize the notable information from this conversation:\n\n${conversationText}`,
+      { system, maxTokens: 512, temperature: 0.3 }
+    );
+
+    // Append to durable memory (skip if nothing notable)
+    if (summary && !summary.toLowerCase().includes('no notable information')) {
+      mem.appendMemory(summary);
+    }
+
+    // Index raw messages as conversation chunks
+    for (const m of recent.slice(0, -keepLast)) {
+      try {
+        indexer.store.saveChunk({
+          chunk_id: `conv-${chatId}-${m.timestamp}`,
+          file_path: `memory/chats/${chatId}`,
+          page_start: null,
+          page_end: null,
+          element_type: 'conversation',
+          name: `${m.role} @ ${m.timestamp}`,
+          content: m.content,
+          parent_chunk_id: null,
+          section_path: JSON.stringify([chatId, m.role]),
+          section_level: 0,
+          document_type: 'conversation',
+          metadata: JSON.stringify({ role: m.role, chatId }),
+          created_at: m.timestamp,
+          updated_at: m.timestamp
+        });
+      } catch {
+        // Duplicate chunk_id or store error — not critical
+      }
+    }
+
+    // Trim recent to keep last N messages
+    mem.trimRecent(keepLast);
+
+    console.log(`[capture] Chat ${chatId}: captured ${recent.length - keepLast} messages`);
+  } catch (err) {
+    console.error(`[capture] Error for chat ${chatId}: ${err.message}`);
+  }
+}
+
+module.exports = { runCapture };

package/src/memory/manager.js

@@ -0,0 +1,123 @@
+const fs = require('fs');
+const path = require('path');
+
+const MEMORY_BASE = path.join(
+  process.env.HOME || process.env.USERPROFILE,
+  '.multis', 'memory', 'chats'
+);
+
+/**
+ * Per-chat memory manager — handles profile, recent messages, durable memory, and daily logs.
+ * All I/O is synchronous (single process, no concurrency).
+ */
+class ChatMemoryManager {
+  constructor(chatId) {
+    this.chatId = String(chatId);
+    this.dir = path.join(MEMORY_BASE, this.chatId);
+    this.profilePath = path.join(this.dir, 'profile.json');
+    this.recentPath = path.join(this.dir, 'recent.json');
+    this.memoryPath = path.join(this.dir, 'memory.md');
+    this.logDir = path.join(this.dir, 'log');
+    this.ensureDirectories();
+  }
+
+  ensureDirectories() {
+    if (!fs.existsSync(this.dir)) fs.mkdirSync(this.dir, { recursive: true });
+    if (!fs.existsSync(this.logDir)) fs.mkdirSync(this.logDir, { recursive: true });
+  }
+
+  // --- Profile ---
+
+  loadProfile() {
+    if (!fs.existsSync(this.profilePath)) {
+      return { mode: 'personal', platform: null, lastActive: null, created: new Date().toISOString() };
+    }
+    return JSON.parse(fs.readFileSync(this.profilePath, 'utf-8'));
+  }
+
+  saveProfile(profile) {
+    profile.lastActive = new Date().toISOString();
+    fs.writeFileSync(this.profilePath, JSON.stringify(profile, null, 2));
+  }
+
+  // --- Recent messages (rolling window) ---
+
+  loadRecent() {
+    if (!fs.existsSync(this.recentPath)) return [];
+    try {
+      return JSON.parse(fs.readFileSync(this.recentPath, 'utf-8'));
+    } catch {
+      return [];
+    }
+  }
+
+  saveRecent(messages) {
+    fs.writeFileSync(this.recentPath, JSON.stringify(messages, null, 2));
+  }
+
+  appendMessage(role, content, timestamp = null) {
+    const messages = this.loadRecent();
+    messages.push({
+      role,
+      content,
+      timestamp: timestamp || new Date().toISOString()
+    });
+    this.saveRecent(messages);
+    return messages;
+  }
+
+  trimRecent(keepLast = 5) {
+    const messages = this.loadRecent();
+    if (messages.length <= keepLast) return messages;
+    const trimmed = messages.slice(-keepLast);
+    this.saveRecent(trimmed);
+    return trimmed;
+  }
+
+  // --- Durable memory (memory.md) ---
+
+  loadMemory() {
+    if (!fs.existsSync(this.memoryPath)) return '';
+    return fs.readFileSync(this.memoryPath, 'utf-8');
+  }
+
+  appendMemory(notes) {
+    const header = `\n## ${new Date().toISOString()}\n\n`;
+    fs.appendFileSync(this.memoryPath, header + notes.trim() + '\n');
+  }
+
+  clearMemory() {
+    fs.writeFileSync(this.memoryPath, '');
+  }
+
+  // --- Daily log (append-only) ---
+
+  appendToLog(role, content) {
+    const now = new Date();
+    const dateStr = now.toISOString().slice(0, 10);
+    const timeStr = now.toISOString().slice(11, 19);
+    const logFile = path.join(this.logDir, `${dateStr}.md`);
+    const entry = `### ${timeStr} [${role}]\n${content}\n\n`;
+    fs.appendFileSync(logFile, entry);
+  }
+
+  // --- Capture threshold ---
+
+  shouldCapture(threshold = 20) {
+    const messages = this.loadRecent();
+    return messages.length >= threshold;
+  }
+}
+
+/**
+ * Get or create a ChatMemoryManager for a chatId.
+ * Uses a Map cache to avoid re-creating managers.
+ */
+function getMemoryManager(cache, chatId) {
+  if (!cache.has(chatId)) {
+    cache.set(chatId, new ChatMemoryManager(chatId));
+  }
+  return cache.get(chatId);
+}
+
+module.exports = { ChatMemoryManager, getMemoryManager };

package/src/platforms/base.js

@@ -0,0 +1,38 @@
+/**
+ * Abstract platform base class.
+ * All platform adapters (Telegram, Beeper, etc.) extend this.
+ */
+class Platform {
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+    this._messageCallback = null;
+  }
+
+  async start() {
+    throw new Error(`${this.name}: start() not implemented`);
+  }
+
+  async stop() {
+    throw new Error(`${this.name}: stop() not implemented`);
+  }
+
+  /**
+   * Send a text message to a chat.
+   * @param {string} chatId
+   * @param {string} text
+   */
+  async send(chatId, text) {
+    throw new Error(`${this.name}: send() not implemented`);
+  }
+
+  /**
+   * Register callback for incoming messages.
+   * Callback receives Message objects.
+   */
+  onMessage(callback) {
+    this._messageCallback = callback;
+  }
+}
+
+module.exports = { Platform };

package/src/platforms/beeper.js

@@ -0,0 +1,238 @@
+const fs = require('fs');
+const path = require('path');
+const { Platform } = require('./base');
+const { Message } = require('./message');
+const { logAudit } = require('../governance/audit');
+
+const DEFAULT_URL = 'http://localhost:23373';
+const DEFAULT_POLL_INTERVAL = 3000;
+const TOKEN_FILE = path.join(process.env.HOME || process.env.USERPROFILE, '.multis', 'beeper-token.json');
+
+/**
+ * Beeper Desktop API platform adapter.
+ * Polls localhost:23373 for new messages, processes // commands from self.
+ */
+class BeeperPlatform extends Platform {
+  constructor(config) {
+    super('beeper', config);
+    const bc = config.platforms?.beeper || {};
+    this.baseUrl = bc.url || DEFAULT_URL;
+    this.pollInterval = bc.poll_interval || DEFAULT_POLL_INTERVAL;
+    this.commandPrefix = bc.command_prefix || '//';
+    this.token = null;
+    this.selfIds = new Set(); // account user IDs to detect self-messages
+    this._pollTimer = null;
+    this._lastSeen = {}; // chatId -> last message ID (numeric) we processed
+    this._initialized = false; // first poll seeds _lastSeen without processing
+    this._personalChats = new Set(); // chatIds that are self/note-to-self chats
+  }
+
+  async start() {
+    this.token = this._loadToken();
+    if (!this.token) {
+      console.error('Beeper: no token found. Run: node src/cli/setup-beeper.js');
+      return;
+    }
+
+    // Verify token and discover self IDs
+    try {
+      const accounts = await this._api('GET', '/v1/accounts');
+      const list = Array.isArray(accounts) ? accounts : accounts.items || [];
+      for (const acc of list) {
+        if (acc.user?.id) this.selfIds.add(acc.user.id);
+        if (acc.accountID) this.selfIds.add(acc.accountID);
+      }
+      console.log(`Beeper: connected (${list.length} accounts)`);
+    } catch (err) {
+      console.error(`Beeper: token invalid or Desktop not running — ${err.message}`);
+      return;
+    }
+
+    // Seed _lastSeen with current message IDs so we don't process old messages
+    await this._seedLastSeen();
+    this._initialized = true;
+
+    // Start polling
+    this._pollTimer = setInterval(() => this._poll(), this.pollInterval);
+    console.log(`Beeper: polling every ${this.pollInterval}ms for ${this.commandPrefix} commands`);
+  }
+
+  async stop() {
+    if (this._pollTimer) {
+      clearInterval(this._pollTimer);
+      this._pollTimer = null;
+    }
+  }
+
+  async send(chatId, text) {
+    // Prefix responses so they're distinguishable from user's own messages
+    const prefixed = `[multis] ${text}`;
+    await this._api('POST', `/v1/chats/${encodeURIComponent(chatId)}/messages`, { text: prefixed });
+  }
+
+  async _seedLastSeen() {
+    try {
+      const data = await this._api('GET', '/v1/chats?limit=20');
+      const chats = data.items || [];
+      for (const chat of chats) {
+        const chatId = chat.id || chat.chatID;
+        if (!chatId) continue;
+
+        // Detect self/note-to-self chats by type or participant count
+        const chatType = chat.type || '';
+        const participants = chat.participants || chat.members || [];
+        if (chatType === 'single' && participants.length <= 1) {
+          this._personalChats.add(chatId);
+        }
+
+        const msgData = await this._api('GET', `/v1/chats/${encodeURIComponent(chatId)}/messages?limit=1`);
+        const messages = msgData.items || [];
+        if (messages.length > 0) {
+          const id = messages[0].id || messages[0].messageID;
+          if (id) this._lastSeen[chatId] = Number(id);
+        }
+      }
+      if (this._personalChats.size > 0) {
+        console.log(`Beeper: detected ${this._personalChats.size} personal/self chat(s)`);
+      }
+    } catch (err) {
+      console.error(`Beeper: seed error — ${err.message}`);
+    }
+  }
+
+  async _poll() {
+    if (!this._initialized) return;
+    try {
+      const data = await this._api('GET', '/v1/chats?limit=20');
+      const chats = data.items || [];
+
+      for (const chat of chats) {
+        const chatId = chat.id || chat.chatID;
+        if (!chatId) continue;
+
+        const msgData = await this._api('GET', `/v1/chats/${encodeURIComponent(chatId)}/messages?limit=5`);
+        const messages = msgData.items || [];
+
+        // Messages are newest-first; process in reverse (oldest-first) for correct ordering
+        for (let i = messages.length - 1; i >= 0; i--) {
+          const msg = messages[i];
+          const msgId = Number(msg.id || msg.messageID);
+          if (!msgId) continue;
+
+          // Skip already-seen messages
+          const lastSeen = this._lastSeen[chatId] || 0;
+          if (msgId <= lastSeen) continue;
+
+          // Update last seen
+          this._lastSeen[chatId] = msgId;
+
+          const isSelf = this._isSelf(msg);
+          const text = msg.text || '';
+
+          // Skip our own responses to avoid cascade
+          if (text.startsWith('[multis]')) continue;
+
+          if (!this._messageCallback) continue;
+
+          // Detect self/personal chats (single participant or DM type)
+          const isPersonalChat = this._personalChats.has(chatId);
+          const mode = this._getChatMode(chatId);
+
+          // Determine how to route this message
+          let routeAs = null;
+          let shouldProcess = false;
+
+          if (isSelf && text.startsWith(this.commandPrefix)) {
+            // Explicit command: //ask, //mode, etc.
+            shouldProcess = true;
+          } else if (isSelf && isPersonalChat && !text.startsWith(this.commandPrefix)) {
+            // Self-message in personal/note-to-self chat → natural language ask
+            routeAs = 'natural';
+            shouldProcess = true;
+          } else if (!isSelf && mode === 'business') {
+            // Incoming message in a business-mode chat → auto-respond
+            routeAs = 'business';
+            shouldProcess = true;
+          }
+
+          if (shouldProcess) {
+            console.log(`Beeper: ${routeAs || 'command'} from ${chat.title || chatId}: ${text.slice(0, 80)}`);
+
+            const normalized = new Message({
+              id: msgId,
+              platform: 'beeper',
+              chatId,
+              chatName: chat.title || chat.name || '',
+              senderId: msg.senderID || msg.sender || '',
+              senderName: msg.senderName || '',
+              isSelf,
+              text,
+              raw: msg,
+              routeAs,
+            });
+
+            try {
+              await this._messageCallback(normalized, this);
+            } catch (err) {
+              console.error(`Beeper: handler error — ${err.message}`);
+            }
+          }
+        }
+      }
+
+      // Clear poll error flag on success
+      this._pollErrorLogged = false;
+    } catch (err) {
+      if (!this._pollErrorLogged) {
+        console.error(`Beeper: poll error — ${err.message}`);
+        this._pollErrorLogged = true;
+      }
+    }
+  }
+
+  _isSelf(msg) {
+    const sender = msg.senderID || msg.sender || '';
+    return this.selfIds.has(sender);
+  }
+
+  _getChatMode(chatId) {
+    const modes = this.config.platforms?.beeper?.chat_modes;
+    if (modes && modes[chatId]) return modes[chatId];
+    return this.config.platforms?.beeper?.default_mode || 'personal';
+  }
+
+  _loadToken() {
+    try {
+      const data = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf8'));
+      return data.access_token;
+    } catch {
+      // Also check legacy location
+      const legacyPath = path.join(__dirname, '..', '..', '.beeper-storage', 'desktop-token.json');
+      try {
+        const data = JSON.parse(fs.readFileSync(legacyPath, 'utf8'));
+        return data.access_token;
+      } catch {
+        return null;
+      }
+    }
+  }
+
+  async _api(method, apiPath, body) {
+    const opts = {
+      method,
+      headers: {
+        'Authorization': `Bearer ${this.token}`,
+        'Content-Type': 'application/json',
+      },
+    };
+    if (body) opts.body = JSON.stringify(body);
+    const res = await fetch(`${this.baseUrl}${apiPath}`, opts);
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`${res.status} ${res.statusText}: ${text}`);
+    }
+    return res.json();
+  }
+}
+
+module.exports = { BeeperPlatform };

package/src/platforms/message.js

@@ -0,0 +1,61 @@
+/**
+ * Normalized message across all platforms.
+ * Telegram bot messages are always commands.
+ * Beeper messages are commands only when prefixed with //.
+ */
+class Message {
+  constructor({ id, platform, chatId, chatName, senderId, senderName, isSelf, text, raw, routeAs }) {
+    this.id = id;
+    this.platform = platform;
+    this.chatId = chatId;
+    this.chatName = chatName || '';
+    this.senderId = senderId;
+    this.senderName = senderName || '';
+    this.isSelf = isSelf || false;
+    this.text = text || '';
+    this.raw = raw || null;
+    /** @type {'natural'|'business'|null} Set by platform for non-command routing */
+    this.routeAs = routeAs || null;
+  }
+
+  /**
+   * Is this message a command for multis?
+   * Telegram: all messages to the bot are commands (it's a dedicated bot).
+   * Beeper: only messages starting with // are commands.
+   */
+  isCommand() {
+    if (this.platform === 'telegram') return true;
+    if (this.platform === 'beeper') return this.isSelf && this.text.startsWith('//');
+    return false;
+  }
+
+  /**
+   * Get the command text with platform prefix stripped.
+   * Telegram: "/exec ls" -> "exec ls", plain text -> text as-is
+   * Beeper: "//exec ls" -> "exec ls"
+   */
+  commandText() {
+    if (this.platform === 'telegram') {
+      return this.text.startsWith('/') ? this.text.slice(1) : this.text;
+    }
+    if (this.platform === 'beeper') {
+      return this.text.startsWith('//') ? this.text.slice(2).trimStart() : this.text;
+    }
+    return this.text;
+  }
+
+  /**
+   * Parse command name and arguments.
+   * Returns { command, args } or null if not a command.
+   */
+  parseCommand() {
+    if (!this.isCommand()) return null;
+    const text = this.commandText();
+    // Handle Telegram @bot suffix: /command@botname args
+    const match = text.match(/^([^\s@]+)(?:@\S+)?(?:\s+(.*)|$)/s);
+    if (!match) return null;
+    return { command: match[1].toLowerCase(), args: match[2] };
+  }
+}
+
+module.exports = { Message };