pixelcrew 0.2.3 → 0.2.6

package/src/server/server.js

@@ -13,8 +13,7 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
     engine = maybeEngine;
   }
 
-  const dashboardDir = path.join(rootDir, '.pixel-agents', 'dashboard');
-  const legacyDashboardDir = path.join(rootDir, '.pixel-dashboard');
+  const dashboardDir = path.join(rootDir, '.pixel-crew', 'dashboard');
   const fallbackDashboardDir = fileURLToPath(new URL('../dashboard', import.meta.url));
 
   const sseClients = new Set();
@@ -87,15 +86,39 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
 
     // API Routes
     if (pathname === '/api/info' && req.method === 'GET') {
+      let activeProv = { activeProvider: 'generic', activeProviderName: 'Generic CLI Runner', activeProviderIcon: '💻' };
+      if (engine.providerRegistry) {
+        try {
+          const scan = await engine.providerRegistry.scanEnvironment();
+          activeProv = {
+            activeProvider: scan.activeProvider,
+            activeProviderName: scan.activeProviderName,
+            activeProviderIcon: scan.activeProviderIcon
+          };
+        } catch {}
+      }
       return sendJson(200, {
         rootDir: engine.rootDir,
         project: engine.getConfig()?.project || path.basename(engine.rootDir),
-        version: '0.1.0'
+        version: '0.2.5',
+        ...activeProv
       });
     }
 
     if (pathname === '/api/state' && req.method === 'GET') {
-      return sendJson(200, engine.getState());
+      const state = engine.getState() || {};
+      let activeProv = { activeProvider: 'generic', activeProviderName: 'Generic CLI Runner', activeProviderIcon: '💻' };
+      if (engine.providerRegistry) {
+        try {
+          const scan = await engine.providerRegistry.scanEnvironment();
+          activeProv = {
+            activeProvider: scan.activeProvider,
+            activeProviderName: scan.activeProviderName,
+            activeProviderIcon: scan.activeProviderIcon
+          };
+        } catch {}
+      }
+      return sendJson(200, { ...state, ...activeProv });
     }
 
     if (pathname === '/api/config' && req.method === 'GET') {
@@ -110,11 +133,24 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
         'Connection': 'keep-alive'
       });
 
+      let activeProv = { activeProvider: 'generic', activeProviderName: 'Generic CLI Runner', activeProviderIcon: '💻' };
+      if (engine.providerRegistry) {
+        try {
+          const scan = await engine.providerRegistry.scanEnvironment();
+          activeProv = {
+            activeProvider: scan.activeProvider,
+            activeProviderName: scan.activeProviderName,
+            activeProviderIcon: scan.activeProviderIcon
+          };
+        } catch {}
+      }
+
       // Send initial history
       const initialPayload = `event: init\ndata: ${JSON.stringify({
-        state: engine.getState(),
+        state: { ...(engine.getState() || {}), ...activeProv },
         config: engine.getConfig(),
-        history: engine.getEvents()
+        history: engine.getEvents(),
+        provider: activeProv
       })}\n\n`;
       res.write(initialPayload);
 
@@ -126,6 +162,82 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
       return;
     }
 
