alvin-bot 4.4.1

package/dist/services/usage-tracker.js

@@ -0,0 +1,137 @@
+/**
+ * Usage Tracker — Persistent daily/weekly usage stats.
+ *
+ * Tracks token counts, costs, and query counts per provider per day.
+ * Persists to ~/.alvin-bot/usage.json. Calculates daily/weekly summaries.
+ *
+ * Also stores the last-seen rate limit headers from providers (in-memory only).
+ */
+import fs from "fs";
+import path from "path";
+import { DATA_DIR } from "../paths.js";
+const USAGE_FILE = path.join(DATA_DIR, "usage.json");
+// ── State ────────────────────────────────────────────────────────────
+/** Last-seen rate limit info per provider (in-memory, not persisted) */
+const rateLimits = new Map();
+// ── Persistence ──────────────────────────────────────────────────────
+function loadUsage() {
+    try {
+        return JSON.parse(fs.readFileSync(USAGE_FILE, "utf-8"));
+    }
+    catch {
+        return { daily: {} };
+    }
+}
+function saveUsage(data) {
+    // Prune entries older than 90 days
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - 90);
+    const cutoffStr = cutoff.toISOString().slice(0, 10);
+    for (const key of Object.keys(data.daily)) {
+        if (key < cutoffStr)
+            delete data.daily[key];
+    }
+    fs.writeFileSync(USAGE_FILE, JSON.stringify(data, null, 2));
+}
+function todayKey() {
+    return new Date().toISOString().slice(0, 10);
+}
+// ── Public API ───────────────────────────────────────────────────────
+/** Record a completed query's usage. Called after each provider response. */
+export function trackUsage(providerKey, inputTokens, outputTokens, costUsd) {
+    const data = loadUsage();
+    const key = todayKey();
+    if (!data.daily[key]) {
+        data.daily[key] = { queries: 0, inputTokens: 0, outputTokens: 0, costUsd: 0, byProvider: {} };
+    }
+    const day = data.daily[key];
+    day.queries++;
+    day.inputTokens += inputTokens;
+    day.outputTokens += outputTokens;
+    day.costUsd += costUsd;
+    if (!day.byProvider[providerKey]) {
+        day.byProvider[providerKey] = { queries: 0, inputTokens: 0, outputTokens: 0, costUsd: 0 };
+    }
+    const prov = day.byProvider[providerKey];
+    prov.queries++;
+    prov.inputTokens += inputTokens;
+    prov.outputTokens += outputTokens;
+    prov.costUsd += costUsd;
+    saveUsage(data);
+}
+/** Get usage summary (today + last 7 days). */
+export function getUsageSummary() {
+    const data = loadUsage();
+    const today = todayKey();
+    const emptyDay = { queries: 0, inputTokens: 0, outputTokens: 0, costUsd: 0, byProvider: {} };
+    const todayStats = data.daily[today] || emptyDay;
+    // Week = last 7 days including today
+    const weekStats = { queries: 0, inputTokens: 0, outputTokens: 0, costUsd: 0, byProvider: {} };
+    const now = new Date();
+    let daysWithData = 0;
+    for (let i = 0; i < 7; i++) {
+        const d = new Date(now);
+        d.setDate(d.getDate() - i);
+        const key = d.toISOString().slice(0, 10);
+        const day = data.daily[key];
+        if (day) {
+            daysWithData++;
+            weekStats.queries += day.queries;
+            weekStats.inputTokens += day.inputTokens;
+            weekStats.outputTokens += day.outputTokens;
+            weekStats.costUsd += day.costUsd;
+            for (const [pk, ps] of Object.entries(day.byProvider)) {
+                if (!weekStats.byProvider[pk]) {
+                    weekStats.byProvider[pk] = { queries: 0, inputTokens: 0, outputTokens: 0, costUsd: 0 };
+                }
+                weekStats.byProvider[pk].queries += ps.queries;
+                weekStats.byProvider[pk].inputTokens += ps.inputTokens;
+                weekStats.byProvider[pk].outputTokens += ps.outputTokens;
+                weekStats.byProvider[pk].costUsd += ps.costUsd;
+            }
+        }
+    }
+    const totalDays = Object.keys(data.daily).length;
+    const allTokens = Object.values(data.daily).reduce((s, d) => s + d.inputTokens + d.outputTokens, 0);
+    const allCost = Object.values(data.daily).reduce((s, d) => s + d.costUsd, 0);
+    return {
+        today: todayStats,
+        week: weekStats,
+        daysTracked: totalDays,
+        avgDailyTokens: totalDays > 0 ? Math.round(allTokens / totalDays) : 0,
+        avgDailyCost: totalDays > 0 ? allCost / totalDays : 0,
+    };
+}
+/** Store rate limit info from provider response headers. */
+export function updateRateLimits(providerKey, info) {
+    rateLimits.set(providerKey, { ...info, updatedAt: Date.now() });
+}
+/** Get last-seen rate limits for a provider. Returns null if no data or stale (>5min). */
+export function getRateLimits(providerKey) {
+    const info = rateLimits.get(providerKey);
+    if (!info)
+        return null;
+    // Stale after 5 minutes
+    if (Date.now() - info.updatedAt > 300_000)
+        return null;
+    return info;
+}
+/** Get all non-stale rate limits. */
+export function getAllRateLimits() {
+    const result = new Map();
+    const now = Date.now();
+    for (const [key, info] of rateLimits) {
+        if (now - info.updatedAt < 300_000) {
+            result.set(key, info);
+        }
+    }
+    return result;
+}
+/** Format token count for display (e.g., 45200 → "45.2K") */
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}K`;
+    return String(n);
+}

package/dist/services/users.js

@@ -0,0 +1,199 @@
+/**
+ * User Profiles Service — Multi-user support with per-user settings and memory.
+ *
+ * Each user gets:
+ * - Their own memory directory (docs/users/<userId>/)
+ * - A profile with preferences (language, effort, voice, personality)
+ * - Separate conversation context
+ *
+ * The admin/owner user uses the global docs/memory/ and docs/MEMORY.md.
+ * Additional users get isolated memory spaces.
+ */
+import fs from "fs";
+import { resolve } from "path";
+import { config } from "../config.js";
+import { killSession } from "./session.js";
+import { USERS_DIR, MEMORY_DIR } from "../paths.js";
+// Ensure users dir exists
+if (!fs.existsSync(USERS_DIR))
+    fs.mkdirSync(USERS_DIR, { recursive: true });
+// ── Profile Management ──────────────────────────────────
+function profilePath(userId) {
+    return resolve(USERS_DIR, `${userId}.json`);
+}
+function userMemoryDir(userId) {
+    return resolve(USERS_DIR, `${userId}`);
+}
+/**
+ * Load a user profile. Returns null if not found.
+ */
+export function loadProfile(userId) {
+    try {
+        const raw = fs.readFileSync(profilePath(userId), "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save a user profile.
+ */
+export function saveProfile(profile) {
+    fs.writeFileSync(profilePath(profile.userId), JSON.stringify(profile, null, 2));
+}
+/**
+ * Get or create a user profile.
+ * Auto-creates on first interaction.
+ */
+export function getOrCreateProfile(userId, name, username) {
+    let profile = loadProfile(userId);
+    if (!profile) {
+        const isOwner = config.allowedUsers.length > 0 && config.allowedUsers[0] === userId;
+        profile = {
+            userId,
+            name: name || `User ${userId}`,
+            username,
+            firstSeen: Date.now(),
+            lastActive: Date.now(),
+            totalMessages: 0,
+            language: "en",
+            isOwner,
+            notes: "",
+            langStats: { de: 0, en: 0, other: 0 },
+            langExplicit: false,
+        };
+        // Create user memory directory for non-owner users
+        if (!isOwner) {
+            const memDir = userMemoryDir(userId);
+            if (!fs.existsSync(memDir))
+                fs.mkdirSync(memDir, { recursive: true });
+        }
+        saveProfile(profile);
+    }
+    return profile;
+}
+/**
+ * Update a user's activity (call on each message).
+ */
+export function touchProfile(userId, name, username, platform, messageText) {
+    const profile = getOrCreateProfile(userId, name, username);
+    profile.lastActive = Date.now();
+    profile.totalMessages++;
+    if (name)
+        profile.name = name;
+    if (username)
+        profile.username = username;
+    if (platform)
+        profile.lastPlatform = platform;
+    if (messageText) {
+        profile.lastMessage = messageText.length > 120 ? messageText.slice(0, 120) + "…" : messageText;
+        profile.lastMessageAt = Date.now();
+    }
+    saveProfile(profile);
+    return profile;
+}
+/**
+ * List all known user profiles.
+ */
+export function listProfiles() {
+    const profiles = [];
+    try {
+        const files = fs.readdirSync(USERS_DIR);
+        for (const file of files) {
+            if (file.endsWith(".json")) {
+                try {
+                    const raw = fs.readFileSync(resolve(USERS_DIR, file), "utf-8");
+                    profiles.push(JSON.parse(raw));
+                }
+                catch { /* skip corrupt */ }
+            }
+        }
+    }
+    catch { /* dir doesn't exist */ }
+    return profiles.sort((a, b) => b.lastActive - a.lastActive);
+}
+/**
+ * Get user-specific memory directory.
+ * Owner uses global memory, others get isolated dirs.
+ */
+export function getUserMemoryDir(userId) {
+    const profile = loadProfile(userId);
+    if (profile?.isOwner) {
+        return MEMORY_DIR;
+    }
+    const dir = userMemoryDir(userId);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    return dir;
+}
+/**
+ * Add a note to a user's profile (for AI context).
+ */
+export function addUserNote(userId, note) {
+    const profile = getOrCreateProfile(userId);
+    const timestamp = new Date().toISOString().slice(0, 16);
+    profile.notes += `\n[${timestamp}] ${note}`;
+    profile.notes = profile.notes.trim();
+    saveProfile(profile);
+}
+/**
+ * Delete a user and all their data: profile, session, memory, conversation history.
+ * Returns a summary of what was deleted.
+ */
+export function deleteUser(userId) {
+    const deleted = [];
+    const errors = [];
+    // 1. Delete profile JSON
+    const pPath = profilePath(userId);
+    try {
+        if (fs.existsSync(pPath)) {
+            fs.unlinkSync(pPath);
+            deleted.push("Profile");
+        }
+    }
+    catch (e) {
+        errors.push(`Profile: ${e}`);
+    }
+    // 2. Delete user memory directory (non-owner only)
+    const memDir = userMemoryDir(userId);
+    try {
+        if (fs.existsSync(memDir) && fs.statSync(memDir).isDirectory()) {
+            fs.rmSync(memDir, { recursive: true, force: true });
+            deleted.push("Memory directory");
+        }
+    }
+    catch (e) {
+        errors.push(`Memory: ${e}`);
+    }
+    // 3. Kill active session
+    try {
+        const result = killSession(userId);
+        if (result.hadSession) {
+            deleted.push("Session deleted");
+            if (result.aborted) {
+                deleted.push("Running request aborted");
+            }
+        }
+    }
+    catch (e) {
+        errors.push(`Session: ${e}`);
+    }
+    return { deleted, errors };
+}
+/**
+ * Build user context string for system prompt injection.
+ */
+export function buildUserContext(userId) {
+    const profile = loadProfile(userId);
+    if (!profile)
+        return "";
+    const parts = [];
+    parts.push(`User: ${profile.name}${profile.username ? ` (@${profile.username})` : ""}`);
+    parts.push(`Language: ${profile.language === "de" ? "Deutsch" : "English"}`);
+    parts.push(`Messages: ${profile.totalMessages}`);
+    if (profile.notes) {
+        parts.push(`\nNotes about this user:\n${profile.notes}`);
+    }
+    return parts.join("\n");
+}

package/dist/services/voice.js

@@ -0,0 +1,95 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import https from "https";
+import { EdgeTTS } from "node-edge-tts";
+import { config } from "../config.js";
+const TEMP_DIR = path.join(os.tmpdir(), "alvin-bot");
+if (!fs.existsSync(TEMP_DIR)) {
+    fs.mkdirSync(TEMP_DIR, { recursive: true });
+}
+// ── Speech-to-Text (Groq Whisper) ──────────────────────
+export async function transcribeAudio(audioPath) {
+    const fileBuffer = fs.readFileSync(audioPath);
+    const boundary = "----FormBoundary" + Math.random().toString(36).slice(2);
+    const fileName = path.basename(audioPath);
+    let body = "";
+    body += `--${boundary}\r\n`;
+    body += `Content-Disposition: form-data; name="file"; filename="${fileName}"\r\n`;
+    body += `Content-Type: audio/ogg\r\n\r\n`;
+    const bodyStart = Buffer.from(body, "utf-8");
+    const bodyEnd = Buffer.from(`\r\n--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="model"\r\n\r\n` +
+        `whisper-large-v3-turbo\r\n` +
+        `--${boundary}\r\n` +
+        `Content-Disposition: form-data; name="language"\r\n\r\n` +
+        `de\r\n` +
+        `--${boundary}--\r\n`, "utf-8");
+    const fullBody = Buffer.concat([bodyStart, fileBuffer, bodyEnd]);
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            hostname: "api.groq.com",
+            path: "/openai/v1/audio/transcriptions",
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${config.apiKeys.groq}`,
+                "Content-Type": `multipart/form-data; boundary=${boundary}`,
+                "Content-Length": fullBody.length,
+            },
+        }, (res) => {
+            let data = "";
+            res.on("data", (chunk) => (data += chunk));
+            res.on("end", () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.text || "");
+                }
+                catch {
+                    reject(new Error(`Groq STT error: ${data}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(fullBody);
+        req.end();
+    });
+}
+// ── Text-to-Speech (Edge TTS via node-edge-tts) ────────
+export async function textToSpeech(text) {
+    // Strip markdown formatting for cleaner TTS
+    let cleanText = text
+        .replace(/```[\s\S]*?```/g, " Code block skipped. ")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/#{1,6}\s/g, "")
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/\n{2,}/g, ". ")
+        .replace(/\n/g, " ")
+        .trim();
+    if (!cleanText) {
+        throw new Error("No text available for TTS");
+    }
+    if (cleanText.length > 3000) {
+        cleanText = cleanText.slice(0, 3000) + "... Text truncated.";
+    }
+    // Try ElevenLabs if configured
+    if (config.ttsProvider === "elevenlabs" && config.elevenlabs.apiKey) {
+        try {
+            const { elevenLabsTTS } = await import("./elevenlabs.js");
+            return await elevenLabsTTS(cleanText);
+        }
+        catch (err) {
+            console.warn("ElevenLabs TTS failed, falling back to Edge TTS:", err instanceof Error ? err.message : err);
+        }
+    }
+    // Edge TTS (default / fallback)
+    const outputPath = path.join(TEMP_DIR, `tts_${Date.now()}.mp3`);
+    const tts = new EdgeTTS({
+        voice: "de-DE-ConradNeural",
+        lang: "de-DE",
+        outputFormat: "audio-24khz-48kbitrate-mono-mp3",
+    });
+    await tts.ttsPromise(cleanText, outputPath);
+    return outputPath;
+}