@sienklogic/plan-build-run 2.19.0 → 2.19.2

package/dashboard/server/routes/agents.js

@@ -0,0 +1,234 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * 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;
+  // Fallback: find most recent hooks-*.jsonl
+  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 */ }
+  // Last fallback: legacy filename
+  return path.join(planningDir, 'logs', 'hooks.jsonl');
+}
+
+/**
+ * Agents route factory.
+ * Reads agent definitions from plugins/pbr/agents/*.md.
+ * Also provides hooks and errors sub-endpoints.
+ *
+ * @param {object} options
+ * @param {string} options.planningDir - Path to .planning/ directory
+ * @param {string} [options.agentsDir] - Path to agents directory (default: plugins/pbr/agents)
+ * @returns {express.Router}
+ */
+function createAgentsRouter({ planningDir, agentsDir }) {
+  // Check multiple possible agent definition directories
+  const candidates = [
+    agentsDir,
+    path.join(planningDir, '..', 'plugins', 'pbr', 'agents'),
+    path.join(planningDir, '..', '.claude', 'agents'),
+    path.join(planningDir, '..', '.claude', 'plan-build-run', 'agents'),
+  ].filter(Boolean);
+  const resolvedAgentsDir = candidates.find(d => {
+    try { return fs.statSync(d).isDirectory(); } catch (_e) { return false; }
+  }) || candidates[0];
+
+  const router = express.Router();
+
+  /**
+   * GET / - Return list of agent definitions.
+   */
+  router.get('/', async (_req, res) => {
+    try {
+      let files = [];
+      try {
+        files = await fs.promises.readdir(resolvedAgentsDir);
+      } catch (_e) {
+        return res.json([]);
+      }
+
+      const items = [];
+      let idx = 0;
+
+      // Parse agents
+      for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        try {
+          const content = await fs.promises.readFile(
+            path.join(resolvedAgentsDir, file), 'utf-8'
+          );
+          const fm = parseFrontmatter(content).frontmatter;
+          const toolsMatch = content.match(/tools:\s*\n((?:\s+-\s+.+\n?)*)/);
+          const tools = toolsMatch
+            ? toolsMatch[1].split('\n').map(l => l.replace(/^\s*-\s*/, '').trim()).filter(Boolean)
+            : [];
+          items.push({
+            id: `agent-${idx++}`,
+            type: 'agent',
+            file,
+            name: fm.name || file.replace('.md', ''),
+            role: fm.description || '',
+            model: fm.model || 'inherit',
+            memory: fm.memory || 'none',
+            contextSlots: [],
+            totalContextBudget: '200k',
+            maxAllowed: fm.model === 'opus' ? '200k' : '180k',
+            hooks: [],
+            configKeys: [],
+            systemPrompt: null,
+            tools,
+          });
+        } catch (_e) {
+          // Skip unreadable files
+        }
+      }
+
+      // Parse skills
+      const skillsDir = path.join(resolvedAgentsDir, '..', 'skills');
+      try {
+        const skillDirs = await fs.promises.readdir(skillsDir, { withFileTypes: true });
+        for (const entry of skillDirs) {
+          if (!entry.isDirectory()) continue;
+          const skillFile = path.join(skillsDir, entry.name, 'SKILL.md');
+          try {
+            const content = await fs.promises.readFile(skillFile, 'utf-8');
+            const fm = parseFrontmatter(content).frontmatter;
+            items.push({
+              id: `skill-${idx++}`,
+              type: 'skill',
+              file: `skills/${entry.name}/SKILL.md`,
+              name: fm.name || entry.name,
+              role: fm.description || '',
+              model: null,
+              memory: null,
+              contextSlots: [],
+              totalContextBudget: '-',
+              maxAllowed: '-',
+              hooks: [],
+              configKeys: [],
+              systemPrompt: null,
+              tools: [],
+            });
+          } catch (_e) { /* skip */ }
+        }
+      } catch (_e) { /* no skills dir */ }
+
+      // Parse commands
+      const commandsDir = path.join(resolvedAgentsDir, '..', 'commands');
+      try {
+        const cmdFiles = await fs.promises.readdir(commandsDir);
+        for (const file of cmdFiles) {
+          if (!file.endsWith('.md')) continue;
+          items.push({
+            id: `cmd-${idx++}`,
+            type: 'command',
+            file: `commands/${file}`,
+            name: file.replace('.md', ''),
+            role: `Slash command /${file.replace('.md', '')}`,
+            model: null,
+            memory: null,
+            contextSlots: [],
+            totalContextBudget: '-',
+            maxAllowed: '-',
+            hooks: [],
+            configKeys: [],
+            systemPrompt: null,
+            tools: [],
+          });
+        }
+      } catch (_e) { /* no commands dir */ }
+
+      res.json(items);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /hooks - Return hook event log (last 100 events).
+   */
+  router.get('/hooks', 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
+      }
+
+      // Map to UI-expected shape
+      const mapped = events.slice(-100).map(evt => ({
+        time: evt.ts || evt.time || new Date().toISOString(),
+        hook: evt.event || evt.hook || 'unknown',
+        status: evt.status || (evt.level === 'error' ? 'error' : 'success'),
+        duration: evt.duration || '-',
+        payload: evt.tool || evt.payload || null,
+      }));
+
+      res.json({ events: mapped, config: null });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /errors - Return error entries from hook events.
+   */
+  router.get('/errors', async (_req, res) => {
+    try {
+      const eventsPath = getHookLogPath(planningDir);
+      let errors = [];
+
+      try {
+        const raw = await fs.promises.readFile(eventsPath, 'utf-8');
+        const events = raw
+          .split('\n')
+          .filter(line => line.trim())
+          .map(line => {
+            try { return JSON.parse(line); } catch (_e) { return null; }
+          })
+          .filter(Boolean);
+
+        errors = events.filter(evt =>
+          evt.level === 'error' ||
+          evt.type === 'error' ||
+          evt.status === 'error'
+        );
+      } catch (_e) {
+        // No events file
+      }
+
+      res.json(errors);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createAgentsRouter;

package/dashboard/server/routes/config.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const express = require('express');
+
+/**
+ * Config route factory.
+ * @param {import('../services/planning-reader').PlanningReader} planningReader
+ * @returns {express.Router}
+ */
+const VALID_MODES = ['autonomous', 'supervised', 'manual'];
+const VALID_DEPTHS = ['minimal', 'standard', 'thorough'];
+const VALID_STRATEGIES = ['conservative', 'balanced', 'aggressive'];
+
+function createConfigRouter(planningReader) {
+  const router = express.Router();
+
+  router.get('/', async (_req, res) => {
+    try {
+      const config = await planningReader.getConfig();
+      res.json(config);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  router.put('/', async (req, res) => {
+    try {
+      if (!req.body || typeof req.body !== 'object' || Array.isArray(req.body)) {
+        return res.status(400).json({ error: 'Request body must be a JSON object' });
+      }
+
+      const errors = [];
+      if (req.body.version !== undefined && (!Number.isInteger(req.body.version) || req.body.version < 1)) {
+        errors.push('version must be a positive integer');
+      }
+      if (req.body.mode !== undefined && !VALID_MODES.includes(req.body.mode)) {
+        errors.push('mode must be one of: ' + VALID_MODES.join(', '));
+      }
+      if (req.body.depth !== undefined && !VALID_DEPTHS.includes(req.body.depth)) {
+        errors.push('depth must be one of: ' + VALID_DEPTHS.join(', '));
+      }
+      if (req.body.context_strategy !== undefined && !VALID_STRATEGIES.includes(req.body.context_strategy)) {
+        errors.push('context_strategy must be one of: ' + VALID_STRATEGIES.join(', '));
+      }
+      for (const key of ['features', 'models', 'parallelization', 'planning', 'git', 'gates', 'safety']) {
+        if (req.body[key] !== undefined && (typeof req.body[key] !== 'object' || Array.isArray(req.body[key]) || req.body[key] === null)) {
+          errors.push(key + ' must be a plain object');
+        }
+      }
+      if (errors.length > 0) {
+        return res.status(400).json({ error: 'Validation error', details: errors });
+      }
+
+      const updated = await planningReader.writeConfig(req.body);
+      res.json(updated);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createConfigRouter;

package/dashboard/server/routes/health.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const express = require('express');
+const path = require('path');
+
+const router = express.Router();
+const startTime = Date.now();
+const pbrVersion = (() => {
+  try { return require('../../../../package.json').version; } catch (_e) { return 'unknown'; }
+})();
+
+/**
+ * Resolve the planning directory from request app config.
+ */
+function getPlanningDir(req) {
+  return req.app.locals.options.planningDir;
+}
+
+/**
+ * Load config from the planning directory.
+ */
+function loadConfig(planningDir) {
+  try {
+    const fs = require('fs');
+    const configPath = path.join(planningDir, 'config.json');
+    if (!fs.existsSync(configPath)) return {};
+    return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (_e) {
+    return {};
+  }
+}
+
+/**
+ * GET /api/health
+ * Returns server health information.
+ */
+router.get('/', (_req, res) => {
+  res.json({
+    status: 'ok',
+    uptime: Math.floor((Date.now() - startTime) / 1000),
+    version: pbrVersion,
+    timestamp: new Date().toISOString(),
+  });
+});
+
+/**
+ * GET /api/health/features
+ * Returns per-feature health status for Phase 15 DX features.
+ */
+router.get('/features', (req, res) => {
+  try {
+    const planningDir = getPlanningDir(req);
+    const config = loadConfig(planningDir);
+    const features = (config && config.features) || {};
+
+    const featureChecks = [
+      {
+        name: 'progress_visualization',
+        module: '../../../plugins/pbr/scripts/lib/progress-visualization.js',
+        fn: 'getProgressData',
+      },
+      {
+        name: 'contextual_help',
+        module: '../../../plugins/pbr/scripts/lib/contextual-help.js',
+        fn: 'getContextualHelp',
+      },
+      {
+        name: 'team_onboarding',
+        module: '../../../plugins/pbr/scripts/lib/onboarding-generator.js',
+        fn: 'generateOnboardingGuide',
+      },
+    ];
+
+    const results = featureChecks.map(({ name, module: modPath, fn }) => {
+      const enabled = features[name] !== false; // default true
+
+      if (!enabled) {
+        return { feature: name, enabled: false, status: 'disabled', detail: 'Feature disabled in config' };
+      }
+
+      try {
+        const mod = require(modPath);
+        const result = mod[fn](planningDir, config);
+        // If module returns enabled:false, it's degraded (STATE.md likely missing)
+        const status = result && result.enabled === false ? 'degraded' : 'healthy';
+        return { feature: name, enabled: true, status, detail: status === 'healthy' ? 'OK' : 'Module returned disabled stub' };
+      } catch (err) {
+        return { feature: name, enabled: true, status: 'degraded', detail: err.message };
+      }
+    });
+
+    res.json(results);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/dashboard/server/routes/incidents.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Incidents route factory.
+ * Reads incident JSONL files from .planning/incidents/ directory.
+ *
+ * @param {object} options
+ * @param {string} options.planningDir - Path to .planning/ directory
+ * @returns {express.Router}
+ */
+function createIncidentsRouter({ planningDir }) {
+  const router = express.Router();
+
+  /**
+   * GET / - Return parsed incident objects from .planning/incidents/.
+   * Reads all .jsonl files, parses each line as JSON, returns flat array
+   * sorted by timestamp descending.
+   * Supports ?severity= query param filter.
+   */
+  router.get('/', async (req, res) => {
+    try {
+      const incidentsDir = path.join(planningDir, 'incidents');
+      const severityFilter = req.query.severity;
+      const incidents = [];
+
+      let dirEntries = [];
+      try {
+        dirEntries = await fs.promises.readdir(incidentsDir);
+      } catch (_e) {
+        // No incidents directory — return empty
+        return res.json([]);
+      }
+
+      for (const file of dirEntries) {
+        if (!file.endsWith('.jsonl')) continue;
+        try {
+          const raw = await fs.promises.readFile(
+            path.join(incidentsDir, file), 'utf-8'
+          );
+          const lines = raw.split('\n').filter(line => line.trim());
+          for (const line of lines) {
+            try {
+              const obj = JSON.parse(line);
+              incidents.push(obj);
+            } catch (_e) {
+              // Skip malformed lines
+            }
+          }
+        } catch (_e) {
+          // Skip unreadable files
+        }
+      }
+
+      // Sort by timestamp descending
+      incidents.sort((a, b) => {
+        const tsA = a.timestamp || a.ts || '';
+        const tsB = b.timestamp || b.ts || '';
+        return tsB.localeCompare(tsA);
+      });
+
+      if (severityFilter) {
+        return res.json(incidents.filter(i => i.severity === severityFilter));
+      }
+
+      res.json(incidents);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createIncidentsRouter;

package/dashboard/server/routes/intel.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * Intel route factory.
+ * Reads intel data from .planning/intel/ directory.
+ *
+ * @param {object} options
+ * @param {string} options.planningDir - Path to .planning/ directory
+ * @returns {express.Router}
+ */
+function createIntelRouter({ planningDir }) {
+  const router = express.Router();
+
+  /**
+   * GET / - Return parsed intel data from .planning/intel/.
+   * JSON files (apis.json, deps.json, files.json, stack.json) are returned as keyed object.
+   * MD files are parsed with frontmatter and returned in a docs array.
+   */
+  router.get('/', async (_req, res) => {
+    try {
+      const intelDir = path.join(planningDir, 'intel');
+      const data = { apis: null, deps: null, files: null, stack: null, docs: [] };
+      const fileList = [];
+
+      let dirEntries = [];
+      try {
+        dirEntries = await fs.promises.readdir(intelDir);
+      } catch (_e) {
+        // No intel directory — return empty
+        return res.json({ data, files: [] });
+      }
+
+      for (const file of dirEntries) {
+        const filePath = path.join(intelDir, file);
+        fileList.push(file);
+
+        try {
+          if (file.endsWith('.json')) {
+            const raw = await fs.promises.readFile(filePath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const key = file.replace('.json', '');
+            if (key in data && key !== 'docs') {
+              data[key] = parsed;
+            }
+          } else if (file.endsWith('.md')) {
+            const raw = await fs.promises.readFile(filePath, 'utf-8');
+            const { frontmatter, body } = parseFrontmatter(raw);
+            data.docs.push({ file, ...frontmatter, body });
+          }
+        } catch (_e) {
+          // Skip unreadable files
+        }
+      }
+
+      res.json({ data, files: fileList });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createIntelRouter;

package/dashboard/server/routes/memory.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const { parseFrontmatter } = require('../lib/frontmatter');
+
+/**
+ * Memory route factory.
+ * Reads memory entries from .planning/memory/ or agent memory dirs.
+ * Also exposes PROJECT.md ## Context via /project-context sub-route.
+ *
+ * @param {object} options
+ * @param {string} options.planningDir - Path to .planning/ directory
+ * @param {import('../services/planning-reader').PlanningReader} [options.planningReader] - Optional PlanningReader instance
+ * @returns {express.Router}
+ */
+function createMemoryRouter({ planningDir, planningReader }) {
+  const router = express.Router();
+
+  /**
+   * GET / - Return memory entries, optionally filtered by ?type=
+   */
+  router.get('/', async (req, res) => {
+    try {
+      const typeFilter = req.query.type;
+      const memoryDir = path.join(planningDir, 'memory');
+      const entries = [];
+
+      let files = [];
+      try {
+        files = await fs.promises.readdir(memoryDir);
+      } catch (_e) {
+        // No memory directory — return empty
+        return res.json([]);
+      }
+
+      for (const file of files) {
+        if (!file.endsWith('.md')) continue;
+        try {
+          const content = await fs.promises.readFile(
+            path.join(memoryDir, file), 'utf-8'
+          );
+          const { frontmatter, body } = parseFrontmatter(content);
+          const entry = {
+            file,
+            type: frontmatter.type || 'general',
+            title: frontmatter.title || file.replace('.md', ''),
+            content: body.slice(0, 500),
+            ...frontmatter,
+          };
+          entries.push(entry);
+        } catch (_e) {
+          // Skip unreadable files
+        }
+      }
+
+      if (typeFilter) {
+        return res.json(entries.filter(e => e.type === typeFilter));
+      }
+
+      res.json(entries);
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  /**
+   * GET /project-context - Return ## Context section from PROJECT.md.
+   * Falls back to legacy CONTEXT.md if PROJECT.md has no ## Context.
+   */
+  router.get('/project-context', async (_req, res) => {
+    try {
+      if (planningReader && typeof planningReader.getProjectContext === 'function') {
+        const result = await planningReader.getProjectContext();
+        return res.json(result);
+      }
+
+      // Fallback: read PROJECT.md directly if no planningReader provided
+      const projectPath = path.join(planningDir, 'PROJECT.md');
+      try {
+        const content = await fs.promises.readFile(projectPath, 'utf-8');
+        const { body } = parseFrontmatter(content);
+        const contextMatch = body.match(/## Context\n([\s\S]*?)(?=\n## |\s*$)/);
+        if (contextMatch) {
+          return res.json({ context: contextMatch[1].trim() });
+        }
+      } catch (_e) { /* no PROJECT.md */ }
+
+      // Legacy fallback: CONTEXT.md
+      const contextPath = path.join(planningDir, 'CONTEXT.md');
+      try {
+        const content = await fs.promises.readFile(contextPath, 'utf-8');
+        const { body } = parseFrontmatter(content);
+        return res.json({ context: body.trim() || null });
+      } catch (_e) { /* no CONTEXT.md */ }
+
+      res.json({ context: null });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  return router;
+}
+
+module.exports = createMemoryRouter;