@sugar-crash-studios/vibe-forge 0.4.0

package/bin/dashboard/api/agents.js

@@ -0,0 +1,333 @@
+/**
+ * Agents API - List and query agent status
+ *
+ * Reads agent status from:
+ *   1. SQLite database (if available) - daemon's aggregated view
+ *   2. JSON files in context/agent-status/ - direct file read fallback
+ *
+ * Endpoints:
+ *   GET /api/agents - List all agents with their status
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Agent status directory
+const AGENT_STATUS_DIR = 'context/agent-status';
+
+// Known agents (for complete listing even if status file missing)
+const KNOWN_AGENTS = [
+    'planning-hub',
+    'architect',
+    'furnace',
+    'anvil',
+    'crucible',
+    'temper',
+    'ember',
+    'scribe',
+    'aegis',
+    'pixel',
+    'oracle',
+    'loki'
+];
+
+// Status display order
+const STATUS_ORDER = {
+    'working': 0,
+    'testing': 1,
+    'blocked': 2,
+    'attention': 3,
+    'idle': 4,
+    'unknown': 5,
+    'offline': 6
+};
+
+/**
+ * Try to read agent status from SQLite database
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array|null} Agent statuses or null if DB not available
+ */
+async function readFromDatabase(projectRoot) {
+    try {
+        // Check for better-sqlite3 (synchronous)
+        const Database = require('better-sqlite3');
+        const dbPath = path.join(projectRoot, '.forge', 'forge.db');
+
+        if (!fs.existsSync(dbPath)) {
+            return null;
+        }
+
+        const db = new Database(dbPath, { readonly: true });
+
+        try {
+            const rows = db.prepare(`
+                SELECT agent, status, task, message, updated_at
+                FROM agent_status
+                ORDER BY agent
+            `).all();
+
+            return rows.map(row => ({
+                agent: row.agent,
+                status: row.status || 'unknown',
+                task: row.task || null,
+                message: row.message || null,
+                updatedAt: row.updated_at || null,
+                source: 'database'
+            }));
+        } finally {
+            db.close();
+        }
+    } catch (err) {
+        // better-sqlite3 not available or DB error, fall back to files
+        return null;
+    }
+}
+
+/**
+ * Read agent status from JSON file
+ * @param {string} filePath - Path to status file
+ * @returns {Object|null} Agent status or null
+ */
+function readStatusFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const data = JSON.parse(content);
+        const stats = fs.statSync(filePath);
+
+        return {
+            agent: data.agent || path.basename(filePath, '.json'),
+            status: data.status || 'unknown',
+            task: data.task || null,
+            message: data.message || null,
+            updatedAt: data.updated || stats.mtime.toISOString(),
+            source: 'file'
+        };
+    } catch (err) {
+        console.error(`[Agents] Error reading ${filePath}: ${err.message}`);
+        return null;
+    }
+}
+
+/**
+ * Read all agent statuses from files
+ * @param {string} projectRoot - Project root directory
+ * @returns {Array} Agent statuses
+ */
+function readFromFiles(projectRoot) {
+    const statusDir = path.join(projectRoot, AGENT_STATUS_DIR);
+    const agents = [];
+
+    if (!fs.existsSync(statusDir)) {
+        return agents;
+    }
+
+    const files = fs.readdirSync(statusDir).filter(f => f.endsWith('.json'));
+
+    for (const file of files) {
+        const filePath = path.join(statusDir, file);
+        const status = readStatusFile(filePath);
+
+        if (status) {
+            agents.push(status);
+        }
+    }
+
+    return agents;
+}
+
+/**
+ * Get agent metadata (icon, role) from personality files
+ * @param {string} projectRoot - Project root directory
+ * @param {string} agentName - Agent name
+ * @returns {Object} Agent metadata
+ */
+function getAgentMetadata(projectRoot, agentName) {
+    const personalityPath = path.join(projectRoot, 'agents', agentName, 'personality.md');
+
+    const defaults = {
+        icon: getDefaultIcon(agentName),
+        role: 'Agent',
+        color: getDefaultColor(agentName)
+    };
+
+    if (!fs.existsSync(personalityPath)) {
+        return defaults;
+    }
+
+    try {
+        const content = fs.readFileSync(personalityPath, 'utf8');
+
+        // Extract icon from first line or **Icon:** field
+        const iconMatch = content.match(/\*\*Icon:\*\*\s*(.+)/);
+        if (iconMatch) {
+            defaults.icon = iconMatch[1].trim();
+        }
+
+        // Extract role from **Role:** field
+        const roleMatch = content.match(/\*\*Role:\*\*\s*(.+)/);
+        if (roleMatch) {
+            defaults.role = roleMatch[1].trim();
+        }
+
+        return defaults;
+    } catch (err) {
+        return defaults;
+    }
+}
+
+/**
+ * Get default icon for agent
+ * @param {string} agentName - Agent name
+ * @returns {string} Icon emoji
+ */
+function getDefaultIcon(agentName) {
+    const icons = {
+        'planning-hub': '⚙️',
+        'architect': '🏛️',
+        'furnace': '🔥',
+        'anvil': '🔨',
+        'crucible': '🧪',
+        'temper': '⚖️',
+        'ember': '✨',
+        'scribe': '📝',
+        'aegis': '🔒',
+        'pixel': '🎨',
+        'oracle': '🔮',
+        'loki': '🎭'
+    };
+    return icons[agentName] || '🤖';
+}
+
+/**
+ * Get default color for agent (for UI)
+ * @param {string} agentName - Agent name
+ * @returns {string} Color code
+ */
+function getDefaultColor(agentName) {
+    const colors = {
+        'planning-hub': '#6366f1',
+        'architect': '#8b5cf6',
+        'furnace': '#ef4444',
+        'anvil': '#f97316',
+        'crucible': '#22c55e',
+        'temper': '#8b5cf6',
+        'ember': '#eab308',
+        'scribe': '#06b6d4',
+        'aegis': '#14b8a6',
+        'pixel': '#ec4899',
+        'oracle': '#FBBF24',
+        'loki': '#7C3AED'
+    };
+    return colors[agentName] || '#6b7280';
+}
+
+/**
+ * List all agents with their status
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object} Agents listing with summary
+ */
+async function listAgents(projectRoot) {
+    // Try database first, then fall back to files
+    let statuses = await readFromDatabase(projectRoot);
+
+    if (!statuses) {
+        statuses = readFromFiles(projectRoot);
+    }
+
+    // Create map for quick lookup
+    const statusMap = new Map();
+    for (const status of statuses) {
+        statusMap.set(status.agent, status);
+    }
+
+    // Build complete agent list
+    const agents = [];
+
+    for (const agentName of KNOWN_AGENTS) {
+        const status = statusMap.get(agentName);
+        const metadata = getAgentMetadata(projectRoot, agentName);
+
+        agents.push({
+            agent: agentName,
+            displayName: agentName.split('-').map(w =>
+                w.charAt(0).toUpperCase() + w.slice(1)
+            ).join(' '),
+            icon: metadata.icon,
+            role: metadata.role,
+            color: metadata.color,
+            status: status?.status || 'offline',
+            task: status?.task || null,
+            message: status?.message || null,
+            updatedAt: status?.updatedAt || null,
+            isOnline: status != null
+        });
+    }
+
+    // Add any unknown agents found in status files
+    for (const status of statuses) {
+        if (!KNOWN_AGENTS.includes(status.agent)) {
+            const metadata = getAgentMetadata(projectRoot, status.agent);
+            agents.push({
+                agent: status.agent,
+                displayName: status.agent.split('-').map(w =>
+                    w.charAt(0).toUpperCase() + w.slice(1)
+                ).join(' '),
+                icon: metadata.icon,
+                role: metadata.role,
+                color: metadata.color,
+                status: status.status,
+                task: status.task,
+                message: status.message,
+                updatedAt: status.updatedAt,
+                isOnline: true
+            });
+        }
+    }
+
+    // Sort by status priority, then by name
+    agents.sort((a, b) => {
+        const sa = STATUS_ORDER[a.status] ?? 5;
+        const sb = STATUS_ORDER[b.status] ?? 5;
+        if (sa !== sb) return sa - sb;
+        return a.agent.localeCompare(b.agent);
+    });
+
+    // Build summary
+    const summary = {
+        total: agents.length,
+        online: agents.filter(a => a.isOnline).length,
+        working: agents.filter(a => a.status === 'working').length,
+        idle: agents.filter(a => a.status === 'idle').length,
+        blocked: agents.filter(a => a.status === 'blocked').length,
+        attention: agents.filter(a => a.status === 'attention').length
+    };
+
+    return {
+        agents,
+        summary,
+        dataSource: statuses.length > 0 && statuses[0].source || 'none'
+    };
+}
+
+/**
+ * Get single agent details
+ * @param {string} projectRoot - Project root directory
+ * @param {string} agentName - Agent name
+ * @returns {Object|null} Agent details or null
+ */
+async function getAgent(projectRoot, agentName) {
+    // Sanitize agent name
+    const safeName = agentName.toLowerCase().replace(/[^a-z0-9-]/g, '');
+
+    const result = await listAgents(projectRoot);
+    return result.agents.find(a => a.agent === safeName) || null;
+}
+
+module.exports = {
+    listAgents,
+    getAgent,
+    readFromFiles,
+    readFromDatabase,
+    getAgentMetadata,
+    KNOWN_AGENTS
+};