bigpowers 1.3.2 → 1.4.0

package/dashboard/src/loaders/watcher.js

@@ -0,0 +1,108 @@
+const EventEmitter = require('events');
+const fs = require('fs');
+const path = require('path');
+
+let chokidar;
+try {
+  chokidar = require('chokidar');
+} catch (err) {
+  chokidar = null;
+}
+
+function watch(projectRoot) {
+  const emitter = new EventEmitter();
+  const debounceTimers = {};
+
+  function notifyChange(file) {
+    const key = file;
+    if (debounceTimers[key]) {
+      clearTimeout(debounceTimers[key]);
+    }
+    debounceTimers[key] = setTimeout(() => {
+      emitter.emit('change', { file, data: null });
+      delete debounceTimers[key];
+    }, 300);
+  }
+
+  if (chokidar) {
+    const filesToWatch = [
+      path.join(projectRoot, 'specs/state.yaml'),
+      path.join(projectRoot, 'specs/execution-status.yaml'),
+      path.join(projectRoot, 'specs/metrics/cycle-times.yaml'),
+      path.join(projectRoot, 'specs/epics')
+    ];
+
+    const watcher = chokidar.watch(filesToWatch, {
+      persistent: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 100
+      }
+    });
+
+    watcher.on('change', (file) => {
+      notifyChange(file);
+    });
+
+    watcher.on('add', (file) => {
+      notifyChange(file);
+    });
+
+    emitter.close = () => watcher.close();
+  } else {
+    const fileStats = {};
+    const filesToWatch = [
+      path.join(projectRoot, 'specs/state.yaml'),
+      path.join(projectRoot, 'specs/execution-status.yaml'),
+      path.join(projectRoot, 'specs/metrics/cycle-times.yaml')
+    ];
+
+    const pollInterval = setInterval(() => {
+      filesToWatch.forEach((file) => {
+        try {
+          const stat = fs.statSync(file);
+          const mtime = stat.mtime.getTime();
+
+          if (!fileStats[file]) {
+            fileStats[file] = mtime;
+          } else if (fileStats[file] !== mtime) {
+            fileStats[file] = mtime;
+            notifyChange(file);
+          }
+        } catch (err) {
+          // File doesn't exist yet or was deleted
+          if (fileStats[file]) {
+            delete fileStats[file];
+            notifyChange(file);
+          }
+        }
+      });
+
+      // Check specs/epics directory
+      const epicsDir = path.join(projectRoot, 'specs/epics');
+      try {
+        const entries = fs.readdirSync(epicsDir);
+        entries.forEach((entry) => {
+          const fullPath = path.join(epicsDir, entry);
+          const stat = fs.statSync(fullPath);
+          const mtime = stat.mtime.getTime();
+
+          if (!fileStats[fullPath]) {
+            fileStats[fullPath] = mtime;
+          } else if (fileStats[fullPath] !== mtime) {
+            fileStats[fullPath] = mtime;
+            notifyChange(fullPath);
+          }
+        });
+      } catch (err) {
+        // epics directory doesn't exist yet
+      }
+    }, 200);
+
+    emitter.close = () => clearInterval(pollInterval);
+  }
+
+  return emitter;
+}
+
+module.exports = { watch };

package/dashboard/src/tui/epic-queue.js

@@ -0,0 +1,36 @@
+const { gateIcon, gateColor } = require('../loaders/gate-status');
+
+function renderEpicQueue(box, epics, executionStatus) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  if (!epics || epics.length === 0) {
+    box.setContent('{dim}no epic shards found{/dim}');
+    return;
+  }
+
+  let lines = [];
+  let totalBcps = 0;
+
+  epics.forEach(epic => {
+    const epicStatusIcon = gateIcon[epic.status] || '?';
+    lines.push(`${epicStatusIcon} ${epic.id} ${epic.title}`);
+
+    if (epic.stories && epic.stories.length > 0) {
+      epic.stories.forEach(story => {
+        const storyStatusIcon = gateIcon[story.status] || '?';
+        const bcpCount = story.bcps || 0;
+        totalBcps += bcpCount;
+        lines.push(`  ${storyStatusIcon} ${story.id} ${story.title} (${bcpCount} BCPs)`);
+      });
+    }
+  });
+
+  lines.push('');
+  lines.push(`Total: ${totalBcps} BCPs`);
+
+  box.setContent(lines.join('\n'));
+}
+
+module.exports = { renderEpicQueue };

package/dashboard/src/tui/filesystem.js

