@sienklogic/plan-build-run 2.19.0 → 2.19.2

package/dashboard/server/routes/telemetry.js

@@ -0,0 +1,233 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Get the path to the current hook log file.
+ * Prefers today's dated file, falls back to most recent, then legacy hooks.jsonl.
+ */
+function getHookLogPath(planningDir) {
+  const today = new Date().toISOString().slice(0, 10);
+  const dated = path.join(planningDir, 'logs', `hooks-${today}.jsonl`);
+  if (fs.existsSync(dated)) return dated;
+  const logsDir = path.join(planningDir, 'logs');
+  try {
+    const files = fs.readdirSync(logsDir)
+      .filter(f => /^hooks-\d{4}-\d{2}-\d{2}\.jsonl$/.test(f))
+      .sort()
+      .reverse();
+    if (files.length > 0) return path.join(logsDir, files[0]);
+  } catch (_e) { /* no logs dir */ }
+  return path.join(planningDir, 'logs', 'hooks.jsonl');
+}
+
+/**
+ * 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 = getHookLogPath(planningDir);
+      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,
+      }));
+
+      // Session history -- read sessions.jsonl for session metrics
+      let sessions = [];
+      let sessionAggregates = { avgDuration: 0, avgAgents: 0, avgCompliance: 0, totalSessions: 0 };
+      try {
+        const sessionsPath = path.join(planningDir, 'logs', 'sessions.jsonl');
+        const sessionsRaw = await fs.promises.readFile(sessionsPath, 'utf-8');
+        const allSessions = sessionsRaw
+          .split('\n')
+          .filter(line => line.trim())
+          .map(line => {
+            try { return JSON.parse(line); } catch (_e) { return null; }
+          })
+          .filter(Boolean);
+
+        sessionAggregates.totalSessions = allSessions.length;
+
+        // Take last 20 entries (most recent)
+        sessions = allSessions.slice(-20).map(s => ({
+          start: s.start || null,
+          end: s.end || null,
+          duration_minutes: s.duration_minutes || 0,
+          agents_spawned: s.agents_spawned || 0,
+          commits_created: s.commits_created || 0,
+          plans_executed: s.plans_executed || 0,
+          compliance_pct: s.compliance_pct || 0,
+          feedback_loops_triggered: s.feedback_loops_triggered || 0,
+        }));
+
+        // Compute aggregates over all sessions
+        if (allSessions.length > 0) {
+          const sumDuration = allSessions.reduce((sum, s) => sum + (s.duration_minutes || 0), 0);
+          const sumAgents = allSessions.reduce((sum, s) => sum + (s.agents_spawned || 0), 0);
+          const sumCompliance = allSessions.reduce((sum, s) => sum + (s.compliance_pct || 0), 0);
+          sessionAggregates.avgDuration = Math.round((sumDuration / allSessions.length) * 10) / 10;
+          sessionAggregates.avgAgents = Math.round((sumAgents / allSessions.length) * 10) / 10;
+          sessionAggregates.avgCompliance = Math.round((sumCompliance / allSessions.length) * 10) / 10;
+        }
+      } catch (_e) {
+        // Missing sessions.jsonl — return empty defaults
+      }
+
+      res.json({
+        metrics,
+        tokenHistory,
+        phaseDistribution,
+        subagents,
+        successData,
+        subagentPerf,
+        contextRadar: {},
+        sessions,
+        sessionAggregates,
+      });
+    } 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 };