alvin-bot 4.4.1

package/dist/services/mcp.js

@@ -0,0 +1,252 @@
+/**
+ * MCP (Model Context Protocol) Client — Connect to any MCP-compatible tool server.
+ *
+ * Supports:
+ * - stdio transport (local processes)
+ * - HTTP/SSE transport (remote servers)
+ *
+ * Configuration via docs/mcp.json:
+ * {
+ *   "servers": {
+ *     "filesystem": {
+ *       "command": "npx",
+ *       "args": ["-y", "@modelcontextprotocol/server-filesystem", "/tmp"],
+ *       "env": {}
+ *     },
+ *     "remote-server": {
+ *       "url": "https://mcp.example.com/sse",
+ *       "headers": { "Authorization": "Bearer ..." }
+ *     }
+ *   }
+ * }
+ */
+import { spawn } from "child_process";
+import fs from "fs";
+import { MCP_CONFIG } from "../paths.js";
+// ── MCP Client ──────────────────────────────────────────
+const servers = new Map();
+/**
+ * Load MCP configuration from docs/mcp.json.
+ */
+function loadConfig() {
+    try {
+        const raw = fs.readFileSync(MCP_CONFIG, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return { servers: {} };
+    }
+}
+/**
+ * Send a JSON-RPC message to a stdio MCP server.
+ */
+function sendMessage(server, method, params) {
+    return new Promise((resolve, reject) => {
+        if (!server.process?.stdin?.writable) {
+            reject(new Error(`Server ${server.name} not connected`));
+            return;
+        }
+        const id = ++server.requestId;
+        const message = JSON.stringify({
+            jsonrpc: "2.0",
+            id,
+            method,
+            params: params || {},
+        });
+        server.pendingRequests.set(id, { resolve, reject });
+        // Timeout after 30s
+        setTimeout(() => {
+            if (server.pendingRequests.has(id)) {
+                server.pendingRequests.delete(id);
+                reject(new Error(`Request ${id} timed out`));
+            }
+        }, 30000);
+        server.process.stdin.write(message + "\n");
+    });
+}
+/**
+ * Handle incoming JSON-RPC responses from a stdio server.
+ */
+function handleResponse(server, line) {
+    try {
+        const msg = JSON.parse(line);
+        if (msg.id && server.pendingRequests.has(msg.id)) {
+            const pending = server.pendingRequests.get(msg.id);
+            server.pendingRequests.delete(msg.id);
+            if (msg.error) {
+                pending.reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+            }
+            else {
+                pending.resolve(msg.result);
+            }
+        }
+    }
+    catch {
+        // Not valid JSON — skip
+    }
+}
+/**
+ * Connect to a stdio MCP server.
+ */
+async function connectStdio(name, config) {
+    const server = {
+        name,
+        config,
+        tools: [],
+        connected: false,
+        requestId: 0,
+        pendingRequests: new Map(),
+        buffer: "",
+    };
+    return new Promise((resolve, reject) => {
+        const proc = spawn(config.command, config.args || [], {
+            env: { ...process.env, ...config.env },
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        server.process = proc;
+        proc.stdout.on("data", (data) => {
+            server.buffer += data.toString();
+            const lines = server.buffer.split("\n");
+            server.buffer = lines.pop() || "";
+            for (const line of lines) {
+                if (line.trim())
+                    handleResponse(server, line.trim());
+            }
+        });
+        proc.stderr.on("data", (data) => {
+            console.error(`MCP ${name} stderr:`, data.toString().trim());
+        });
+        proc.on("error", (err) => {
+            console.error(`MCP ${name} process error:`, err);
+            server.connected = false;
+        });
+        proc.on("close", (code) => {
+            console.log(`MCP ${name} exited with code ${code}`);
+            server.connected = false;
+        });
+        // Initialize the connection
+        setTimeout(async () => {
+            try {
+                // Send initialize
+                await sendMessage(server, "initialize", {
+                    protocolVersion: "2024-11-05",
+                    capabilities: {},
+                    clientInfo: { name: "alvin-bot", version: "2.2.0" },
+                });
+                // Send initialized notification
+                server.process.stdin.write(JSON.stringify({
+                    jsonrpc: "2.0",
+                    method: "notifications/initialized",
+                }) + "\n");
+                // List tools
+                const result = await sendMessage(server, "tools/list");
+                server.tools = result?.tools || [];
+                server.connected = true;
+                console.log(`MCP ${name}: connected, ${server.tools.length} tools`);
+                resolve(server);
+            }
+            catch (err) {
+                reject(err);
+            }
+        }, 500);
+    });
+}
+// ── Public API ──────────────────────────────────────────
+/**
+ * Initialize all configured MCP servers.
+ */
+export async function initMCP() {
+    const config = loadConfig();
+    const connected = [];
+    const errors = [];
+    for (const [name, serverConfig] of Object.entries(config.servers)) {
+        try {
+            if (serverConfig.command) {
+                const server = await connectStdio(name, serverConfig);
+                servers.set(name, server);
+                connected.push(name);
+            }
+            else if (serverConfig.url) {
+                // HTTP/SSE transport — not yet implemented
+                errors.push({ name, error: "HTTP/SSE transport not yet supported" });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push({ name, error: msg });
+        }
+    }
+    return { connected, errors };
+}
+/**
+ * Call a tool on an MCP server.
+ */
+export async function callMCPTool(serverName, toolName, args) {
+    const server = servers.get(serverName);
+    if (!server)
+        throw new Error(`MCP server "${serverName}" not found`);
+    if (!server.connected)
+        throw new Error(`MCP server "${serverName}" not connected`);
+    const result = await sendMessage(server, "tools/call", {
+        name: toolName,
+        arguments: args,
+    });
+    // Extract text from content array
+    const texts = (result?.content || [])
+        .filter((c) => c.type === "text")
+        .map((c) => c.text || "");
+    return texts.join("\n") || JSON.stringify(result);
+}
+/**
+ * Get all available MCP tools across all servers.
+ */
+export function getMCPTools() {
+    const tools = [];
+    for (const [serverName, server] of servers) {
+        for (const tool of server.tools) {
+            tools.push({
+                server: serverName,
+                name: tool.name,
+                description: tool.description,
+            });
+        }
+    }
+    return tools;
+}
+/**
+ * Get MCP server status.
+ */
+export function getMCPStatus() {
+    const result = [];
+    for (const [name, server] of servers) {
+        result.push({
+            name,
+            connected: server.connected,
+            tools: server.tools.length,
+        });
+    }
+    return result;
+}
+/**
+ * Disconnect all MCP servers.
+ */
+export async function disconnectMCP() {
+    for (const [name, server] of servers) {
+        try {
+            if (server.process) {
+                server.process.kill();
+            }
+            console.log(`MCP ${name} disconnected`);
+        }
+        catch (err) {
+            console.error(`MCP ${name} disconnect error:`, err);
+        }
+    }
+    servers.clear();
+}
+/**
+ * Check if MCP config exists.
+ */
+export function hasMCPConfig() {
+    return fs.existsSync(MCP_CONFIG);
+}

package/dist/services/memory.js

@@ -0,0 +1,133 @@
+/**
+ * Memory Service — Persistent memory across sessions.
+ *
+ * Manages:
+ * - MEMORY.md (long-term, curated knowledge)
+ * - memory/YYYY-MM-DD.md (daily session logs)
+ * - Auto-write session summaries on /new
+ * - Load context at session start
+ */
+import fs from "fs";
+import { resolve } from "path";
+import { MEMORY_DIR, MEMORY_FILE } from "../paths.js";
+import { reindexMemory } from "./embeddings.js";
+// Ensure dirs exist
+if (!fs.existsSync(MEMORY_DIR))
+    fs.mkdirSync(MEMORY_DIR, { recursive: true });
+/** Get today's date as YYYY-MM-DD */
+function today() {
+    return new Date().toISOString().slice(0, 10);
+}
+/** Get current time as HH:MM */
+function now() {
+    return new Date().toLocaleTimeString("de-DE", { hour: "2-digit", minute: "2-digit" });
+}
+/**
+ * Load long-term memory (MEMORY.md).
+ */
+export function loadLongTermMemory() {
+    try {
+        return fs.readFileSync(MEMORY_FILE, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Load today's daily log.
+ */
+export function loadDailyLog(date) {
+    const d = date || today();
+    const filePath = resolve(MEMORY_DIR, `${d}.md`);
+    try {
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Append an entry to today's daily log.
+ */
+export function appendDailyLog(entry) {
+    const filePath = resolve(MEMORY_DIR, `${today()}.md`);
+    const header = `# ${today()} — Session Log\n\n`;
+    let content = "";
+    try {
+        content = fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        content = header;
+    }
+    content += `\n## ~${now()}\n\n${entry}\n`;
+    fs.writeFileSync(filePath, content);
+    // Trigger incremental reindex in background (non-blocking)
+    reindexMemory().catch(() => { });
+}
+/**
+ * Build memory context for injection into non-SDK prompts.
+ * Returns relevant memory as a compact string.
+ */
+export function buildMemoryContext() {
+    const parts = [];
+    // Long-term memory (truncate if too long)
+    const ltm = loadLongTermMemory();
+    if (ltm) {
+        const truncated = ltm.length > 2000 ? ltm.slice(0, 2000) + "\n[...truncated]" : ltm;
+        parts.push(`## Long-term Memory\n${truncated}`);
+    }
+    // Today's log
+    const todayLog = loadDailyLog();
+    if (todayLog) {
+        const truncated = todayLog.length > 1500 ? todayLog.slice(-1500) : todayLog;
+        parts.push(`## Today's Log\n${truncated}`);
+    }
+    // Yesterday's log (for continuity)
+    const yesterday = new Date(Date.now() - 86_400_000).toISOString().slice(0, 10);
+    const yesterdayLog = loadDailyLog(yesterday);
+    if (yesterdayLog) {
+        const truncated = yesterdayLog.length > 500 ? yesterdayLog.slice(-500) : yesterdayLog;
+        parts.push(`## Yesterday's Log (summary)\n${truncated}`);
+    }
+    if (parts.length === 0)
+        return "";
+    return `\n\n---\n## Your Memory (auto-loaded)\n\n${parts.join("\n\n")}`;
+}
+/**
+ * Write a session summary to daily log.
+ * Called when user does /new or session is long enough.
+ */
+export function writeSessionSummary(summary) {
+    const lines = [
+        `**Session Summary:**`,
+        `- Messages: ${summary.messageCount}`,
+        `- Tool Calls: ${summary.toolUseCount}`,
+        `- Cost: $${summary.costUsd.toFixed(4)}`,
+        `- Provider: ${summary.provider}`,
+    ];
+    if (summary.topics && summary.topics.length > 0) {
+        lines.push(`- Topics: ${summary.topics.join(", ")}`);
+    }
+    appendDailyLog(lines.join("\n"));
+}
+/**
+ * Get memory stats for /status.
+ */
+export function getMemoryStats() {
+    let longTermSize = 0;
+    try {
+        longTermSize = fs.statSync(MEMORY_FILE).size;
+    }
+    catch { /* empty */ }
+    let dailyLogs = 0;
+    try {
+        dailyLogs = fs.readdirSync(MEMORY_DIR).filter(f => f.endsWith(".md") && f !== ".gitkeep").length;
+    }
+    catch { /* empty */ }
+    let todayEntries = 0;
+    const todayLog = loadDailyLog();
+    if (todayLog) {
+        todayEntries = (todayLog.match(/^## ~/gm) || []).length;
+    }
+    return { longTermSize, dailyLogs, todayEntries };
+}

package/dist/services/personality.js

@@ -0,0 +1,227 @@
+/**
+ * Personality Service — Loads SOUL.md and builds system prompts.
+ *
+ * SOUL.md defines Alvin Bot's personality and is injected into every system prompt.
+ * This ensures consistent personality across ALL providers (SDK + non-SDK).
+ */
+import { readFileSync } from "fs";
+import { buildMemoryContext } from "./memory.js";
+import { searchMemory } from "./embeddings.js";
+import { getToolSummary } from "./tool-discovery.js";
+import { SOUL_FILE } from "../paths.js";
+import { loadStandingOrders, getStandingOrders } from "./standing-orders.js";
+import { getAssetIndexMd } from "./asset-index.js";
+// Resolve display name for the active provider
+function getActiveProviderLabel() {
+    try {
+        const primary = process.env.PRIMARY_PROVIDER || "claude-sdk";
+        const labels = {
+            "claude-sdk": "Claude (Anthropic Agent SDK) — Opus/Sonnet Klasse",
+            "openai": "OpenAI GPT",
+            "groq": "Groq (Llama 3.3 70B)",
+            "gemini-2.5-flash": "Google Gemini 2.5 Flash",
+            "google": "Google Gemini",
+            "nvidia-llama-3.3-70b": "NVIDIA NIM (Llama 3.3 70B)",
+            "nvidia-kimi-k2.5": "NVIDIA NIM (Kimi K2.5)",
+        };
+        return labels[primary] || primary;
+    }
+    catch {
+        return "AI language model";
+    }
+}
+let soulContent = "";
+try {
+    soulContent = readFileSync(SOUL_FILE, "utf-8");
+}
+catch {
+    console.warn("SOUL.md not found — using default personality");
+}
+loadStandingOrders();
+/** Base system prompt — adapts to user language */
+function getBasePrompt(lang) {
+    return lang === "de"
+        ? `You are Alvin Bot, an autonomous AI agent on Telegram.\nUse Markdown formatting compatible with Telegram (bold, italic, code blocks).`
+        : `You are Alvin Bot, an autonomous AI agent on Telegram.\nUse Markdown formatting compatible with Telegram (bold, italic, code blocks).`;
+}
+/** Additional instructions for SDK providers (tool use) */
+const SDK_ADDON = `When you run commands or edit files, briefly explain what you did.`;
+/**
+ * Self-Awareness Core — Dynamic introspection block.
+ *
+ * This makes the agent deeply aware of what it IS, what it can do natively
+ * (without external APIs), and when to use tools vs its own intelligence.
+ *
+ * Injected into EVERY system prompt, adapted to the active provider.
+ */
+function buildSelfAwareness(isSDK, providerName, lang = "en") {
+    const model = providerName || (isSDK ? "Claude (Anthropic Agent SDK)" : "AI language model");
+    if (lang === "de") {
+        return `## Self-Awareness — Who you are and what you can do
+
+You are a high-performance AI language model (${model}).
+
+### What you can do NATIVELY (no external APIs or tools needed):
+- **Analyze, summarize, translate text** — You ARE the language model. You ARE the AI.
+- **Evaluate, categorize, prioritize content** — Your core competency.
+- **Creative writing** — Letters, reports, emails, stories, code.
+- **Logical reasoning** — Problem solving, decision making, strategy development.
+- **Data structuring** — Extract JSON, CSV, tables from free text.
+- **Write and debug code** — In any common programming language.
+
+### When you need tools (and when you DON'T):
+- **Summarize text?** → Do it YOURSELF. No API call needed.
+- **Read emails?** → Use tools. But summarize content YOURSELF.
+- **Generate images?** → API needed (Gemini, DALL-E).
+- **Fetch a webpage?** → Use tools. But analyze content YOURSELF.
+- **Create PDF?** → Use tools. But write the text YOURSELF.
+
+### 📄 HTML → PDF Best Practices (letters, reports, documents):
+When generating PDFs from HTML (e.g., via Puppeteer, Playwright, wkhtmltopdf):
+- **\`break-inside: avoid\` + \`page-break-inside: avoid\`** on all logical blocks:
+  - Heading + first paragraph (keep together!)
+  - Blockquotes, citation boxes
+  - List items, timeline entries
+  - Signature area (closing + line + name)
+- **\`break-after: avoid\`** on headings — never leave a heading alone at page bottom
+- **Set A4 explicitly:** \`paperWidth: 8.27, paperHeight: 11.69\` (inches) — default is US Letter!
+- **Continuous HTML flow** instead of fixed page divs → let the browser optimize page breaks
+- **Margins:** \`margin: 15mm 20mm\` for professional letters
+- **Font size:** 11-12pt for body text, line-height: 1.5-1.6
+
+### Decision rule:
+**NEVER** call an external LLM API (Groq, Gemini, OpenAI) to process text — YOU are the LLM!
+Always ask yourself first: "Can I solve this with my own intelligence?" If yes → do it directly.`;
+    }
+    return `## Self-Awareness — Who you are and what you can do
+
+You are a high-performance AI language model (${model}).
+
+### What you can do NATIVELY (no external APIs or tools needed):
+- **Analyze, summarize, translate text** — You ARE the language model. You ARE the AI.
+- **Evaluate, categorize, prioritize content** — Your core competency.
+- **Creative writing** — Letters, reports, emails, stories, code.
+- **Logical reasoning** — Problem solving, decision making, strategy development.
+- **Data structuring** — Extract JSON, CSV, tables from free text.
+- **Write and debug code** — In any common programming language.
+
+### When you need tools (and when you DON'T):
+- **Summarize text?** → Do it YOURSELF. No API call needed.
+- **Read emails?** → Use tools (osascript, himalaya). But summarize content YOURSELF.
+- **Generate images?** → API needed (Gemini, DALL-E).
+- **Fetch a webpage?** → Use tools (curl, web_fetch). But analyze content YOURSELF.
+- **Create PDF?** → Use tools (Python script). But write the text YOURSELF.
+
+### 📄 HTML → PDF Best Practices (letters, reports, documents):
+When generating PDFs from HTML (e.g., via Puppeteer, Playwright, wkhtmltopdf):
+- **\`break-inside: avoid\` + \`page-break-inside: avoid\`** on all logical blocks:
+  - Heading + first paragraph (keep together!)
+  - Blockquotes, citation boxes
+  - List items, timeline entries
+  - Signature area (closing + line + name)
+- **\`break-after: avoid\`** on headings — never leave a heading alone at page bottom
+- **Set A4 explicitly:** \`paperWidth: 8.27, paperHeight: 11.69\` (inches) — default is US Letter!
+- **Continuous HTML flow** instead of fixed page divs → let the browser optimize page breaks
+- **Margins:** \`margin: 15mm 20mm\` for professional letters
+- **Font size:** 11-12pt for body text, line-height: 1.5-1.6
+
+### Decision rule:
+**NEVER** call an external LLM API (Groq, Gemini, OpenAI) to process text — YOU are the LLM!
+Always ask yourself first: "Can I solve this with my own intelligence?" If yes → do it directly.`;
+}
+/**
+ * Build the full system prompt for a query.
+ * @param isSDK Whether the active provider is the Claude SDK (has tool use)
+ * @param language Preferred language ('de' or 'en')
+ */
+export function buildSystemPrompt(isSDK, language = "de", chatId) {
+    const langInstruction = language === "en"
+        ? "Respond in English. If the user writes in another language, mirror their language naturally."
+        : "Reply in the language the user writes in. Match their language naturally.";
+    // Current date/time context
+    const now = new Date();
+    const locale = language === "de" ? "de-DE" : "en-US";
+    const dateStr = now.toLocaleDateString(locale, { weekday: "long", year: "numeric", month: "long", day: "numeric" });
+    const timeStr = now.toLocaleTimeString(locale, { hour: "2-digit", minute: "2-digit" });
+    const timeContext = language === "de"
+        ? `Current date: ${dateStr}, ${timeStr} (Europe/Berlin).`
+        : `Current date: ${dateStr}, ${timeStr} (Europe/Berlin).`;
+    const parts = [getBasePrompt(language), langInstruction, timeContext];
+    // Core self-awareness — always injected, adapted to active provider and language
+    parts.push(buildSelfAwareness(isSDK, getActiveProviderLabel(), language));
+    if (soulContent) {
+        parts.push(soulContent);
+    }
+    const standingOrders = getStandingOrders();
+    if (standingOrders) {
+        parts.push("## Standing Orders\n\n" + standingOrders);
+    }
+    if (isSDK) {
+        parts.push(SDK_ADDON);
+        // SDK providers have bash access — inject discovered tools so they know what's available
+        parts.push(getToolSummary());
+    }
+    // Inject chat context for cron job creation
+    if (chatId) {
+        parts.push(`Current chat: Platform=telegram, ChatID=${chatId}. Use this ChatID when creating cron jobs that should send results to this chat.`);
+    }
+    // Non-SDK providers get memory injected into system prompt
+    // (SDK provider reads memory files directly via tools)
+    if (!isSDK) {
+        const memoryCtx = buildMemoryContext();
+        if (memoryCtx) {
+            parts.push(memoryCtx);
+        }
+    }
+    // Non-SDK: inject compact asset awareness
+    if (!isSDK) {
+        const assetMd = getAssetIndexMd();
+        if (assetMd) {
+            parts.push(assetMd);
+        }
+    }
+    return parts.join("\n\n");
+}
+/**
+ * Build a system prompt enhanced with semantically relevant memories.
+ * Searches the vector index for context related to the user's message.
+ */
+export async function buildSmartSystemPrompt(isSDK, language = "de", userMessage, chatId) {
+    const base = buildSystemPrompt(isSDK, language, chatId);
+    // SDK providers read memory directly via tools — skip
+    if (isSDK || !userMessage)
+        return base;
+    // Search for relevant memories
+    try {
+        const results = await searchMemory(userMessage, 3, 0.35);
+        if (results.length > 0) {
+            const memorySnippets = results.map(r => {
+                const preview = r.text.length > 400 ? r.text.slice(0, 400) + "..." : r.text;
+                return `[${r.source}] ${preview}`;
+            }).join("\n\n");
+            return base + `\n\n---\n## Relevant Memories (auto-retrieved)\n\n${memorySnippets}`;
+        }
+    }
+    catch {
+        // Embedding search failed — fall back to basic context
+    }
+    return base;
+}
+/**
+ * Get just the SOUL.md content (for /status or debugging).
+ */
+export function getSoulContent() {
+    return soulContent || "(no SOUL.md loaded)";
+}
+/**
+ * Reload SOUL.md from disk (e.g., after editing).
+ */
+export function reloadSoul() {
+    try {
+        soulContent = readFileSync(SOUL_FILE, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}