@sienklogic/plan-build-run 2.0.2 → 2.1.1

package/dashboard/server/routes/requirements.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const express = require('express');
+const path = require('path');
+const { safeReadFile } = require('../services/planning-reader');
+
+/**
+ * Requirements route factory.
+ * Parses REQUIREMENTS.md and returns structured requirement data.
+ *
+ * @param {import('../services/planning-reader').PlanningReader} planningReader
+ * @returns {express.Router}
+ */
+function createRequirementsRouter(planningReader) {
+  const router = express.Router();
+
+  router.get('/', async (_req, res) => {
+    try {
+      const content = await safeReadFile(path.join(planningReader.planningDir, 'REQUIREMENTS.md'));
+      if (!content) return res.json({ requirements: [], sections: [] });
+      const reqs = [];
+      const regex = /^- \[([ x])\] \*\*(\w+-\d+)\*\*:\s*(.+)$/gm;
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        reqs.push({
+          id: match[2],
+          description: match[3].trim(),
+          status: match[1] === 'x' ? 'complete' : 'pending',
+        });
+      }
+      res.json({ requirements: reqs });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createRequirementsRouter;

package/dashboard/server/routes/roadmap.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const express = require('express');
+
+/**
+ * Roadmap route factory.
+ * Reads ROADMAP.md via PlanningReader and returns structured milestone + phase data.
+ *
+ * @param {import('../services/planning-reader').PlanningReader} planningReader
+ * @returns {express.Router}
+ */
+function createRoadmapRouter(planningReader) {
+  const router = express.Router();
+
+  /**
+   * GET /phases/:slug - Return detail for a single phase (plans, summaries, verifications, context).
+   */
+  router.get('/phases/:slug', async (req, res) => {
+    try {
+      const detail = await planningReader.getPhaseDetail(req.params.slug);
+      const isEmpty = detail.plans.length === 0 && detail.summaries.length === 0
+        && detail.verifications.length === 0 && detail.context.length === 0;
+      if (isEmpty) {
+        return res.status(404).json({ error: 'Phase not found' });
+      }
+      res.json(detail);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET / - Return roadmap phases with milestone header info.
+   */
+  router.get('/', async (_req, res) => {
+    try {
+      const [milestones, phases] = await Promise.all([
+        planningReader.getMilestones(),
+        planningReader.getRoadmapPhases(),
+      ]);
+
+      // Build milestone header from first active (or only) milestone
+      const activeMilestone = milestones.find(m => !m.archived) || milestones[0] || null;
+      const milestone = activeMilestone ? {
+        name: activeMilestone.name,
+        goal: activeMilestone.description || null,
+        phaseCount: phases.length,
+        reqCoverage: null,
+      } : null;
+
+      // Backward compat: also include flat items array
+      const items = milestones.map((ms, i) => ({
+        id: ms.id || `ms-${i}`,
+        title: ms.title || ms.name,
+        tier: ms.archived ? 1 : (ms.version ? 2 : 3),
+        st: ms.archived ? 'done' : 'in-progress',
+        s: ms.version || '-',
+      }));
+
+      res.json({ milestone, phases, items });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createRoadmapRouter;

package/dashboard/server/routes/status.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const express = require('express');
+
+/**
+ * Status route factory.
+ * @param {import('../services/planning-reader').PlanningReader} planningReader
+ * @returns {express.Router}
+ */
+function createStatusRouter(planningReader) {
+  const router = express.Router();
+
+  router.get('/', async (_req, res) => {
+    try {
+      const status = await planningReader.getStatus();
+      res.json(status);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createStatusRouter;

package/dashboard/server/routes/telemetry.js

@@ -0,0 +1,171 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Telemetry route factory.
+ * Reads hook event log and telemetry data from .planning/.
+ *
+ * @param {object} options
+ * @param {string} options.planningDir - Path to .planning/ directory
+ * @returns {express.Router}
+ */
+function createTelemetryRouter({ planningDir }) {
+  const router = express.Router();
+
+  /**
+   * GET / - Return telemetry metrics.
+   * Reads logs/hooks.jsonl for aggregate metrics.
+   */
+  router.get('/', async (_req, res) => {
+    try {
+      const eventsPath = path.join(planningDir, 'logs', 'hooks.jsonl');
+      let events = [];
+
+      try {
+        const raw = await fs.promises.readFile(eventsPath, 'utf-8');
+        events = raw
+          .split('\n')
+          .filter(line => line.trim())
+          .map(line => {
+            try { return JSON.parse(line); } catch (_e) { return null; }
+          })
+          .filter(Boolean);
+      } catch (_e) {
+        // No events file -- return empty metrics
+      }
+
+      // Count unique hook types
+      const hookTypeCounts = {};
+      for (const evt of events) {
+        const hook = evt.hook || evt.event || evt.type || 'unknown';
+        hookTypeCounts[hook] = (hookTypeCounts[hook] || 0) + 1;
+      }
+      const uniqueHookTypeCount = Object.keys(hookTypeCounts).length;
+
+      // Count events in last 24 hours
+      const now = Date.now();
+      const oneDayAgo = now - 24 * 60 * 60 * 1000;
+      const recentEventCount = events.filter(evt => {
+        const ts = evt.ts || evt.time;
+        if (!ts) return false;
+        const evtTime = new Date(ts).getTime();
+        return !isNaN(evtTime) && evtTime >= oneDayAgo;
+      }).length;
+
+      const metrics = {
+        totalEvents: events.length,
+        hookTypes: uniqueHookTypeCount,
+        recentEvents: recentEventCount,
+      };
+
+      // tokenHistory -- group events by date, count per day (last 14 days)
+      const dayMap = {};
+      for (const evt of events) {
+        const ts = evt.ts || evt.time;
+        if (!ts) continue;
+        const d = new Date(ts);
+        if (isNaN(d.getTime())) continue;
+        const dateStr = d.toISOString().slice(0, 10);
+        dayMap[dateStr] = (dayMap[dateStr] || 0) + 1;
+      }
+      const today = new Date();
+      const tokenHistory = [];
+      for (let i = 13; i >= 0; i--) {
+        const d = new Date(today);
+        d.setDate(d.getDate() - i);
+        const dateStr = d.toISOString().slice(0, 10);
+        tokenHistory.push({ date: dateStr, tokens: dayMap[dateStr] || 0 });
+      }
+
+      // phaseDistribution -- derive phase from hook name patterns
+      function derivePhase(evt) {
+        const hook = (evt.hook || evt.event || evt.type || '').toLowerCase();
+        const category = (evt.category || '').toLowerCase();
+        if (hook.includes('plan') || category.includes('plan')) return 'Plan';
+        if (hook.includes('build') || category.includes('build')) return 'Build';
+        if (hook.includes('review') || category.includes('review')) return 'Review';
+        return 'Run';
+      }
+
+      const phaseCounts = {};
+      for (const evt of events) {
+        const phase = derivePhase(evt);
+        phaseCounts[phase] = (phaseCounts[phase] || 0) + 1;
+      }
+      const phaseDistribution = Object.entries(phaseCounts).map(([name, value]) => ({ name, value }));
+
+      // subagents -- map last 20 events into subagent-like shape
+      function formatDuration(evt) {
+        const dur = evt.duration;
+        if (dur == null) return '-';
+        if (typeof dur === 'number') {
+          if (dur < 1000) return `${dur}ms`;
+          return `${(dur / 1000).toFixed(1)}s`;
+        }
+        return String(dur);
+      }
+
+      const subagents = events.slice(-20).map(evt => ({
+        name: evt.hook || evt.event || 'unknown',
+        task: evt.tool || '-',
+        phase: derivePhase(evt),
+        model: '-',
+        tokens: 0,
+        time: formatDuration(evt),
+        status: evt.status || 'success',
+      }));
+
+      // successData -- group by date, compute success rate per day
+      const daySuccessMap = {};
+      for (const evt of events) {
+        const ts = evt.ts || evt.time;
+        if (!ts) continue;
+        const d = new Date(ts);
+        if (isNaN(d.getTime())) continue;
+        const dateStr = d.toISOString().slice(0, 10);
+        if (!daySuccessMap[dateStr]) {
+          daySuccessMap[dateStr] = { total: 0, success: 0 };
+        }
+        daySuccessMap[dateStr].total++;
+        const status = evt.status || (evt.level === 'error' ? 'error' : 'success');
+        if (status === 'success') {
+          daySuccessMap[dateStr].success++;
+        }
+      }
+      const successData = [];
+      for (let i = 13; i >= 0; i--) {
+        const d = new Date(today);
+        d.setDate(d.getDate() - i);
+        const dateStr = d.toISOString().slice(0, 10);
+        const entry = daySuccessMap[dateStr];
+        const rate = entry ? Math.round((entry.success / entry.total) * 100) : 0;
+        successData.push({ date: dateStr, rate });
+      }
+
+      // subagentPerf -- per-hook-type performance data
+      const subagentPerf = Object.entries(hookTypeCounts).map(([name, count]) => ({
+        name,
+        count,
+      }));
+
+      res.json({
+        metrics,
+        tokenHistory,
+        phaseDistribution,
+        subagents,
+        successData,
+        subagentPerf,
+        contextRadar: {},
+      });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createTelemetryRouter;

package/dashboard/server/services/file-watcher.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const chokidar = require('chokidar');
+const EventEmitter = require('events');
+const path = require('path');
+
+/**
+ * Classify a file change event based on its path relative to the planning dir.
+ * @param {string} filePath - Absolute path of the changed file
+ * @param {string} planningDir - Root planning directory
+ * @returns {string} Event type: "phase", "event", or "context"
+ */
+function classifyEvent(filePath, planningDir) {
+  const rel = path.relative(planningDir, filePath).replace(/\\/g, '/');
+
+  if (rel.startsWith('phases/') || rel.startsWith('phases\\')) return 'phase';
+  if (rel === 'ROADMAP.md') return 'phase';
+  if (rel === 'STATE.md') return 'event';
+  if (rel === 'config.json') return 'event';
+  return 'context';
+}
+
+/**
+ * FileWatcher watches a .planning/ directory for changes and emits
+ * LiveEvent-shaped objects via the 'event' event.
+ *
+ * @extends EventEmitter
+ */
+class FileWatcher extends EventEmitter {
+  /**
+   * @param {string} planningDir - Absolute path to .planning/ directory
+   * @param {object} [options]
+   * @param {number} [options.debounceMs=100] - Debounce interval in ms
+   */
+  constructor(planningDir, options = {}) {
+    super();
+    this.planningDir = planningDir;
+    this.debounceMs = options.debounceMs || 100;
+    this.watcher = null;
+    this._pendingEvents = new Map();
+    this._debounceTimer = null;
+  }
+
+  /**
+   * Start watching the planning directory.
+   * @returns {Promise<void>} Resolves when watcher is ready.
+   */
+  start() {
+    return new Promise((resolve) => {
+      this.watcher = chokidar.watch(this.planningDir, {
+        ignoreInitial: true,
+        awaitWriteFinish: { stabilityThreshold: 300 },
+      });
+
+      this.watcher.on('ready', () => resolve());
+
+      const handleChange = (changeType, filePath) => {
+        // Debounce: store pending event keyed by file path
+        this._pendingEvents.set(filePath, { changeType, filePath });
+
+        if (this._debounceTimer) {
+          clearTimeout(this._debounceTimer);
+        }
+
+        this._debounceTimer = setTimeout(() => {
+          for (const [, entry] of this._pendingEvents) {
+            const type = classifyEvent(entry.filePath, this.planningDir);
+            const rel = path.relative(this.planningDir, entry.filePath).replace(/\\/g, '/');
+            this.emit('event', {
+              ts: new Date().toISOString(),
+              type,
+              source: 'file-watcher',
+              msg: `${entry.changeType}: ${rel}`,
+              level: 'info',
+            });
+          }
+          this._pendingEvents.clear();
+          this._debounceTimer = null;
+        }, this.debounceMs);
+      };
+
+      this.watcher.on('add', (fp) => handleChange('add', fp));
+      this.watcher.on('change', (fp) => handleChange('change', fp));
+      this.watcher.on('unlink', (fp) => handleChange('unlink', fp));
+    });
+  }
+
+  /**
+   * Stop watching and clean up.
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (this._debounceTimer) {
+      clearTimeout(this._debounceTimer);
+      this._debounceTimer = null;
+    }
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+    }
+    this._pendingEvents.clear();
+  }
+}
+
+module.exports = { FileWatcher, classifyEvent };