@@ -0,0 +1,95 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+function renderFilesystem(box, projectRoot) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  const specsPath = path.join(projectRoot, 'specs');
+
+  if (!fs.existsSync(specsPath)) {
+    box.setContent(chalk.dim('{center}specs/ not found{/center}'));
+    return;
+  }
+
+  const now = Date.now();
+  const lines = [];
+  lines.push('{bold}{cyan}Filesystem{/cyan}{/bold}');
+
+  let fileCount = 0;
+
+  try {
+    const entries = fs.readdirSync(specsPath, { withFileTypes: true });
+
+    // Count files for badge
+    function countFiles(dir, depth = 0) {
+      if (depth > 1) return 0;
+      let count = 0;
+      try {
+        const dirEntries = fs.readdirSync(dir, { withFileTypes: true });
+        dirEntries.forEach((entry) => {
+          if (entry.isFile()) count++;
+          else if (entry.isDirectory() && depth < 1) {
+            count += countFiles(path.join(dir, entry.name), depth + 1);
+          }
+        });
+      } catch (e) {
+        // ignore
+      }
+      return count;
+    }
+
+    fileCount = countFiles(specsPath);
+    lines.push(`{dim}[${fileCount} files]{/dim}`);
+    lines.push('');
+
+    // Build tree
+    function buildTree(dir, prefix = '', depth = 0) {
+      if (depth > 1) return;
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        entries.forEach((entry, index) => {
+          const isLast = index === entries.length - 1;
+          const connector = isLast ? '└─ ' : '├─ ';
+          const fullPath = path.join(dir, entry.name);
+
+          let displayName = entry.name;
+
+          if (entry.isDirectory()) {
+            displayName = chalk.blue(displayName);
+            lines.push(prefix + connector + displayName);
+
+            if (depth < 1) {
+              const childPrefix =
+                prefix + (isLast ? '   ' : '│  ');
+              buildTree(fullPath, childPrefix, depth + 1);
+            }
+          } else if (entry.isFile()) {
+            // Check if modified in last 60 seconds
+            const stat = fs.statSync(fullPath);
+            const mtime = stat.mtimeMs;
+            const age = now - mtime;
+
+            if (age < 60000) {
+              displayName = chalk.yellow(displayName + ' ★');
+            }
+
+            lines.push(prefix + connector + displayName);
+          }
+        });
+      } catch (e) {
+        // ignore
+      }
+    }
+
+    buildTree(specsPath);
+  } catch (err) {
+    lines.push(chalk.dim('Error reading specs/'));
+  }
+
+  box.setContent(lines.join('\n'));
+}
+
+module.exports = { renderFilesystem };

package/dashboard/src/tui/index.js

