alvin-bot 4.4.1

package/plugins/finance/index.js

@@ -0,0 +1,254 @@
+/**
+ * Finance Plugin — Stock prices, crypto, and currency conversion.
+ *
+ * Uses free APIs (no key needed):
+ * - Yahoo Finance (via query2.finance.yahoo.com)
+ * - CoinGecko (crypto)
+ * - frankfurter.app (currency conversion)
+ */
+
+const YAHOO_BASE = "https://query2.finance.yahoo.com/v8/finance/chart";
+const COINGECKO_BASE = "https://api.coingecko.com/api/v3";
+const CURRENCY_BASE = "https://api.frankfurter.app";
+
+// Common crypto IDs
+const CRYPTO_MAP = {
+  btc: "bitcoin", bitcoin: "bitcoin",
+  eth: "ethereum", ethereum: "ethereum",
+  sol: "solana", solana: "solana",
+  ada: "cardano", cardano: "cardano",
+  doge: "dogecoin", dogecoin: "dogecoin",
+  xrp: "ripple", ripple: "ripple",
+  dot: "polkadot", polkadot: "polkadot",
+  matic: "matic-network", polygon: "matic-network",
+  link: "chainlink", chainlink: "chainlink",
+  avax: "avalanche-2", avalanche: "avalanche-2",
+};
+
+async function fetchJSON(url, headers = {}) {
+  const res = await fetch(url, {
+    headers: { "User-Agent": "AlvinBot/1.0", ...headers },
+  });
+  if (!res.ok) throw new Error(`HTTP ${res.status}`);
+  return res.json();
+}
+
+async function getStockPrice(symbol) {
+  const data = await fetchJSON(`${YAHOO_BASE}/${encodeURIComponent(symbol)}?interval=1d&range=5d`);
+  const result = data?.chart?.result?.[0];
+  if (!result) throw new Error(`Symbol "${symbol}" not found`);
+
+  const meta = result.meta;
+  const price = meta.regularMarketPrice;
+  const prevClose = meta.chartPreviousClose || meta.previousClose;
+  const change = price - prevClose;
+  const changePct = (change / prevClose * 100);
+  const currency = meta.currency || "USD";
+
+  return {
+    symbol: meta.symbol,
+    name: meta.shortName || meta.symbol,
+    price,
+    change,
+    changePct,
+    currency,
+    exchange: meta.exchangeName,
+    marketState: meta.marketState,
+  };
+}
+
+async function getCryptoPrice(id) {
+  const data = await fetchJSON(
+    `${COINGECKO_BASE}/simple/price?ids=${id}&vs_currencies=usd,eur&include_24hr_change=true&include_market_cap=true`
+  );
+  const coin = data[id];
+  if (!coin) throw new Error(`Crypto "${id}" not found`);
+
+  return {
+    id,
+    usd: coin.usd,
+    eur: coin.eur,
+    change24h: coin.usd_24h_change,
+    marketCapUsd: coin.usd_market_cap,
+  };
+}
+
+async function convertCurrency(amount, from, to) {
+  const data = await fetchJSON(
+    `${CURRENCY_BASE}/latest?amount=${amount}&from=${from.toUpperCase()}&to=${to.toUpperCase()}`
+  );
+  return {
+    amount,
+    from: from.toUpperCase(),
+    to: to.toUpperCase(),
+    result: data.rates?.[to.toUpperCase()],
+    date: data.date,
+  };
+}
+
+function formatNumber(n, decimals = 2) {
+  if (n >= 1e12) return (n / 1e12).toFixed(1) + "T";
+  if (n >= 1e9) return (n / 1e9).toFixed(1) + "B";
+  if (n >= 1e6) return (n / 1e6).toFixed(1) + "M";
+  return n.toLocaleString("de-DE", { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
+}
+
+export default {
+  name: "finance",
+  description: "Stock prices, crypto prices and currency conversion",
+  version: "1.0.0",
+  author: "Alvin Bot",
+
+  commands: [
+    {
+      command: "stock",
+      description: "Get stock price (e.g. /stock AAPL)",
+      handler: async (ctx, args) => {
+        if (!args) {
+          await ctx.reply("📈 Use: `/stock AAPL` or `/stock MSFT GOOGL TSLA`", { parse_mode: "Markdown" });
+          return;
+        }
+
+        const symbols = args.toUpperCase().split(/[\s,]+/).filter(Boolean).slice(0, 5);
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+        const results = [];
+        for (const sym of symbols) {
+          try {
+            const data = await getStockPrice(sym);
+            const arrow = data.change >= 0 ? "📈" : "📉";
+            const sign = data.change >= 0 ? "+" : "";
+            results.push(
+              `${arrow} *${data.symbol}* (${data.name})\n` +
+              `   ${formatNumber(data.price)} ${data.currency} (${sign}${formatNumber(data.change)} / ${sign}${data.changePct.toFixed(2)}%)\n` +
+              `   _${data.exchange} — ${data.marketState}_`
+            );
+          } catch (err) {
+            results.push(`❌ ${sym}: ${err.message}`);
+          }
+        }
+
+        await ctx.reply(results.join("\n\n"), { parse_mode: "Markdown" });
+      },
+    },
+    {
+      command: "crypto",
+      description: "Get crypto price (e.g. /crypto btc)",
+      handler: async (ctx, args) => {
+        if (!args) {
+          await ctx.reply("🪙 Use: `/crypto btc` or `/crypto eth sol doge`", { parse_mode: "Markdown" });
+          return;
+        }
+
+        const coins = args.toLowerCase().split(/[\s,]+/).filter(Boolean).slice(0, 5);
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+        const results = [];
+        for (const coin of coins) {
+          const id = CRYPTO_MAP[coin] || coin;
+          try {
+            const data = await getCryptoPrice(id);
+            const arrow = data.change24h >= 0 ? "📈" : "📉";
+            const sign = data.change24h >= 0 ? "+" : "";
+            results.push(
+              `${arrow} *${id.charAt(0).toUpperCase() + id.slice(1)}*\n` +
+              `   $${formatNumber(data.usd)} / €${formatNumber(data.eur)}\n` +
+              `   24h: ${sign}${data.change24h?.toFixed(2)}% | MCap: $${formatNumber(data.marketCapUsd, 0)}`
+            );
+          } catch (err) {
+            results.push(`❌ ${coin}: ${err.message}`);
+          }
+        }
+
+        await ctx.reply(results.join("\n\n"), { parse_mode: "Markdown" });
+      },
+    },
+    {
+      command: "fx",
+      description: "Convert currency (e.g. /fx 100 USD EUR)",
+      handler: async (ctx, args) => {
+        if (!args) {
+          await ctx.reply("💱 Use: `/fx 100 USD EUR`", { parse_mode: "Markdown" });
+          return;
+        }
+
+        const parts = args.split(/\s+/);
+        if (parts.length < 3) {
+          await ctx.reply("Format: `/fx <amount> <FROM> <TO>`\nExample: `/fx 100 USD EUR`", { parse_mode: "Markdown" });
+          return;
+        }
+
+        const amount = parseFloat(parts[0]);
+        if (isNaN(amount)) {
+          await ctx.reply("❌ Invalid amount.");
+          return;
+        }
+
+        await ctx.api.sendChatAction(ctx.chat.id, "typing");
+
+        try {
+          const data = await convertCurrency(amount, parts[1], parts[2]);
+          if (!data.result) throw new Error("Currency pair not supported");
+          await ctx.reply(
+            `💱 *${formatNumber(data.amount)} ${data.from}* = *${formatNumber(data.result)} ${data.to}*\n` +
+            `_Rate from ${data.date}_`,
+            { parse_mode: "Markdown" }
+          );
+        } catch (err) {
+          await ctx.reply(`❌ ${err.message}`);
+        }
+      },
+    },
+  ],
+
+  tools: [
+    {
+      name: "get_stock_price",
+      description: "Get current stock price for a ticker symbol",
+      parameters: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Ticker symbol (e.g. AAPL, MSFT)" },
+        },
+        required: ["symbol"],
+      },
+      execute: async (params) => {
+        const data = await getStockPrice(params.symbol);
+        return JSON.stringify(data);
+      },
+    },
+    {
+      name: "get_crypto_price",
+      description: "Get current cryptocurrency price",
+      parameters: {
+        type: "object",
+        properties: {
+          coin: { type: "string", description: "Coin name or symbol (e.g. bitcoin, btc, eth)" },
+        },
+        required: ["coin"],
+      },
+      execute: async (params) => {
+        const id = CRYPTO_MAP[params.coin?.toLowerCase()] || params.coin;
+        const data = await getCryptoPrice(id);
+        return JSON.stringify(data);
+      },
+    },
+    {
+      name: "convert_currency",
+      description: "Convert between currencies",
+      parameters: {
+        type: "object",
+        properties: {
+          amount: { type: "number", description: "Amount to convert" },
+          from: { type: "string", description: "Source currency (e.g. USD)" },
+          to: { type: "string", description: "Target currency (e.g. EUR)" },
+        },
+        required: ["amount", "from", "to"],
+      },
+      execute: async (params) => {
+        const data = await convertCurrency(params.amount, params.from, params.to);
+        return JSON.stringify(data);
+      },
+    },
+  ],
+};

