pixelcrew 0.1.0 → 0.1.2

package/src/orchestrator/engine.js

@@ -572,17 +572,21 @@ export class OrchestratorEngine extends EventEmitter {
       await this.persistState();
 
       // 5. Generate and Persist Executive Report
-      const reportMarkdown = this.compileAuditReport(taskPrompt, targetAgents, findings);
-      await this.saveAuditReport(reportMarkdown);
+      const reportData = this.compileAuditReport(taskPrompt, targetAgents, findings);
+      await this.saveAuditReport(reportData);
 
       await this.emitEvent({
         agent: 'orchestrator',
         type: 'complete',
-        message: `★ SWARM MISSION COMPLETE: Audit report generated with recommendations!`,
-        metadata: { report: reportMarkdown }
+        message: `★ SWARM MISSION COMPLETE: Audit report generated with actionable recommendations!`,
+        metadata: { 
+          report: reportData.markdown,
+          reportId: reportData.id,
+          reportData
+        }
       });
 
-      return reportMarkdown;
+      return reportData.markdown;
 
     } catch (err) {
       if (err.message !== 'Task Aborted') {
@@ -600,53 +604,250 @@ export class OrchestratorEngine extends EventEmitter {
   }
 
   /**
-   * Compiles structured markdown audit report
+   * Compiles structured audit report with both user-friendly JSON and Markdown formats
    */
   compileAuditReport(taskPrompt, targetAgents, findings) {
-    const timestamp = new Date().toLocaleTimeString();
+    const timestamp = Date.now();
+    const dateObj = new Date(timestamp);
+    const timeStr = dateObj.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    const dateStr = dateObj.toLocaleDateString([], { month: 'short', day: 'numeric', year: 'numeric' });
     const projectName = this.config?.project || path.basename(this.targetDir);
+    const reportId = `sprint-${timestamp}`;
+
+    const agentMeta = {
+      frontend: { name: 'Frontend Squad', icon: '🎨', color: '#00f0ff' },
+      backend: { name: 'Backend Squad', icon: '⚡', color: '#ff007f' },
+      database: { name: 'Database Squad', icon: '🗄️', color: '#ffd700' },
+      security: { name: 'Security Squad', icon: '🛡️', color: '#ff3344' },
+      performance: { name: 'Performance SRE', icon: '🚀', color: '#39ff14' },
+      qa: { name: 'QA Squad', icon: '🧪', color: '#b026ff' },
+      orchestrator: { name: 'Lead Orchestrator', icon: '👔', color: '#ffd700' }
+    };
 
-    let report = `
-╔═══════════════════════════════════════════════════════════════════╗
-║               PIXELCREW SWARM AUDIT REPORT                       ║
-╚═══════════════════════════════════════════════════════════════════╝
+    const sections = [];
+    const actionItems = [];
+    let totalFindings = 0;
 
-PROJECT:         ${projectName}
-OBJECTIVE:       "${taskPrompt}"
-TIMESTAMP:       ${timestamp}
-TEAM SPRINT:     ${targetAgents.map(a => a.toUpperCase()).join(', ')}
-STATUS:          100% COMPLETED
+    for (const [agent, items] of Object.entries(findings)) {
+      if (!items || !items.length) continue;
+      totalFindings += items.length;
+      const meta = agentMeta[agent] || { name: agent.toUpperCase(), icon: '💼', color: '#00f0ff' };
+      
+      const parsedFindings = items.map((item, idx) => {
+        const parts = item.split(':');
+        const category = parts.length > 1 ? parts[0].trim() : 'Recommendation';
+        const description = parts.length > 1 ? parts.slice(1).join(':').trim() : item;
+        actionItems.push(`[${agent.toUpperCase()}] ${description}`);
+        return {
+          id: `${agent}-${idx + 1}`,
+          category,
+          description
+        };
+      });
 
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-EXECUTIVE FINDINGS & ACTIONABLE IMPROVEMENTS
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-`;
+      sections.push({
+        agent,
+        name: meta.name,
+        icon: meta.icon,
+        color: meta.color,
+        findings: parsedFindings
+      });
+    }
 
-    for (const [agent, items] of Object.entries(findings)) {
-      report += `\n[${agent.toUpperCase()} AGENT]:\n`;
-      for (const item of items) {
-        report += `  • ${item}\n`;
+    // Generate Markdown
+    let markdown = `# PixelCrew Swarm Audit Report\n\n`;
+    markdown += `**Project:** ${projectName}  \n`;
+    markdown += `**Objective:** "${taskPrompt}"  \n`;
+    markdown += `**Date:** ${dateStr} at ${timeStr}  \n`;
+    markdown += `**Team Roster:** ${targetAgents.map(a => a.toUpperCase()).join(', ')}  \n`;
+    markdown += `**Status:** 100% Completed  \n\n`;
+    markdown += `## Executive Summary\n`;
+    markdown += `The multi-agent swarm completed the assigned objective with **${totalFindings} key findings & actionable improvements** across ${targetAgents.length} specialized engineering squads.\n\n`;
+    markdown += `## Squad Findings & Recommendations\n\n`;
+
+    for (const section of sections) {
+      markdown += `### ${section.icon} ${section.name}\n`;
+      for (const finding of section.findings) {
+        markdown += `- **${finding.category}:** ${finding.description}\n`;
       }
+      markdown += `\n`;
     }
 
-    report += `\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`;
-    report += `NEXT STEPS: Review findings and apply proposed improvements.\n`;
+    markdown += `## Action Items & Next Steps\n`;
+    for (const action of actionItems) {
+      markdown += `- [ ] ${action}\n`;
+    }
+
+    const reportObject = {
+      id: reportId,
+      timestamp,
+      dateFormatted: `${dateStr}, ${timeStr}`,
+      project: projectName,
+      objective: taskPrompt,
+      status: 'COMPLETED',
+      targetAgents,
+      totalFindings,
+      sections,
+      actionItems,
+      markdown
+    };
 
-    return report.trim();
+    return reportObject;
   }
 
   /**
-   * Saves audit report to .pixel-agents/reports/
+   * Saves audit report to .pixel-agents/reports/ in both JSON and Markdown format
    */
-  async saveAuditReport(reportMarkdown) {
+  async saveAuditReport(reportData) {
     const reportsDir = path.join(this.pixelAgentsDir, 'reports');
     try {
       await fs.mkdir(reportsDir, { recursive: true });
-      const filename = `audit-${Date.now()}.md`;
-      await fs.writeFile(path.join(reportsDir, filename), reportMarkdown + '\n', 'utf-8');
-    } catch {
-      // ignore
+      const baseFilename = reportData.id || `sprint-${Date.now()}`;
+      
+      // Save JSON metadata
+      await fs.writeFile(
+        path.join(reportsDir, `${baseFilename}.json`),
+        JSON.stringify(reportData, null, 2),
+        'utf-8'
+      );
+
+      // Save readable Markdown
+      if (reportData.markdown) {
+        await fs.writeFile(
+          path.join(reportsDir, `${baseFilename}.md`),
+          reportData.markdown.trim() + '\n',
+          'utf-8'
+        );
+      }
+    } catch (err) {
+      console.error('Error saving audit report:', err);
     }
   }
+
+  /**
+   * Reads and lists all audit reports stored in .pixel-agents/reports/ or reports/
+   */
+  async getReports() {
+    const directories = [
+      path.join(this.pixelAgentsDir, 'reports'),
+      path.join(this.targetDir || this.rootDir, 'reports')
+    ];
+
+    const reportsMap = new Map();
+
+    for (const dir of directories) {
+      try {
+        await fs.mkdir(dir, { recursive: true });
+        const files = await fs.readdir(dir);
+
+        // 1. Process JSON reports first
+        const jsonFiles = files.filter(f => f.endsWith('.json'));
+        for (const file of jsonFiles) {
+          try {
+            const raw = await fs.readFile(path.join(dir, file), 'utf-8');
+            const data = JSON.parse(raw);
+            const id = data.id || file.replace(/\.json$/, '');
+            reportsMap.set(id, { ...data, id });
+          } catch {}
+        }
+
+        // 2. Process Markdown reports (including standalone .md files)
+        const mdFiles = files.filter(f => f.endsWith('.md'));
+        for (const file of mdFiles) {
+          const id = file.replace(/\.md$/, '');
+          if (!reportsMap.has(id)) {
+            try {
+              const fullPath = path.join(dir, file);
+              const raw = await fs.readFile(fullPath, 'utf-8');
+              const stats = await fs.stat(fullPath);
+              const parsed = this.parseMarkdownReport(id, raw, stats.mtime);
+              reportsMap.set(id, parsed);
+            } catch {}
+          }
+        }
+      } catch {}
+    }
+
+    const reports = Array.from(reportsMap.values());
+    reports.sort((a, b) => (b.timestamp || 0) - (a.timestamp || 0));
+    return reports;
+  }
+
+  /**
+   * Helper to parse standalone markdown files into structured report objects
+   */
+  parseMarkdownReport(id, markdown, mtime) {
+    const lines = markdown.split('\n');
+    let title = id.replace(/[-_]/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    const findings = [];
+    const actionItems = [];
+    const detectedAgents = new Set();
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith('# ') && (title === id || title.toLowerCase() === id.replace(/[-_]/g, ' '))) {
+        title = trimmed.replace(/^#\s+/, '');
+      } else if (trimmed.startsWith('- [ ]') || trimmed.startsWith('- [x]')) {
+        actionItems.push(trimmed.replace(/^-\s+\[.\]\s*/, ''));
+      } else if (trimmed.startsWith('- ') || trimmed.startsWith('* ') || /^\d+\.\s+/.test(trimmed)) {
+        findings.push(trimmed.replace(/^[-*]\s+|\d+\.\s+/, ''));
+      }
+
+      // Check agent mentions
+      const lower = line.toLowerCase();
+      if (lower.includes('frontend') || lower.includes('ui') || lower.includes('react')) detectedAgents.add('frontend');
+      if (lower.includes('backend') || lower.includes('api')) detectedAgents.add('backend');
+      if (lower.includes('database') || lower.includes('postgres') || lower.includes('prisma') || lower.includes('sql')) detectedAgents.add('database');
+      if (lower.includes('security') || lower.includes('auth')) detectedAgents.add('security');
+      if (lower.includes('performance') || lower.includes('vital') || lower.includes('speed')) detectedAgents.add('performance');
+      if (lower.includes('qa') || lower.includes('test') || lower.includes('playwright')) detectedAgents.add('qa');
+    }
+
+    const targetAgents = detectedAgents.size > 0 ? Array.from(detectedAgents) : ['frontend', 'qa'];
+    const timestamp = mtime ? new Date(mtime).getTime() : Date.now();
+    const dateObj = new Date(timestamp);
+    const timeStr = dateObj.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+    const dateStr = dateObj.toLocaleDateString([], { month: 'short', day: 'numeric', year: 'numeric' });
+
+    // Group findings into clean sections
+    const sections = [
+      {
+        agent: targetAgents[0] || 'frontend',
+        name: `${(targetAgents[0] || 'Team').toUpperCase()} Findings`,
+        icon: '📋',
+        color: '#00f0ff',
+        findings: (findings.length > 0 ? findings : ['Report recorded in markdown']).slice(0, 10).map((f, i) => {
+          const parts = f.split(':');
+          return {
+            id: `item-${i + 1}`,
+            category: parts.length > 1 ? parts[0].trim() : 'Observation',
+            description: parts.length > 1 ? parts.slice(1).join(':').trim() : f
+          };
+        })
+      }
+    ];
+
+    return {
+      id,
+      timestamp,
+      dateFormatted: `${dateStr}, ${timeStr}`,
+      project: this.config?.project || path.basename(this.targetDir || this.rootDir),
+      objective: title,
+      status: 'COMPLETED',
+      targetAgents,
+      totalFindings: findings.length || 1,
+      sections,
+      actionItems: actionItems.length > 0 ? actionItems : (findings.length > 0 ? findings.slice(0, 5) : ['Review report findings']),
+      markdown
+    };
+  }
+
+  /**
+   * Gets a specific report by ID
+   */
+  async getReportById(reportId) {
+    const reports = await this.getReports();
+    return reports.find(r => r.id === reportId) || null;
+  }
 }
 

package/src/server/server.js

@@ -169,6 +169,34 @@ export function createServer(engine, options = {}) {
       return sendJson(200, { status: 'reset' });
     }
 
+    if (pathname === '/api/reports' && req.method === 'GET') {
+      const reports = await engine.getReports();
+      return sendJson(200, { reports });
+    }
+
+    if (pathname.startsWith('/api/reports/') && req.method === 'GET') {
+      const reportId = pathname.replace('/api/reports/', '');
+      const report = await engine.getReportById(reportId);
+      if (!report) {
+        return sendJson(404, { error: 'Report not found' });
+      }
+      return sendJson(200, { report });
+    }
+
+    if (pathname === '/api/reports' && req.method === 'POST') {
+      const body = await readBody();
+      if (!body.objective && !body.markdown) {
+        return sendJson(400, { error: 'Missing report objective or markdown' });
+      }
+      const reportData = engine.compileAuditReport(
+        body.objective || 'Manual Audit',
+        body.targetAgents || ['frontend', 'backend', 'database'],
+        body.findings || {}
+      );
+      await engine.saveAuditReport(reportData);
+      return sendJson(201, { status: 'created', report: reportData });
+    }
+
     if (pathname === '/api/demo' && req.method === 'POST') {
       const demoPrompt = 'Analyze CRM customer search bottlenecks & optimize Postgres Prisma queries with responsive UI';
       engine.submitTask(demoPrompt).catch(console.error);
@@ -187,12 +215,12 @@ export function createServer(engine, options = {}) {
     else if (filename.endsWith('.svg')) contentType = 'image/svg+xml';
     else if (filename.endsWith('.ico')) contentType = 'image/x-icon';
 
-    // Check project .pixel-dashboard first, then fallback to built-in
-    let filePath = path.join(dashboardDir, filename);
+    // Serve latest dashboard assets from package with fallback to project directory
+    let filePath = path.join(fallbackDashboardDir, filename);
     try {
       await fs.access(filePath);
     } catch {
-      filePath = path.join(fallbackDashboardDir, filename);
+      filePath = path.join(dashboardDir, filename);
       try {
         await fs.access(filePath);
       } catch {