@@ -0,0 +1,161 @@
+const path = require('path');
+const { watch } = require('../loaders/watcher');
+const { readStateYaml, readExecutionStatus, readEpicShards, readCycleTimes } = require('../loaders/reader');
+const { getMetrics } = require('../loaders/metrics');
+const { renderPipeline } = require('./pipeline');
+const { renderEpicQueue } = require('./epic-queue');
+const { renderMetricsBar } = require('./metrics-bar');
+const { renderStateYaml } = require('./state-yaml');
+const { renderFilesystem } = require('./filesystem');
+const { renderLedger } = require('./ledger');
+
+let blessed;
+try {
+  blessed = require('blessed');
+} catch (err) {
+  blessed = null;
+}
+
+function start(projectRoot) {
+  if (!blessed) {
+    console.error('Error: blessed module is not installed. Please run: npm install blessed');
+    process.exit(1);
+  }
+
+  // Create screen
+  const screen = blessed.screen({
+    smartCSR: true,
+    mouse: true,
+    title: 'BigPowers Dashboard',
+    256: true,
+    fullUnicode: true
+  });
+
+  // Check terminal size
+  if (screen.width < 120 || screen.height < 30) {
+    const msg = blessed.box({
+      parent: screen,
+      top: 'center',
+      left: 'center',
+      width: 60,
+      height: 10,
+      content: '{center}Terminal must be at least 120x30{/center}\n{center}Please resize and try again{/center}',
+      border: 'line',
+      style: { border: { fg: 'yellow' } }
+    });
+    screen.render();
+    return;
+  }
+
+  // Create layout zones
+  const metricsBar = blessed.box({
+    parent: screen,
+    top: 0,
+    left: 0,
+    width: '100%',
+    height: 3,
+    border: 'line',
+    style: { border: { fg: 'blue' } }
+  });
+
+  const pipeline = blessed.box({
+    parent: screen,
+    top: 3,
+    left: 0,
+    width: '100%',
+    height: 5,
+    border: 'line',
+    style: { border: { fg: 'cyan' } }
+  });
+
+  const epicQueue = blessed.box({
+    parent: screen,
+    top: 8,
+    left: 0,
+    width: '33%',
+    height: screen.height - 20,
+    border: 'line',
+    scrollable: true,
+    mouse: true,
+    keys: true,
+    style: { border: { fg: 'green' } }
+  });
+
+  const actionLog = blessed.box({
+    parent: screen,
+    top: 8,
+    left: '33%',
+    width: '33%',
+    height: screen.height - 20,
+    border: 'line',
+    scrollable: true,
+    mouse: true,
+    keys: true,
+    style: { border: { fg: 'yellow' } }
+  });
+
+  const fsPanel = blessed.box({
+    parent: screen,
+    top: 8,
+    left: '66%',
+    width: '34%',
+    height: screen.height - 20,
+    border: 'line',
+    scrollable: true,
+    mouse: true,
+    keys: true,
+    style: { border: { fg: 'magenta' } }
+  });
+
+  const ledger = blessed.box({
+    parent: screen,
+    top: screen.height - 12,
+    left: 0,
+    width: '100%',
+    height: 12,
+    border: 'line',
+    scrollable: true,
+    mouse: true,
+    keys: true,
+    style: { border: { fg: 'white' } }
+  });
+
+  // Refresh function
+  function refresh() {
+    const stateData = readStateYaml(projectRoot);
+    const executionStatus = readExecutionStatus(projectRoot);
+    const epics = readEpicShards(projectRoot);
+    const cycleTimes = readCycleTimes(projectRoot);
+    const metrics = getMetrics(cycleTimes);
+
+    renderMetricsBar(metricsBar, metrics, stateData);
+    renderPipeline(pipeline, stateData);
+    renderEpicQueue(epicQueue, epics, executionStatus);
+    renderStateYaml(actionLog, stateData);
+    renderFilesystem(fsPanel, projectRoot);
+    renderLedger(ledger, cycleTimes);
+
+    screen.render();
+  }
+
+  // Set up file watcher
+  const watcher = watch(projectRoot);
+  watcher.on('change', () => {
+    refresh();
+  });
+
+  // Initial refresh
+  refresh();
+
+  // Key bindings
+  screen.key(['q', 'C-c'], () => {
+    watcher.close();
+    process.exit(0);
+  });
+
+  screen.key(['r'], () => {
+    refresh();
+  });
+}
+
+module.exports = { start };

package/dashboard/src/tui/ledger.js

@@ -0,0 +1,66 @@
+const chalk = require('chalk');
+
+function renderLedger(box, cycleTimes) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  if (!cycleTimes || cycleTimes.length === 0) {
+    box.setContent(chalk.dim('{center}no completed stories yet{/center}'));
+    return;
+  }
+
+  const lines = [];
+  lines.push('{bold}{cyan}Ledger{/cyan}{/bold}');
+  lines.push('');
+
+  // Header row
+  lines.push(
+    '{bold}' +
+    '{cyan}Story ID{/cyan}  ' +
+    '{cyan}Epic{/cyan}  ' +
+    '{cyan}BCPs{/cyan}  ' +
+    '{cyan}Minutes{/cyan}  ' +
+    '{cyan}BCP/hr{/cyan}' +
+    '{/bold}'
+  );
+
+  let totalBCPs = 0;
+  let totalMinutes = 0;
+
+  // Data rows
+  cycleTimes.forEach((cycle) => {
+    const storyId = cycle.story_id || '—';
+    const epicPrefix = cycle.epic || '—';
+    const bcps = cycle.bcps || 0;
+    const minutes = cycle.cycle_minutes || 0;
+    const bcpPerHour = minutes > 0 ? ((bcps * 60) / minutes).toFixed(1) : '—';
+
+    totalBCPs += bcps;
+    totalMinutes += minutes;
+
+    lines.push(
+      `  ${storyId}  ` +
+      `${epicPrefix}  ` +
+      `${bcps}  ` +
+      `${minutes}  ` +
+      `${bcpPerHour}`
+    );
+  });
+
+  lines.push('');
+
+  // Totals row
+  const avgBcpPerHour =
+    totalMinutes > 0 ? ((totalBCPs * 60) / totalMinutes).toFixed(1) : '—';
+
+  lines.push(
+    '{bold}{yellow}' +
+    `TOTAL  —  ${totalBCPs}  ${totalMinutes}  ${avgBcpPerHour}` +
+    '{/yellow}{/bold}'
+  );
+
+  box.setContent(lines.join('\n'));
+}
+
+module.exports = { renderLedger };

