vibe-forge 0.4.0 → 0.8.2

package/bin/cli.js

@@ -17,12 +17,14 @@ const os = require('os');
 // Read version from package.json (single source of truth)
 const packageJson = require(path.join(__dirname, '..', 'package.json'));
 const VERSION = packageJson.version;
-const REPO_URL = 'https://github.com/SpasticPalate/vibe-forge.git';
+const REPO_URL = 'https://github.com/sugar-crash-studios/vibe-forge.git';
 const FORGE_DIR = '_vibe-forge';
 
 // Colors for terminal output
-// NOTE: Intentionally self-contained - cli.js runs standalone via npx before
-// the rest of Vibe Forge is installed, so it cannot share with colors.sh
+// NOTE: Intentionally duplicated from src/lib/colors.sh
+// This is by design: cli.js runs standalone via npx before the rest of Vibe Forge
+// is installed, so it cannot import colors.sh. If you update colors here,
+// also update src/lib/colors.sh to keep them in sync.
 const colors = {
   reset: '\x1b[0m',
   red: '\x1b[31m',
@@ -63,15 +65,60 @@ function showHelp() {
 Commands:
   init      Initialize Vibe Forge in the current project
   update    Update Vibe Forge to the latest version
+  agents    List all agents, roles, and aliases
   version   Show version information
   help      Show this help message
 
 Examples:
   npx vibe-forge init     # Set up Forge in your project
   npx vibe-forge update   # Update to latest version
+  npx vibe-forge agents   # Show agent roster
 `);
 }
 
+function showAgents() {
+  const agentsFile = path.join(__dirname, '..', 'config', 'agents.json');
+  let agents = {};
+  try {
+    const data = JSON.parse(fs.readFileSync(agentsFile, 'utf8'));
+    agents = data.agents || {};
+  } catch (e) {
+    logError('Could not read agents.json');
+    logInfo('Run from inside a Vibe Forge installation, or run: npx vibe-forge init');
+    return;
+  }
+
+  showBanner();
+  console.log(`${colors.yellow}Agent Roster${colors.reset}`);
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+
+  const typeOrder = ['core', 'worker', 'specialist', 'advisor'];
+  const typeLabels = {
+    core: 'Core (Always Running)',
+    worker: 'Workers (Per-Task)',
+    specialist: 'Specialists (On-Demand)',
+    advisor: 'Advisors',
+  };
+
+  for (const type of typeOrder) {
+    const group = Object.entries(agents).filter(([, a]) => a.type === type);
+    if (group.length === 0) continue;
+    console.log(`  ${colors.cyan}${typeLabels[type] || type}${colors.reset}`);
+    for (const [name, agent] of group) {
+      console.log(`    ${agent.icon || '  '} ${colors.yellow}${name}${colors.reset} — ${agent.role}`);
+      if (agent.aliases && agent.aliases.length > 0) {
+        console.log(`       aliases: ${agent.aliases.join(', ')}`);
+      }
+    }
+    console.log('');
+  }
+
+  console.log(`Spawn an agent:`);
+  console.log(`  ${colors.yellow}./bin/forge.sh spawn <agent-name-or-alias>${colors.reset}`);
+  console.log('');
+}
+
 function showVersion() {
   console.log(`Vibe Forge v${VERSION}`);
 }
@@ -106,33 +153,9 @@ function getBashPath() {
   if (!isWindows()) {
     return 'bash';
   }
-
-  // Common Git Bash paths on Windows
-  const paths = [
-    'C:\\Program Files\\Git\\bin\\bash.exe',
-    'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
-    path.join(process.env.LOCALAPPDATA || '', 'Programs', 'Git', 'bin', 'bash.exe'),
-  ];
-
-  for (const p of paths) {
-    if (fs.existsSync(p)) {
-      return p;
-    }
-  }
-
-  // Try to find via where command
-  try {
-    const gitPath = execSync('where git', { stdio: 'pipe' }).toString().trim().split('\n')[0];
-    const gitDir = path.dirname(path.dirname(gitPath));
-    const bashPath = path.join(gitDir, 'bin', 'bash.exe');
-    if (fs.existsSync(bashPath)) {
-      return bashPath;
-    }
-  } catch {
-    // Ignore
-  }
-
-  return null;
+  // Delegate to shared terminal utility for Windows Git Bash detection
+  const { findGitBash } = require('../src/lib/terminal.js');
+  return findGitBash() || null;
 }
 
 function runBashScript(scriptPath, args = []) {
@@ -201,6 +224,9 @@ async function initCommand() {
 
   log('');
 
+  // Validate agents.json (alias collisions)
+  validateAgentsConfig(targetDir);
+
   // Update project's .gitignore to ignore tool internals but keep project data
   updateGitignore();
 
@@ -217,6 +243,24 @@ async function initCommand() {
   }
 }
 
+function validateAgentsConfig(forgeDir) {
+  const checkScript = path.join(forgeDir, 'bin', 'lib', 'check-aliases.js');
+  if (!fs.existsSync(checkScript)) return;
+
+  try {
+    const agentsFile = path.join(forgeDir, 'config', 'agents.json');
+    execSync(`node "${checkScript}" "${agentsFile}"`, { stdio: 'pipe' });
+    const config = JSON.parse(fs.readFileSync(agentsFile, 'utf8'));
+    const agentCount = Object.keys(config.agents || {}).length;
+    logSuccess(`Agent config valid (${agentCount} agents, no alias collisions)`);
+  } catch (err) {
+    logError('Agent alias collisions detected in config/agents.json');
+    logInfo(err.stderr ? err.stderr.toString().trim() : 'Run node src/lib/check-aliases.js for details');
+    logError('Fix collisions before using Vibe Forge.');
+    process.exit(1);
+  }
+}
+
 function updateGitignore() {
   const gitignorePath = path.join(process.cwd(), '.gitignore');
   const forgeIgnoreMarker = '# Vibe Forge';
@@ -305,6 +349,9 @@ async function main() {
     case 'update':
       await updateCommand();
       break;
+    case 'agents':
+      showAgents();
+      break;
     case 'version':
     case '--version':
     case '-v':

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
+};