alvin-bot 4.4.1

package/dist/services/skills.js

@@ -0,0 +1,287 @@
+/**
+ * Skill System — Specialized knowledge for complex tasks.
+ *
+ * Skills are SKILL.md files in the skills/ directory that provide
+ * domain-specific instructions, workflows, and best practices.
+ *
+ * When a user message matches a skill's triggers, the skill's content
+ * is injected into the system prompt — giving the agent deep expertise
+ * for that specific task type.
+ *
+ * Philosophy: A generalist agent with specialist knowledge on demand.
+ *
+ * Features:
+ * - Bundled skills (skills/ in repo) + User skills (~/.alvin-bot/skills/)
+ * - User skills override bundled skills with the same ID
+ * - Hot-reload via fs.watch() on both directories
+ * - Self-modification via createSkill()
+ */
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, watch } from "fs";
+import { resolve } from "path";
+import { SKILLS_DIR } from "../paths.js";
+import { USER_SKILLS_DIR } from "../paths.js";
+import { loadAssetIndex } from "./asset-index.js";
+// ── Skill Registry ──────────────────────────────────────
+let cachedSkills = [];
+let lastScanAt = 0;
+/**
+ * Parse SKILL.md frontmatter (simple YAML-like header).
+ *
+ * Format:
+ * ---
+ * name: Video Creation
+ * description: Create videos with Remotion
+ * triggers: video, remotion, animation, render
+ * priority: 5
+ * category: media
+ * ---
+ * (rest is the skill content)
+ */
+function parseSkillFile(id, content, source) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+    if (!fmMatch) {
+        // No frontmatter — treat entire file as content with defaults
+        return {
+            id,
+            name: id.replace(/-/g, " ").replace(/\b\w/g, c => c.toUpperCase()),
+            description: "",
+            triggers: [id.replace(/-/g, " ")],
+            content: content.trim(),
+            priority: 1,
+            category: "general",
+            source,
+        };
+    }
+    const frontmatter = fmMatch[1];
+    const body = fmMatch[2].trim();
+    function getField(key) {
+        const match = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+        return match ? match[1].trim() : "";
+    }
+    const name = getField("name") || id;
+    const description = getField("description") || "";
+    const triggersRaw = getField("triggers") || id;
+    const priority = parseInt(getField("priority")) || 1;
+    const category = getField("category") || "general";
+    const assetCategoriesRaw = getField("assetCategories");
+    const assetCategories = assetCategoriesRaw
+        ? assetCategoriesRaw.replace(/[\[\]]/g, "").split(",").map(s => s.trim()).filter(Boolean)
+        : undefined;
+    const triggers = triggersRaw
+        .split(",")
+        .map(t => t.trim().toLowerCase())
+        .filter(Boolean);
+    return { id, name, description, triggers, content: body, priority, category, source, assetCategories };
+}
+/**
+ * Scan a single skills directory and return all parsed skills.
+ */
+function scanDirectory(dir, source) {
+    if (!existsSync(dir))
+        return [];
+    const skills = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            const skillFile = resolve(dir, entry.name, "SKILL.md");
+            if (existsSync(skillFile)) {
+                try {
+                    const content = readFileSync(skillFile, "utf-8");
+                    const skill = parseSkillFile(entry.name, content, source);
+                    if (skill)
+                        skills.push(skill);
+                }
+                catch (err) {
+                    console.warn(`\u26a0\ufe0f Failed to load skill ${entry.name}:`, err);
+                }
+            }
+        }
+        // Also support flat .md files in skills/
+        if (entry.isFile() && entry.name.endsWith(".md")) {
+            const id = entry.name.replace(/\.md$/, "");
+            try {
+                const content = readFileSync(resolve(dir, entry.name), "utf-8");
+                const skill = parseSkillFile(id, content, source);
+                if (skill)
+                    skills.push(skill);
+            }
+            catch (err) {
+                console.warn(`\u26a0\ufe0f Failed to load skill ${id}:`, err);
+            }
+        }
+    }
+    return skills;
+}
+/**
+ * Reload all skills from both directories.
+ * User skills override bundled skills with the same ID.
+ */
+function reloadAllSkills() {
+    // Ensure bundled directory exists
+    if (!existsSync(SKILLS_DIR)) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+    const bundled = scanDirectory(SKILLS_DIR, "bundled");
+    const user = scanDirectory(USER_SKILLS_DIR, "user");
+    // Merge: user skills override bundled skills with same ID
+    const skillMap = new Map();
+    for (const s of bundled)
+        skillMap.set(s.id, s);
+    for (const s of user)
+        skillMap.set(s.id, s); // override
+    cachedSkills = [...skillMap.values()];
+    lastScanAt = Date.now();
+    if (cachedSkills.length > 0) {
+        const bundledCount = cachedSkills.filter(s => s.source === "bundled").length;
+        const userCount = cachedSkills.filter(s => s.source === "user").length;
+        console.log(`\ud83c\udfaf Skills loaded: ${cachedSkills.length} (${bundledCount} bundled, ${userCount} user) — ${cachedSkills.map(s => s.name).join(", ")}`);
+    }
+}
+/**
+ * Scan both skills directories and load all SKILL.md files.
+ * Sets up fs.watch() for hot-reload on both directories.
+ */
+export function loadSkills() {
+    reloadAllSkills();
+    // Hot-reload watchers
+    try {
+        watch(SKILLS_DIR, { recursive: true }, () => {
+            console.log("Skills changed (bundled) \u2014 reloading");
+            reloadAllSkills();
+        });
+    }
+    catch { }
+    try {
+        if (existsSync(USER_SKILLS_DIR)) {
+            watch(USER_SKILLS_DIR, { recursive: true }, () => {
+                console.log("Skills changed (user) \u2014 reloading");
+                reloadAllSkills();
+            });
+        }
+    }
+    catch { }
+    return cachedSkills;
+}
+/**
+ * Get all loaded skills.
+ */
+export function getSkills() {
+    if (cachedSkills.length === 0 || Date.now() - lastScanAt > 300_000) {
+        reloadAllSkills();
+    }
+    return cachedSkills;
+}
+/**
+ * Find a skill by its ID.
+ */
+export function getSkillById(id) {
+    return cachedSkills.find(s => s.id === id);
+}
+/**
+ * Create or update a user skill (self-modification).
+ * Writes to USER_SKILLS_DIR and triggers reload.
+ */
+export function createSkill(id, content) {
+    const dir = resolve(USER_SKILLS_DIR, id);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    writeFileSync(resolve(dir, "SKILL.md"), content);
+    // Trigger reload
+    reloadAllSkills();
+    return true;
+}
+/**
+ * Find skills that match a user message.
+ * Returns matched skills sorted by priority (highest first).
+ */
+export function matchSkills(userMessage, maxResults = 2) {
+    const skills = getSkills();
+    if (skills.length === 0)
+        return [];
+    const msgLower = userMessage.toLowerCase();
+    const words = msgLower.split(/[\s,.!?;:()[\]{}'"]+/).filter(w => w.length >= 2);
+    const wordSet = new Set(words);
+    const scored = [];
+    for (const skill of skills) {
+        let score = 0;
+        for (const trigger of skill.triggers) {
+            // Exact phrase match (strongest signal)
+            if (msgLower.includes(trigger)) {
+                score += trigger.split(" ").length * 3; // multi-word triggers score higher
+            }
+            // Single-word trigger match
+            else if (trigger.split(" ").length === 1 && wordSet.has(trigger)) {
+                score += 1;
+            }
+        }
+        if (score > 0) {
+            scored.push({ skill, score: score * skill.priority });
+        }
+    }
+    return scored
+        .sort((a, b) => b.score - a.score)
+        .slice(0, maxResults)
+        .map(s => s.skill);
+}
+// ── Skill-Asset Mapping ────────────────────────────────
+/** Default mapping for skills that don't declare assetCategories in frontmatter. */
+const SKILL_ASSET_MAP = {
+    "job-apply": ["cover-letters", "cv-templates", "photos"],
+    "cv-update": ["cv-templates", "photos"],
+    "cover-letter": ["cover-letters", "cv-templates"],
+    "formal-letter": ["legal", "cv-templates"],
+};
+/**
+ * Find assets relevant to a skill.
+ * Uses frontmatter assetCategories if declared, otherwise falls back to static map.
+ */
+function findAssetsForSkill(skill) {
+    const categories = skill.assetCategories || SKILL_ASSET_MAP[skill.id];
+    if (!categories || categories.length === 0)
+        return [];
+    const index = loadAssetIndex();
+    return index.assets.filter(a => categories.includes(a.category));
+}
+/**
+ * Build a skill injection block for the system prompt.
+ * Includes matched skill content + relevant asset references.
+ */
+export function buildSkillContext(userMessage) {
+    const matched = matchSkills(userMessage, 1); // inject top 1 skill only
+    if (matched.length === 0)
+        return "";
+    const skill = matched[0];
+    let context = `\n\n## 🎯 Active Skill: ${skill.name}\n\n${skill.content}`;
+    // Inject relevant assets for this skill
+    const assets = findAssetsForSkill(skill);
+    if (assets.length > 0) {
+        context += `\n\n### 📂 Relevant Assets\n`;
+        for (const a of assets) {
+            context += `- ${a.category}/${a.filename} → \`${a.absolutePath}\`\n`;
+        }
+    }
+    return context;
+}
+/**
+ * Get a summary of all available skills (for /skills command or status).
+ */
+export function getSkillsSummary() {
+    const skills = getSkills();
+    if (skills.length === 0)
+        return "No skills installed.";
+    const byCategory = new Map();
+    for (const s of skills) {
+        const list = byCategory.get(s.category) || [];
+        list.push(s);
+        byCategory.set(s.category, list);
+    }
+    const lines = [`\ud83c\udfaf **Skills (${skills.length}):**\n`];
+    for (const [cat, list] of byCategory) {
+        lines.push(`**${cat}:**`);
+        for (const s of list) {
+            const badge = s.source === "user" ? " \ud83d\udc64" : "";
+            lines.push(`  \u2022 ${s.name}${badge} \u2014 ${s.description || "(no description)"}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/services/standing-orders.js

@@ -0,0 +1,29 @@
+import { readFileSync, existsSync } from "fs";
+import { AGENTS_FILE } from "../paths.js";
+let cached = "";
+/** Load standing orders from AGENTS.md. Called once at startup and on reload. */
+export function loadStandingOrders() {
+    if (!existsSync(AGENTS_FILE))
+        return "";
+    try {
+        cached = readFileSync(AGENTS_FILE, "utf-8");
+        return cached;
+    }
+    catch {
+        return "";
+    }
+}
+/** Get cached standing orders (fast, no disk I/O) */
+export function getStandingOrders() {
+    return cached;
+}
+/** Reload from disk (e.g., after editing via tools) */
+export function reloadStandingOrders() {
+    try {
+        cached = readFileSync(AGENTS_FILE, "utf-8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/services/subagents.js

@@ -0,0 +1,142 @@
+/**
+ * Sub-Agent System — Parallel Task Execution
+ *
+ * Spawns isolated AI workers that run in the background using the engine registry.
+ * Each sub-agent gets its own query call (not a persistent session).
+ * Results are stored and can be retrieved by the caller.
+ */
+import os from "os";
+import crypto from "crypto";
+import { config } from "../config.js";
+// ── State ───────────────────────────────────────────────
+const activeAgents = new Map();
+// ── Core execution ──────────────────────────────────────
+async function runSubAgent(id, agentConfig, abort) {
+    const startTime = Date.now();
+    const entry = activeAgents.get(id);
+    try {
+        const { getRegistry } = await import("../engine.js");
+        const registry = getRegistry();
+        const systemPrompt = `You are a sub-agent named "${agentConfig.name}". Complete the following task autonomously and report your results clearly when done. Working directory: ${agentConfig.workingDir || os.homedir()}`;
+        let finalText = "";
+        let inputTokens = 0;
+        let outputTokens = 0;
+        for await (const chunk of registry.queryWithFallback({
+            prompt: agentConfig.prompt,
+            systemPrompt,
+            workingDir: agentConfig.workingDir || os.homedir(),
+            effort: "high",
+            abortSignal: abort.signal,
+        })) {
+            if (chunk.type === "text")
+                finalText = chunk.text || "";
+            if (chunk.type === "done") {
+                inputTokens = chunk.inputTokens || 0;
+                outputTokens = chunk.outputTokens || 0;
+            }
+        }
+        entry.result = {
+            id,
+            name: agentConfig.name,
+            status: "completed",
+            output: finalText,
+            tokensUsed: { input: inputTokens, output: outputTokens },
+            duration: Date.now() - startTime,
+        };
+        entry.info.status = "completed";
+    }
+    catch (err) {
+        const isAbort = err instanceof Error && err.message.includes("abort");
+        const isTimeout = abort.signal.aborted;
+        const status = isTimeout
+            ? "timeout"
+            : isAbort
+                ? "cancelled"
+                : "error";
+        entry.result = {
+            id,
+            name: agentConfig.name,
+            status,
+            output: "",
+            tokensUsed: { input: 0, output: 0 },
+            duration: Date.now() - startTime,
+            error: err instanceof Error ? err.message : String(err),
+        };
+        entry.info.status = status;
+    }
+}
+// ── Public API ──────────────────────────────────────────
+/**
+ * Spawn an isolated sub-agent that runs in the background.
+ * Returns the agent ID immediately (does NOT await completion).
+ */
+export function spawnSubAgent(agentConfig) {
+    // Check concurrency limit
+    const runningCount = [...activeAgents.values()].filter((a) => a.info.status === "running").length;
+    if (runningCount >= config.maxSubAgents) {
+        return Promise.reject(new Error(`Sub-agent limit reached (${config.maxSubAgents}). Wait for a running agent to finish or cancel one.`));
+    }
+    const id = crypto.randomUUID();
+    const timeout = agentConfig.timeout ?? config.subAgentTimeout;
+    const abort = new AbortController();
+    // Set up timeout
+    const timeoutId = setTimeout(() => abort.abort(), timeout);
+    const info = {
+        id,
+        name: agentConfig.name,
+        status: "running",
+        startedAt: Date.now(),
+        model: agentConfig.model,
+    };
+    activeAgents.set(id, { info, abort });
+    // Run in background — don't await
+    runSubAgent(id, agentConfig, abort)
+        .finally(() => {
+        clearTimeout(timeoutId);
+        // Auto-cleanup: remove completed agents after 30 minutes
+        setTimeout(() => {
+            const entry = activeAgents.get(id);
+            if (entry && entry.info.status !== "running") {
+                activeAgents.delete(id);
+            }
+        }, 30 * 60 * 1000);
+    });
+    return Promise.resolve(id);
+}
+/**
+ * List all agents (active + recent completed).
+ */
+export function listSubAgents() {
+    return [...activeAgents.values()].map((a) => ({ ...a.info }));
+}
+/**
+ * Cancel a running sub-agent by ID.
+ * Returns true if the agent was found and aborted.
+ */
+export function cancelSubAgent(id) {
+    const entry = activeAgents.get(id);
+    if (!entry || entry.info.status !== "running")
+        return false;
+    entry.abort.abort();
+    entry.info.status = "cancelled";
+    return true;
+}
+/**
+ * Get the result of a completed sub-agent.
+ * Returns null if not found or still running.
+ */
+export function getSubAgentResult(id) {
+    const entry = activeAgents.get(id);
+    return entry?.result ?? null;
+}
+/**
+ * Cancel all active sub-agents. Used during shutdown.
+ */
+export function cancelAllSubAgents() {
+    for (const [id, entry] of activeAgents) {
+        if (entry.info.status === "running") {
+            entry.abort.abort();
+            entry.info.status = "cancelled";
+        }
+    }
+}