package/dashboard/src/tui/metrics-bar.js

@@ -0,0 +1,30 @@
+function renderMetricsBar(box, projectMetrics, stateData) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  const totalBcps = projectMetrics?.totalBcps ?? '-';
+  const totalMin = projectMetrics?.totalMin ?? '-';
+  const avgBcpPerHour = projectMetrics?.avgBcpPerHour ?? '-';
+  const version = stateData?.release?.target_version ?? '-';
+
+  let bcpHrColor = 'white';
+  if (typeof avgBcpPerHour === 'number') {
+    if (avgBcpPerHour >= 2.0) {
+      bcpHrColor = 'green';
+    } else if (avgBcpPerHour >= 1.0) {
+      bcpHrColor = 'yellow';
+    } else {
+      bcpHrColor = 'red';
+    }
+  }
+
+  const avgCycleTime = totalMin === '-' ? '-' : `${totalMin}m`;
+  const bcpHrDisplay = typeof avgBcpPerHour === 'number' ? avgBcpPerHour.toFixed(2) : avgBcpPerHour;
+
+  const line = `BCPs: ${totalBcps} | Cycle: ${avgCycleTime} | {${bcpHrColor}}BCP/hr: ${bcpHrDisplay}{/${bcpHrColor}} | v${version}`;
+
+  box.setContent(line);
+}
+
+module.exports = { renderMetricsBar };

package/dashboard/src/tui/pipeline.js

@@ -0,0 +1,46 @@
+const { STEPS } = require('../loaders/pipeline-map');
+
+function renderPipeline(box, stateData) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  if (!stateData) {
+    box.setContent('{dim}state.yaml not loaded{/dim}');
+    return;
+  }
+
+  const currentStep = stateData.epicCycle?.current_step || null;
+  const completedSteps = stateData.epicCycle?.completed_steps || [];
+
+  // Build pipeline visualization
+  const lines = [];
+  lines.push('{bold}{cyan}Pipeline{/cyan}{/bold}');
+  lines.push('');
+
+  // Create step display
+  const stepDisplay = STEPS.map((step, index) => {
+    const isCompleted = completedSteps.includes(step);
+    const isCurrent = step === currentStep;
+
+    let display = `  ${index + 1}. ${step}`;
+
+    if (isCurrent) {
+      display = `{reverse}{bold}${display}{/bold}{/reverse}`;
+    } else if (isCompleted) {
+      display = `{green-fg}${display}{/green-fg}`;
+    } else {
+      display = `{gray-fg}${display}{/gray-fg}`;
+    }
+
+    return display;
+  }).join('\n');
+
+  lines.push(stepDisplay);
+  lines.push('');
+  lines.push(`{dim}Current: ${currentStep || '—'}{/dim}`);
+
+  box.setContent(lines.join('\n'));
+}
+
+module.exports = { renderPipeline };

package/dashboard/src/tui/state-yaml.js

@@ -0,0 +1,49 @@
+const chalk = require('chalk');
+
+function renderStateYaml(box, stateData) {
+  if (!box || typeof box.setContent !== 'function') {
+    return;
+  }
+
+  if (!stateData) {
+    box.setContent(chalk.dim('{center}state.yaml not found{/center}'));
+    return;
+  }
+
+  const lines = [];
+  lines.push('{bold}{cyan}state.yaml{/cyan}{/bold}');
+  lines.push('');
+
+  const pairs = [
+    { key: 'active_flow', value: stateData.active_flow },
+    { key: 'active_epic', value: stateData.active_epic },
+    { key: 'active_story', value: stateData.active_story },
+    { key: 'current_step', value: stateData.current_step },
+    { key: 'next_skill', value: stateData.next_skill },
+    { key: 'git.branch', value: stateData.git?.branch },
+    { key: 'metrics.story_start', value: stateData.metrics?.story_start },
+  ];
+
+  pairs.forEach(({ key, value }) => {
+    let displayValue = String(value || '—');
+
+    // Color rules
+    if (key === 'git.branch') {
+      if (displayValue === 'main') {
+        displayValue = chalk.green(displayValue);
+      } else if (displayValue.startsWith('feat/')) {
+        displayValue = chalk.yellow(displayValue);
+      }
+    }
+
+    if (key === 'next_skill' && value) {
+      displayValue = chalk.green(displayValue);
+    }
+
+    lines.push(`  {dim}${key}:{/dim} ${displayValue}`);
+  });
+
+  box.setContent(lines.join('\n'));
+}
+
+module.exports = { renderStateYaml };