alvin-bot 4.4.1

package/dist/providers/types.js

@@ -0,0 +1,205 @@
+/**
+ * Alvin Bot — Multi-Model Provider Abstraction
+ *
+ * Unified interfaces for different LLM backends.
+ * Every provider implements the same interface, making model switching seamless.
+ */
+// ── Provider Presets (common configurations) ────────────
+export const PROVIDER_PRESETS = {
+    // OpenAI (via Codex CLI — full tool use)
+    "codex-cli": {
+        type: "codex-cli",
+        name: "Codex CLI (OpenAI)",
+        model: "gpt-5.4",
+        supportsTools: true,
+        supportsVision: false,
+        supportsStreaming: true,
+    },
+    // Anthropic (via Agent SDK — full tool use)
+    "claude-sdk": {
+        type: "claude-sdk",
+        name: "Claude (Agent SDK)",
+        supportsTools: true,
+        supportsVision: true,
+        supportsStreaming: true,
+    },
+    // Anthropic API (via OpenAI-compatible endpoint — no Agent SDK needed)
+    "claude-opus": {
+        type: "openai-compatible",
+        name: "Claude Opus 4",
+        model: "claude-opus-4-6",
+        baseUrl: "https://api.anthropic.com/v1/",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "claude-sonnet": {
+        type: "openai-compatible",
+        name: "Claude Sonnet 4",
+        model: "claude-sonnet-4-20250514",
+        baseUrl: "https://api.anthropic.com/v1/",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "claude-haiku": {
+        type: "openai-compatible",
+        name: "Claude 3.5 Haiku",
+        model: "claude-3-5-haiku-20241022",
+        baseUrl: "https://api.anthropic.com/v1/",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // Groq (fast inference, free tier, supports function calling)
+    "groq": {
+        type: "openai-compatible",
+        name: "Groq (Llama 3.3 70B)",
+        model: "llama-3.3-70b-versatile",
+        baseUrl: "https://api.groq.com/openai/v1",
+        supportsVision: false,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // OpenAI (supports function calling)
+    "gpt-4o": {
+        type: "openai-compatible",
+        name: "GPT-4o",
+        model: "gpt-4o",
+        baseUrl: "https://api.openai.com/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "gpt-4o-mini": {
+        type: "openai-compatible",
+        name: "GPT-4o Mini",
+        model: "gpt-4o-mini",
+        baseUrl: "https://api.openai.com/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // Google Gemini (via OpenAI-compatible endpoint, supports function calling)
+    "gemini-2.5-pro": {
+        type: "openai-compatible",
+        name: "Gemini 2.5 Pro",
+        model: "gemini-2.5-pro",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "gemini-2.5-flash": {
+        type: "openai-compatible",
+        name: "Gemini 2.5 Flash",
+        model: "gemini-2.5-flash",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "gemini-3-pro": {
+        type: "openai-compatible",
+        name: "Gemini 3 Pro (Preview)",
+        model: "gemini-3-pro-preview",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "gemini-3-flash": {
+        type: "openai-compatible",
+        name: "Gemini 3 Flash (Preview)",
+        model: "gemini-3-flash-preview",
+        baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // OpenAI newer models
+    "gpt-4.1": {
+        type: "openai-compatible",
+        name: "GPT-4.1",
+        model: "gpt-4.1",
+        baseUrl: "https://api.openai.com/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "gpt-4.1-mini": {
+        type: "openai-compatible",
+        name: "GPT-4.1 Mini",
+        model: "gpt-4.1-mini",
+        baseUrl: "https://api.openai.com/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "o3-mini": {
+        type: "openai-compatible",
+        name: "o3 Mini",
+        model: "o3-mini",
+        baseUrl: "https://api.openai.com/v1",
+        supportsVision: false,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // Groq additional models
+    "groq-llama-3.1-8b": {
+        type: "openai-compatible",
+        name: "Llama 3.1 8B (Groq)",
+        model: "llama-3.1-8b-instant",
+        baseUrl: "https://api.groq.com/openai/v1",
+        supportsVision: false,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "groq-mixtral": {
+        type: "openai-compatible",
+        name: "Mixtral 8x7B (Groq)",
+        model: "mixtral-8x7b-32768",
+        baseUrl: "https://api.groq.com/openai/v1",
+        supportsVision: false,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // NVIDIA NIM (150+ free models)
+    "nvidia-llama-3.3-70b": {
+        type: "openai-compatible",
+        name: "Llama 3.3 70B (NVIDIA)",
+        model: "meta/llama-3.3-70b-instruct",
+        baseUrl: "https://integrate.api.nvidia.com/v1",
+        supportsVision: false,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    "nvidia-kimi-k2.5": {
+        type: "openai-compatible",
+        name: "Kimi K2.5 (NVIDIA)",
+        model: "moonshotai/kimi-k2.5",
+        baseUrl: "https://integrate.api.nvidia.com/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+    // Ollama (local models)
+    "ollama": {
+        type: "openai-compatible",
+        name: "Gemma 4 E4B (Ollama)",
+        model: "gemma4:e4b",
+        baseUrl: "http://localhost:11434/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+    },
+    // OpenRouter (any model, one API, supports function calling)
+    "openrouter": {
+        type: "openai-compatible",
+        name: "OpenRouter",
+        model: "anthropic/claude-sonnet-4",
+        baseUrl: "https://openrouter.ai/api/v1",
+        supportsVision: true,
+        supportsStreaming: true,
+        supportsTools: true,
+    },
+};

package/dist/services/access.js

@@ -0,0 +1,144 @@
+/**
+ * Access Control Service — Manages group approvals and security.
+ *
+ * Security model:
+ * - DMs: only ALLOWED_USERS can interact (unchanged)
+ * - Groups: must be explicitly approved by an admin before bot responds
+ * - New groups: bot sends approval request to admin, stays silent until approved
+ * - Admin can block/unblock groups at any time
+ * - Forwarded message processing can be toggled
+ */
+import fs from "fs";
+import { ACCESS_FILE, RUNTIME_DIR } from "../paths.js";
+// Ensure data dir exists
+if (!fs.existsSync(RUNTIME_DIR))
+    fs.mkdirSync(RUNTIME_DIR, { recursive: true });
+let config = {
+    groups: {},
+    settings: {
+        allowForwards: true,
+        autoApproveGroups: false,
+        groupRateLimitPerHour: 30,
+    },
+};
+// Load on startup
+try {
+    const raw = fs.readFileSync(ACCESS_FILE, "utf-8");
+    config = JSON.parse(raw);
+}
+catch {
+    save(); // Create default file
+}
+function save() {
+    fs.writeFileSync(ACCESS_FILE, JSON.stringify(config, null, 2));
+}
+// ── Group Management ─────────────────────────────────
+/**
+ * Check if a group chat is approved.
+ * Returns: "approved" | "pending" | "blocked" | "new"
+ */
+export function getGroupStatus(chatId) {
+    const key = String(chatId);
+    const group = config.groups[key];
+    if (!group)
+        return "new";
+    return group.status;
+}
+/**
+ * Register a new group (first time the bot sees it).
+ * Returns the group info.
+ */
+export function registerGroup(chatId, title, addedBy) {
+    const key = String(chatId);
+    if (config.groups[key]) {
+        // Update title if changed
+        config.groups[key].title = title;
+        save();
+        return config.groups[key];
+    }
+    const group = {
+        chatId,
+        title,
+        addedBy,
+        firstSeen: Date.now(),
+        status: config.settings.autoApproveGroups ? "approved" : "pending",
+        statusChanged: Date.now(),
+        messageCount: 0,
+    };
+    config.groups[key] = group;
+    save();
+    return group;
+}
+/**
+ * Approve a group.
+ */
+export function approveGroup(chatId) {
+    const key = String(chatId);
+    const group = config.groups[key];
+    if (!group)
+        return false;
+    group.status = "approved";
+    group.statusChanged = Date.now();
+    save();
+    return true;
+}
+/**
+ * Block a group.
+ */
+export function blockGroup(chatId) {
+    const key = String(chatId);
+    const group = config.groups[key];
+    if (!group)
+        return false;
+    group.status = "blocked";
+    group.statusChanged = Date.now();
+    save();
+    return true;
+}
+/**
+ * Increment message count for a group.
+ */
+export function trackGroupMessage(chatId) {
+    const key = String(chatId);
+    if (config.groups[key]) {
+        config.groups[key].messageCount++;
+        // Save periodically (every 10 messages to reduce I/O)
+        if (config.groups[key].messageCount % 10 === 0)
+            save();
+    }
+}
+/**
+ * Get all groups.
+ */
+export function listGroups() {
+    return Object.values(config.groups).sort((a, b) => b.firstSeen - a.firstSeen);
+}
+/**
+ * Remove a group from tracking.
+ */
+export function removeGroup(chatId) {
+    const key = String(chatId);
+    if (!config.groups[key])
+        return false;
+    delete config.groups[key];
+    save();
+    return true;
+}
+// ── Settings ─────────────────────────────────────────
+export function isForwardingAllowed() {
+    return config.settings.allowForwards;
+}
+export function setForwardingAllowed(allowed) {
+    config.settings.allowForwards = allowed;
+    save();
+}
+export function isAutoApproveEnabled() {
+    return config.settings.autoApproveGroups;
+}
+export function setAutoApprove(enabled) {
+    config.settings.autoApproveGroups = enabled;
+    save();
+}
+export function getSettings() {
+    return { ...config.settings };
+}

package/dist/services/asset-index.js

@@ -0,0 +1,230 @@
+/**
+ * Asset Index — Scans ~/.alvin-bot/assets/ and builds a searchable registry.
+ *
+ * Produces:
+ * - INDEX.json — machine-readable, used by self-search and skill injection
+ * - INDEX.md — human-readable, injected into prompts for asset awareness
+ *
+ * Scan is filesystem-only (<5ms for ~60 files). No API calls.
+ * Re-scans only when ASSETS_DIR has changed since last scan.
+ */
+import fs from "fs";
+import path from "path";
+import { ASSETS_DIR, ASSETS_INDEX_JSON, ASSETS_INDEX_MD } from "../paths.js";
+// ── Cache ───────────────────────────────────────────────
+let cachedIndex = null;
+// ── Helpers ─────────────────────────────────────────────
+/**
+ * Walk a directory recursively, yielding file entries.
+ */
+function walkDir(dir) {
+    const results = [];
+    function walk(currentDir) {
+        let entries;
+        try {
+            entries = fs.readdirSync(currentDir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const fullPath = path.resolve(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.isFile()) {
+                // Skip INDEX.json and INDEX.md at ASSETS_DIR root
+                if (currentDir === dir && (entry.name === "INDEX.json" || entry.name === "INDEX.md")) {
+                    continue;
+                }
+                results.push({
+                    name: entry.name,
+                    path: fullPath,
+                    relativePath: path.relative(dir, fullPath),
+                });
+            }
+        }
+    }
+    walk(dir);
+    return results;
+}
+/**
+ * Generate a human-readable description from a filename.
+ * "acme-cover-letter.html" → "Cover Letter: Acme"
+ * "profile-photo.jpeg" → "Profile Photo"
+ */
+function descriptionFromFilename(filename, category) {
+    const name = filename.replace(/\.[^.]+$/, ""); // strip extension
+    const words = name.replace(/[-_]/g, " ").trim();
+    // Special handling for known patterns
+    if (category === "cover-letters") {
+        const company = words.replace(/cover letter/i, "").replace(/^Cover_Letter_[A-Za-z_]+_/i, "").trim();
+        return `Cover Letter: ${company || words}`;
+    }
+    if (category === "cv-templates") {
+        return `CV Template: ${words}`;
+    }
+    // Default: capitalize words
+    return words.replace(/\b\w/g, c => c.toUpperCase());
+}
+/**
+ * Determine category for a file.
+ * Files in subdirectories get the directory name as category.
+ * Root-level files get a special category based on naming.
+ */
+function categorize(relativePath) {
+    const parts = relativePath.split(path.sep);
+    if (parts.length > 1) {
+        return parts[0]; // directory name
+    }
+    // Root-level file — categorize by pattern
+    const filename = parts[0].toLowerCase();
+    if (filename.includes("signature"))
+        return "signatures";
+    return "misc";
+}
+// ── Public API ──────────────────────────────────────────
+/**
+ * Scan ASSETS_DIR and write INDEX.json + INDEX.md.
+ * Only re-scans if directory has changed since last scan.
+ * Returns the asset index.
+ */
+export function scanAssets() {
+    if (!fs.existsSync(ASSETS_DIR)) {
+        const empty = { lastScan: new Date().toISOString(), assets: [] };
+        cachedIndex = empty;
+        return empty;
+    }
+    // Check if re-scan needed
+    if (fs.existsSync(ASSETS_INDEX_JSON)) {
+        try {
+            const existing = JSON.parse(fs.readFileSync(ASSETS_INDEX_JSON, "utf-8"));
+            const dirStat = fs.statSync(ASSETS_DIR);
+            const lastScanTime = new Date(existing.lastScan).getTime();
+            // Also check subdirectory mtimes (adding a file to a subdir changes subdir mtime, not parent)
+            let newestMtime = dirStat.mtimeMs;
+            try {
+                const subdirs = fs.readdirSync(ASSETS_DIR, { withFileTypes: true });
+                for (const d of subdirs) {
+                    if (d.isDirectory()) {
+                        const subStat = fs.statSync(path.resolve(ASSETS_DIR, d.name));
+                        if (subStat.mtimeMs > newestMtime)
+                            newestMtime = subStat.mtimeMs;
+                    }
+                }
+            }
+            catch { /* ignore */ }
+            if (newestMtime <= lastScanTime) {
+                cachedIndex = existing;
+                return existing;
+            }
+        }
+        catch {
+            // Corrupted index — re-scan
+        }
+    }
+    // Full scan
+    const files = walkDir(ASSETS_DIR);
+    const assets = [];
+    for (const file of files) {
+        try {
+            const stat = fs.statSync(file.path);
+            const category = categorize(file.relativePath);
+            assets.push({
+                path: file.relativePath,
+                absolutePath: file.path,
+                category,
+                filename: file.name,
+                ext: path.extname(file.name),
+                size: stat.size,
+                modified: new Date(stat.mtimeMs).toISOString(),
+                description: descriptionFromFilename(file.name, category),
+            });
+        }
+        catch {
+            // File disappeared between readdir and stat — skip
+        }
+    }
+    // Sort by category then filename
+    assets.sort((a, b) => a.category.localeCompare(b.category) || a.filename.localeCompare(b.filename));
+    const index = {
+        lastScan: new Date().toISOString(),
+        assets,
+    };
+    // Write INDEX.json
+    fs.writeFileSync(ASSETS_INDEX_JSON, JSON.stringify(index, null, 2));
+    // Write INDEX.md
+    const md = generateIndexMd(index);
+    fs.writeFileSync(ASSETS_INDEX_MD, md);
+    cachedIndex = index;
+    return index;
+}
+/**
+ * Load asset index from disk (cached after first call).
+ */
+export function loadAssetIndex() {
+    if (cachedIndex)
+        return cachedIndex;
+    if (fs.existsSync(ASSETS_INDEX_JSON)) {
+        try {
+            cachedIndex = JSON.parse(fs.readFileSync(ASSETS_INDEX_JSON, "utf-8"));
+            return cachedIndex;
+        }
+        catch { /* fall through */ }
+    }
+    // No index — run scan
+    return scanAssets();
+}
+/**
+ * Get INDEX.md content for prompt injection.
+ */
+export function getAssetIndexMd() {
+    if (fs.existsSync(ASSETS_INDEX_MD)) {
+        return fs.readFileSync(ASSETS_INDEX_MD, "utf-8");
+    }
+    return "";
+}
+/**
+ * Find assets by category name.
+ */
+export function findAssetsByCategory(category) {
+    const index = loadAssetIndex();
+    return index.assets.filter(a => a.category === category);
+}
+/**
+ * Find assets by keyword match on filename, category, or description.
+ */
+export function findAssetsByKeyword(keywords) {
+    const index = loadAssetIndex();
+    const lower = keywords.map(k => k.toLowerCase());
+    return index.assets.filter(a => lower.some(k => a.filename.toLowerCase().includes(k) ||
+        a.category.toLowerCase().includes(k) ||
+        a.description.toLowerCase().includes(k)));
+}
+// ── INDEX.md Generator ──────────────────────────────────
+function generateIndexMd(index) {
+    const date = new Date().toISOString().slice(0, 10);
+    const lines = [`## Your Assets (~/.alvin-bot/assets/) — ${date}\n`];
+    // Group by category
+    const byCategory = new Map();
+    for (const a of index.assets) {
+        const list = byCategory.get(a.category) || [];
+        list.push(a);
+        byCategory.set(a.category, list);
+    }
+    // Sort categories alphabetically
+    const sortedCategories = [...byCategory.keys()].sort();
+    for (const cat of sortedCategories) {
+        const assets = byCategory.get(cat);
+        const names = assets.map(a => a.filename);
+        // Compact display: show up to 6 names, then "..."
+        const display = names.length > 6
+            ? names.slice(0, 5).join(", ") + `, ... (+${names.length - 5} more)`
+            : names.join(", ");
+        lines.push(`- **${cat}/** (${assets.length}): ${display}`);
+    }
+    const totalSize = index.assets.reduce((sum, a) => sum + a.size, 0);
+    const sizeMB = (totalSize / 1_048_576).toFixed(1);
+    lines.push(`\nTotal: ${index.assets.length} files, ${sizeMB} MB`);
+    return lines.join("\n") + "\n";
+}