package/plugins/notes/index.js

@@ -0,0 +1,227 @@
+/**
+ * Notes Plugin — Simple markdown notes with search.
+ *
+ * Stores notes in docs/notes/ as markdown files.
+ * No external dependencies — pure filesystem.
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const PLUGIN_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
+const NOTES_DIR = path.resolve(PLUGIN_ROOT, "docs", "notes");
+
+// Ensure dir exists
+if (!fs.existsSync(NOTES_DIR)) fs.mkdirSync(NOTES_DIR, { recursive: true });
+
+function slugify(text) {
+  return text
+    .toLowerCase()
+    .replace(/[äöüß]/g, c => ({ ä: "ae", ö: "oe", ü: "ue", ß: "ss" }[c] || c))
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)/g, "")
+    .slice(0, 60);
+}
+
+function listNotes() {
+  try {
+    return fs.readdirSync(NOTES_DIR)
+      .filter(f => f.endsWith(".md"))
+      .map(f => {
+        const content = fs.readFileSync(path.resolve(NOTES_DIR, f), "utf-8");
+        const title = content.split("\n")[0]?.replace(/^#\s*/, "") || f;
+        const stat = fs.statSync(path.resolve(NOTES_DIR, f));
+        return { filename: f, title, size: stat.size, modified: stat.mtimeMs };
+      })
+      .sort((a, b) => b.modified - a.modified);
+  } catch { return []; }
+}
+
+function searchNotes(query) {
+  const q = query.toLowerCase();
+  return listNotes().filter(n => {
+    const content = fs.readFileSync(path.resolve(NOTES_DIR, n.filename), "utf-8").toLowerCase();
+    return content.includes(q) || n.title.toLowerCase().includes(q);
+  });
+}
+
+export default {
+  name: "notes",
+  description: "Create, read and search markdown notes",
+  version: "1.0.0",
+  author: "Alvin Bot",
+
+  commands: [
+    {
+      command: "notes",
+      description: "Manage notes",
+      handler: async (ctx, args) => {
+        // /notes — list all
+        if (!args) {
+          const notes = listNotes();
+          if (notes.length === 0) {
+            await ctx.reply("📝 No notes yet.\nCreate one with `/notes add <Title> | <Content>`", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const lines = notes.slice(0, 20).map((n, i) => {
+            const date = new Date(n.modified).toLocaleDateString("de-DE");
+            return `${i + 1}. *${n.title}* (${date})`;
+          });
+
+          await ctx.reply(`📝 *Notes (${notes.length}):*\n\n${lines.join("\n")}`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /notes add <title> | <content>
+        if (args.startsWith("add ")) {
+          const text = args.slice(4).trim();
+          const pipeIdx = text.indexOf("|");
+          let title, content;
+
+          if (pipeIdx > 0) {
+            title = text.slice(0, pipeIdx).trim();
+            content = text.slice(pipeIdx + 1).trim();
+          } else {
+            title = text.slice(0, 50).trim();
+            content = text;
+          }
+
+          const slug = slugify(title);
+          const filename = `${slug}.md`;
+          const filePath = path.resolve(NOTES_DIR, filename);
+
+          const md = `# ${title}\n\n${content}\n\n---\n_Created: ${new Date().toLocaleString("de-DE")}_\n`;
+          fs.writeFileSync(filePath, md);
+
+          await ctx.reply(`✅ Note saved: *${title}*`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /notes search <query>
+        if (args.startsWith("search ")) {
+          const query = args.slice(7).trim();
+          if (!query) {
+            await ctx.reply("Format: `/notes search <query>`", { parse_mode: "Markdown" });
+            return;
+          }
+
+          const results = searchNotes(query);
+          if (results.length === 0) {
+            await ctx.reply(`🔍 No notes found for "${query}".`);
+            return;
+          }
+
+          const lines = results.slice(0, 10).map((n, i) => `${i + 1}. *${n.title}*`);
+          await ctx.reply(`🔍 *${results.length} results for "${query}":*\n\n${lines.join("\n")}`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /notes view <number or title>
+        if (args.startsWith("view ") || args.startsWith("read ")) {
+          const query = args.split(" ").slice(1).join(" ").trim();
+          const notes = listNotes();
+          const idx = parseInt(query) - 1;
+          let note;
+
+          if (!isNaN(idx) && idx >= 0 && idx < notes.length) {
+            note = notes[idx];
+          } else {
+            note = notes.find(n => n.title.toLowerCase().includes(query.toLowerCase()));
+          }
+
+          if (!note) {
+            await ctx.reply(`❌ Note "${query}" not found.`);
+            return;
+          }
+
+          const content = fs.readFileSync(path.resolve(NOTES_DIR, note.filename), "utf-8");
+          const truncated = content.length > 3000 ? content.slice(0, 3000) + "\n\n_[...truncated]_" : content;
+          await ctx.reply(truncated, { parse_mode: "Markdown" });
+          return;
+        }
+
+        // /notes delete <number>
+        if (args.startsWith("delete ") || args.startsWith("del ")) {
+          const query = args.split(" ").slice(1).join(" ").trim();
+          const notes = listNotes();
+          const idx = parseInt(query) - 1;
+          let note;
+
+          if (!isNaN(idx) && idx >= 0 && idx < notes.length) {
+            note = notes[idx];
+          } else {
+            note = notes.find(n => n.title.toLowerCase().includes(query.toLowerCase()));
+          }
+
+          if (!note) {
+            await ctx.reply(`❌ Note "${query}" not found.`);
+            return;
+          }
+
+          fs.unlinkSync(path.resolve(NOTES_DIR, note.filename));
+          await ctx.reply(`🗑️ Note deleted: *${note.title}*`, { parse_mode: "Markdown" });
+          return;
+        }
+
+        await ctx.reply(
+          "📝 *Notes commands:*\n\n" +
+          "`/notes` — List all\n" +
+          "`/notes add Title | Content` — Create\n" +
+          "`/notes view 1` — Read (number or title)\n" +
+          "`/notes search query` — Search\n" +
+          "`/notes delete 1` — Delete",
+          { parse_mode: "Markdown" }
+        );
+      },
+    },
+  ],
+
+  tools: [
+    {
+      name: "create_note",
+      description: "Create a markdown note",
+      parameters: {
+        type: "object",
+        properties: {
+          title: { type: "string", description: "Note title" },
+          content: { type: "string", description: "Note content (markdown)" },
+        },
+        required: ["title", "content"],
+      },
+      execute: async (params) => {
+        const slug = slugify(params.title);
+        const filename = `${slug}.md`;
+        const filePath = path.resolve(NOTES_DIR, filename);
+        const md = `# ${params.title}\n\n${params.content}\n\n---\n_Created: ${new Date().toLocaleString("de-DE")}_\n`;
+        fs.writeFileSync(filePath, md);
+        return `Note saved: ${filename}`;
+      },
+    },
+    {
+      name: "search_notes",
+      description: "Search through notes",
+      parameters: {
+        type: "object",
+        properties: {
+          query: { type: "string", description: "Search query" },
+        },
+        required: ["query"],
+      },
+      execute: async (params) => {
+        const results = searchNotes(params.query);
+        return JSON.stringify(results.map(r => ({ title: r.title, filename: r.filename })));
+      },
+    },
+    {
+      name: "list_notes",
+      description: "List all notes",
+      parameters: { type: "object", properties: {} },
+      execute: async () => {
+        const notes = listNotes();
+        return JSON.stringify(notes.map(n => ({ title: n.title, modified: new Date(n.modified).toISOString() })));
+      },
+    },
+  ],
+};