+    if (pathname === '/api/command' && req.method === 'POST') {
+      const body = await readBody();
+      const input = body.input || body.command || body.prompt || '';
+      try {
+        const result = await engine.executeCommand(input, body.options || {});
+        return sendJson(200, result);
+      } catch (err) {
+        return sendJson(500, { success: false, error: err.message });
+      }
+    }
+
+    if (pathname === '/api/commands/autocomplete' && req.method === 'GET') {
+      const query = url.searchParams.get('q') || '';
+      const suggestions = engine.commandRegistry ? engine.commandRegistry.getAutocompleteSuggestions(query) : [];
+      return sendJson(200, { suggestions });
+    }
+
+    if (pathname === '/api/providers' && req.method === 'GET') {
+      if (engine.providerRegistry) {
+        const scan = await engine.providerRegistry.scanEnvironment(true);
+        return sendJson(200, {
+          activeProvider: scan.activeProvider,
+          activeProviderName: scan.activeProviderName,
+          activeProviderIcon: scan.activeProviderIcon,
+          activeProviderDescription: scan.activeProviderDescription,
+          available: scan.available.map(a => ({ 
+            id: a.id, 
+            name: a.name, 
+            icon: a.icon || '🤖', 
+            description: a.description, 
+            capabilities: a.capabilities 
+          })),
+          missing: scan.missing.map(a => ({ 
+            id: a.id, 
+            name: a.name, 
+            icon: a.icon || '🤖' 
+          }))
+        });
+      }
+      return sendJson(200, { 
+        activeProvider: 'generic', 
+        activeProviderName: 'Generic CLI Runner', 
+        activeProviderIcon: '💻',
+        available: [{ id: 'generic', name: 'Generic CLI Runner', icon: '💻' }], 
+        missing: [] 
+      });
+    }
+
+    if (pathname === '/api/providers/select' && req.method === 'POST') {
+      const body = await readBody();
+      const providerId = body.provider || body.id;
+      if (engine.providerRegistry && providerId) {
+        const adapter = engine.providerRegistry.getAdapter(providerId);
+        if (adapter) {
+          return sendJson(200, { 
+            success: true, 
+            activeProvider: adapter.id, 
+            activeProviderName: adapter.name, 
+            activeProviderIcon: adapter.icon || '🤖' 
+          });
+        }
+      }
+      return sendJson(400, { success: false, error: 'Provider not found' });
+    }
+
+    if (pathname === '/api/plan' && req.method === 'POST') {
+      const body = await readBody();
+      const prompt = body.prompt || 'Synthesize responsive web architecture';
+      try {
+        const result = await engine.executeCommand(`/plan ${prompt}`, body.options || {});
+        return sendJson(200, result);
+      } catch (err) {
+        return sendJson(500, { success: false, error: err.message });
+      }
+    }
+
     if (pathname === '/api/task' && req.method === 'POST') {
       const body = await readBody();
       const prompt = body.prompt || body.task || 'Optimize application workflow';
@@ -134,25 +246,39 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
       return sendJson(200, { status: 'accepted', prompt });
     }
 
-    if (pathname === '/api/oneshot' && req.method === 'POST') {
+    if ((pathname === '/api/goal' || pathname === '/api/oneshot') && req.method === 'POST') {
       const body = await readBody();
-      const prompt = body.prompt || 'Build a modern portfolio for an AI engineer inspired by editorial design';
+      const prompt = body.prompt || body.goal || 'Build a modern website for a design agency specializing in AI products';
       const options = {
-        targetFramework: body.targetFramework || 'vanilla',
-        outputDir: body.outputDir || path.join(engine.rootDir, 'generated-site')
+        targetFramework: body.targetFramework || 'nextjs',
+        outputDir: body.outputDir
       };
-      // Asynchronously start OneShot pipeline
+      // Asynchronously start Multi-Agent Synthesis / Goal pipeline
       engine.submitOneShotTask(prompt, options).catch(console.error);
-      return sendJson(200, { status: 'oneshot_started', prompt, options });
+      return sendJson(200, { status: 'goal_started', prompt, options });
     }
 
-    if (pathname === '/api/token-stats' && req.method === 'GET') {
-      return sendJson(200, {
+    if ((pathname === '/api/token-stats' || pathname === '/api/token-telemetry') && req.method === 'GET') {
+      const stats = engine.getTokenTelemetry ? engine.getTokenTelemetry() : null;
+      return sendJson(200, stats || {
         rawTokensEstimated: 42500,
         actualTokensUsed: 11800,
         tokensSaved: 30700,
         efficiencyRatio: 72,
         savingsPercent: "72%",
+        costUsd: 0.0284,
+        perAgent: {
+          creativeDirector: 2400,
+          uxPlanner: 2140,
+          designSystem: 1850,
+          frontend: 6200,
+          backend: 2300,
+          database: 1770,
+          performance: 1530,
+          security: 1400,
+          qa: 2800,
+          orchestrator: 1200
+        },
         strategiesActive: [
           "AST Symbol Graph Skeletonization",
           "Tiered Sliding Window Context Pruning",
@@ -164,15 +290,16 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
     }
 
     if (pathname === '/api/site-preview' && req.method === 'GET') {
-      const sitePath = path.join(engine.rootDir, 'generated-site', 'index.html');
-      try {
-        const html = await fs.readFile(sitePath, 'utf-8');
-        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-        res.end(html);
-        return;
-      } catch {
-        return sendJson(404, { error: 'No generated site found yet. Run oneshot first.' });
+      const sitePath = engine.lastGeneratedSitePath || (engine.lastGeneratedOutputDir ? path.join(engine.lastGeneratedOutputDir, 'index.html') : null);
+      if (sitePath) {
+        try {
+          const html = await fs.readFile(sitePath, 'utf-8');
+          res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+          res.end(html);
+          return;
+        } catch {}
       }
+      return sendJson(404, { error: 'No generated site preview found yet. Execute a task or goal first.' });
     }
 
     if (pathname === '/api/emit' && req.method === 'POST') {
@@ -275,24 +402,118 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
   heartbeat.unref();
 
   let isWatching = false;
+  let workspaceWatcher = null;
+  const debouncedFiles = new Map();
 
-  server.once('listening', () => {
+  function inferAgentFromFile(relPath) {
+    const p = relPath.toLowerCase();
+    if (p.includes('test') || p.includes('spec') || p.includes('playwright') || p.includes('vitest') || p.includes('cypress')) {
+      return { agent: 'qa', skill: 'playwright-e2e' };
+    }
+    if (p.includes('prisma') || p.includes('schema') || p.includes('sql') || p.includes('database') || p.includes('migration') || p.includes('postgres')) {
+      return { agent: 'database', skill: 'postgresql' };
+    }
+    if (p.includes('auth') || p.includes('security') || p.includes('sentinel') || p.includes('policy') || p.includes('cert')) {
+      return { agent: 'security', skill: 'security-audit' };
+    }
+    if (p.includes('perf') || p.includes('benchmark') || p.includes('docker') || p.includes('k8s') || p.includes('sre') || p.includes('lcp')) {
+      return { agent: 'performance', skill: 'performance-profiling' };
+    }
+    if (p.includes('api/') || p.includes('server/') || p.includes('routes/') || p.includes('services/') || p.includes('backend') || p.endsWith('.go') || p.endsWith('.py') || p.endsWith('.rs')) {
+      return { agent: 'backend', skill: 'backend' };
+    }
+    if (p.endsWith('.css') || p.endsWith('.scss') || p.includes('tailwind') || p.includes('theme') || p.includes('tokens')) {
+      return { agent: 'frontend', skill: 'design-tokens' };
+    }
+    return { agent: 'frontend', skill: 'react' };
+  }
+
+  function startWatchers() {
     if (isWatching) return;
     isWatching = true;
 
-    // Watch events.jsonl for direct external CLI / IDE writes
-    let lastKnownEventCount = 0;
-    if (engine.eventsPath) {
+    // 1. Live Workspace File Watcher (Captures IDE code edits in real-time)
+    try {
+      workspaceWatcher = fsSync.watch(rootDir, { recursive: true }, (eventType, filename) => {
+        if (!filename) return;
+
+        // Filter out noisy / internal directories
+        const normalized = filename.replace(/\\/g, '/');
+        if (
+          normalized.startsWith('.git') ||
+          normalized.includes('node_modules') ||
+          normalized.includes('.next') ||
+          normalized.includes('.vite') ||
+          normalized.includes('dist') ||
+          normalized.includes('build') ||
+          normalized.includes('coverage') ||
+          normalized.includes('.DS_Store') ||
+          normalized.includes('events.jsonl') ||
+          normalized.includes('state.json') ||
+          normalized.includes('daemon.json') ||
+          normalized.startsWith('.gemini') ||
+          normalized.endsWith('.log')
+        ) {
+          return;
+        }
+
+        const now = Date.now();
+        const lastSeen = debouncedFiles.get(normalized) || 0;
+        if (now - lastSeen < 200) return; // Debounce rapid writes
+        debouncedFiles.set(normalized, now);
+
+        const inferred = inferAgentFromFile(normalized);
+        const event = {
+          agent: inferred.agent,
+          type: 'tool',
+          skill: inferred.skill,
+          message: `Edited ${normalized} (+live IDE workspace update)`,
+          timestamp: now,
+          metadata: {
+            file: normalized,
+            action: 'EDIT',
+            source: 'ide_realtime_watcher'
+          }
+        };
+
+        if (engine && typeof engine.emitEvent === 'function') {
+          engine.emitEvent(event).catch(() => {});
+        } else {
+          engine.eventHistory.push(event);
+          if (engine.eventHistory.length > 300) engine.eventHistory.shift();
+          const payload = `event: agent_event\ndata: ${JSON.stringify(event)}\n\n`;
+          for (const client of sseClients) {
+            try { client.write(payload); } catch {}
+          }
+        }
+      });
+
+      if (workspaceWatcher && typeof workspaceWatcher.on === 'function') {
+        workspaceWatcher.on('error', () => {});
+      }
+    } catch {}
+
+    // 2. Watch events.jsonl for direct external CLI / IDE writes
+    const possibleEventsPaths = [
+      engine?.eventsPath,
+      path.join(rootDir, '.pixel-crew', 'events.jsonl'),
+      path.join(rootDir, '.pixel-agents', 'events.jsonl')
+    ].filter(Boolean);
+
+    const uniqueEventsPaths = Array.from(new Set(possibleEventsPaths));
+
+    for (const ePath of uniqueEventsPaths) {
+      let lastKnownEventCount = 0;
       try {
-        const initialContent = fsSync.readFileSync(engine.eventsPath, 'utf-8');
+        const initialContent = fsSync.readFileSync(ePath, 'utf-8');
         lastKnownEventCount = initialContent.trim().split('\n').filter(Boolean).length;
       } catch {
         lastKnownEventCount = 0;
       }
 
-      fsSync.watchFile(engine.eventsPath, { interval: 150 }, async () => {
+      fsSync.watchFile(ePath, { interval: 150 }, async () => {
         try {
-          const content = await fs.readFile(engine.eventsPath, 'utf-8');
+          const content = await fs.readFile(ePath, 'utf-8');
           const lines = content.trim().split('\n').filter(Boolean);
           if (lines.length > lastKnownEventCount) {
             const newLines = lines.slice(lastKnownEventCount);
@@ -301,7 +522,7 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
               try {
                 const event = JSON.parse(line);
                 engine.eventHistory.push(event);
-                if (engine.eventHistory.length > 200) engine.eventHistory.shift();
+                if (engine.eventHistory.length > 300) engine.eventHistory.shift();
 
                 const payload = `event: agent_event\ndata: ${JSON.stringify(event)}\n\n`;
                 for (const client of sseClients) {
@@ -314,13 +535,21 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
       });
     }
 
-    // Watch state.json for direct external updates
-    if (engine.statePath) {
-      fsSync.watchFile(engine.statePath, { interval: 150 }, async () => {
+    // 3. Watch state.json for direct external updates
+    const possibleStatePaths = [
+      engine?.statePath,
+      path.join(rootDir, '.pixel-crew', 'state.json'),
+      path.join(rootDir, '.pixel-agents', 'state.json')
+    ].filter(Boolean);
+
+    const uniqueStatePaths = Array.from(new Set(possibleStatePaths));
+
+    for (const sPath of uniqueStatePaths) {
+      fsSync.watchFile(sPath, { interval: 150 }, async () => {
         try {
-          const content = await fs.readFile(engine.statePath, 'utf-8');
+          const content = await fs.readFile(sPath, 'utf-8');
           const state = JSON.parse(content);
-          engine.state = state;
+          if (engine) engine.state = state;
           const payload = `event: state_change\ndata: ${JSON.stringify({ state })}\n\n`;
           for (const client of sseClients) {
             try { client.write(payload); } catch {}
@@ -328,17 +557,31 @@ export function createServer(engineOrRootDir, maybeEngine, options = {}) {
         } catch {}
       });
     }
-  });
+  }
+
+  // Start watchers when server begins listening
+  server.on('listening', startWatchers);
 
   server.on('close', () => {
     clearInterval(heartbeat);
-    if (engine.eventsPath) {
-      try { fsSync.unwatchFile(engine.eventsPath); } catch {}
+    isWatching = false;
+    if (workspaceWatcher) {
+      try { workspaceWatcher.close(); } catch {}
     }
-    if (engine.statePath) {
-      try { fsSync.unwatchFile(engine.statePath); } catch {}
+    const possiblePaths = [
+      engine?.eventsPath,
+      engine?.statePath,
+      path.join(rootDir, '.pixel-crew', 'events.jsonl'),
+      path.join(rootDir, '.pixel-agents', 'events.jsonl'),
+      path.join(rootDir, '.pixel-crew', 'state.json'),
+      path.join(rootDir, '.pixel-agents', 'state.json')
+    ].filter(Boolean);
+
+    for (const p of possiblePaths) {
+      try { fsSync.unwatchFile(p); } catch {}
     }
   });
 
   return server;
 }
+

package/src/utils/fs-safe.js

@@ -0,0 +1,168 @@
+/**
+ * PIXEL CREW — Safe File System Operations & Dry-Run Layer
+ * 
+ * Provides atomic, reversible, and previewable filesystem write operations
+ * preventing unintentional mutations during development and testing.
+ */
+
+import fs from 'node:fs/promises';
+import fsSync from 'node:fs';
+import path from 'node:path';
+
+export class DryRunReporter {
+  constructor(targetDir = process.cwd()) {
+    this.targetDir = targetDir;
+    this.creates = new Set();
+    this.updates = new Set();
+    this.dirs = new Set();
+  }
+
+  recordCreate(filePath) {
+    const rel = path.relative(this.targetDir, filePath) || filePath;
+    this.creates.add(rel);
+  }
+
+  recordUpdate(filePath) {
+    const rel = path.relative(this.targetDir, filePath) || filePath;
+    this.updates.add(rel);
+  }
+
+  recordDir(dirPath) {
+    const rel = path.relative(this.targetDir, dirPath) || dirPath;
+    this.dirs.add(rel);
+  }
+
+  hasChanges() {
+    return this.creates.size > 0 || this.updates.size > 0 || this.dirs.size > 0;
+  }
+
+  formatOutput() {
+    const lines = [];
+    lines.push('\x1b[33m\x1b[1m[DRY RUN PREVIEW] — No files were written to disk.\x1b[0m\n');
+
+    if (!this.hasChanges()) {
+      lines.push('  No files or directories would be modified.');
+      return lines.join('\n');
+    }
+
+    if (this.creates.size > 0) {
+      lines.push('\x1b[32mWould create files:\x1b[0m');
+      for (const f of Array.from(this.creates).sort()) {
+        lines.push(`  \x1b[90m+\x1b[0m \x1b[36m${f}\x1b[0m`);
+      }
+      lines.push('');
+    }
+
+    if (this.updates.size > 0) {
+      lines.push('\x1b[33mWould update files:\x1b[0m');
+      for (const f of Array.from(this.updates).sort()) {
+        lines.push(`  \x1b[90m~\x1b[0m \x1b[33m${f}\x1b[0m`);
+      }
+      lines.push('');
+    }
+
+    if (this.dirs.size > 0) {
+      lines.push('\x1b[35mWould ensure directories:\x1b[0m');
+      for (const d of Array.from(this.dirs).sort()) {
+        lines.push(`  \x1b[90m📁\x1b[0m \x1b[35m${d}/\x1b[0m`);
+      }
+      lines.push('');
+    }
+
+    lines.push('\x1b[90mRun without \x1b[0m\x1b[33m--dry-run\x1b[0m\x1b[90m to apply these changes.\x1b[0m');
+    return lines.join('\n');
+  }
+
+  print() {
+    console.log('\n' + this.formatOutput() + '\n');
+  }
+}
+
+/**
+ * Safely writes a file, supporting dry-run mode and directory auto-creation
+ */
+export async function safeWriteFile(filePath, content, options = {}) {
+  const {
+    dryRun = false,
+    encoding = 'utf-8',
+    reporter = null,
+    targetDir = process.cwd()
+  } = options;
+
+  let exists = false;
+  try {
+    await fs.access(filePath);
+    exists = true;
+  } catch {
+    exists = false;
+  }
+
+  if (reporter) {
+    if (exists) {
+      reporter.recordUpdate(filePath);
+    } else {
+      reporter.recordCreate(filePath);
+    }
+  }
+
+  if (dryRun) {
+    return { written: false, dryRun: true, path: filePath, action: exists ? 'update' : 'create' };
+  }
+
+  // Ensure parent directory exists
+  const parentDir = path.dirname(filePath);
+  await fs.mkdir(parentDir, { recursive: true });
+
+  await fs.writeFile(filePath, content, encoding);
+  return { written: true, dryRun: false, path: filePath, action: exists ? 'update' : 'create' };
+}
+
+/**
+ * Safely creates a directory, supporting dry-run mode
+ */
+export async function safeMkdir(dirPath, options = {}) {
+  const { dryRun = false, recursive = true, reporter = null } = options;
+
+  if (reporter) {
+    reporter.recordDir(dirPath);
+  }
+
+  if (dryRun) {
+    return { created: false, dryRun: true, path: dirPath };
+  }
+
+  await fs.mkdir(dirPath, { recursive });
+  return { created: true, dryRun: false, path: dirPath };
+}
+
+/**
+ * Safely copies a file, supporting dry-run mode
+ */
+export async function safeCopyFile(srcPath, destPath, options = {}) {
+  const { dryRun = false, reporter = null } = options;
+
+  let exists = false;
+  try {
+    await fs.access(destPath);
+    exists = true;
+  } catch {
+    exists = false;
+  }
+
+  if (reporter) {
+    if (exists) {
+      reporter.recordUpdate(destPath);
+    } else {
+      reporter.recordCreate(destPath);
+    }
+  }
+
+  if (dryRun) {
+    return { copied: false, dryRun: true, path: destPath, action: exists ? 'update' : 'create' };
+  }
+
+  const parentDir = path.dirname(destPath);
+  await fs.mkdir(parentDir, { recursive: true });
+  await fs.copyFile(srcPath, destPath);
+  return { copied: true, dryRun: false, path: destPath, action: exists ? 'update' : 'create' };
+}