@sienklogic/plan-build-run 2.24.0 → 2.26.1

package/dashboard/src/services/log.service.js

@@ -0,0 +1,105 @@
+import { readdir, stat, readFile } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+
+/**
+ * List .jsonl files in .planning/logs/ sorted by filename descending.
+ * Returns array of { name, size, modified }.
+ * @param {string} projectDir - Root project directory
+ * @returns {Promise<Array<{name: string, size: number, modified: string}>>}
+ */
+export async function listLogFiles(projectDir) {
+  const logsDir = join(projectDir, '.planning', 'logs');
+  let entries;
+  try {
+    entries = await readdir(logsDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const jsonlFiles = entries.filter(f => f.endsWith('.jsonl')).sort().reverse();
+  const results = await Promise.allSettled(
+    jsonlFiles.map(async f => {
+      const s = await stat(join(logsDir, f));
+      return { name: f, size: s.size, modified: s.mtime.toISOString() };
+    })
+  );
+  return results
+    .filter(r => r.status === 'fulfilled')
+    .map(r => r.value);
+}
+
+/**
+ * Read a page of entries from a JSONL log file.
+ * Reads the entire file line-by-line but only keeps the requested page in memory.
+ * @param {string} filePath - Absolute path to the .jsonl file
+ * @param {object} opts - { page=1, pageSize=100, typeFilter='', q='' }
+ * @returns {Promise<{ entries: object[], total: number, page: number, pageSize: number }>}
+ */
+export async function readLogPage(filePath, { page = 1, pageSize = 100, typeFilter = '', q = '' } = {}) {
+  let raw;
+  try {
+    raw = await readFile(filePath, 'utf8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return { entries: [], total: 0, page, pageSize };
+    throw err;
+  }
+
+  // Parse and filter in a single pass — no full array of all lines held beyond filtering
+  const allEntries = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try { obj = JSON.parse(trimmed); } catch { continue; }
+    if (typeFilter && obj.type !== typeFilter) continue;
+    if (q && !JSON.stringify(obj).toLowerCase().includes(q.toLowerCase())) continue;
+    allEntries.push(obj);
+  }
+
+  const total = allEntries.length;
+  const start = (page - 1) * pageSize;
+  const entries = allEntries.slice(start, start + pageSize);
+  return { entries, total, page, pageSize };
+}
+
+/**
+ * Tail a log file: watch for new lines appended after the current end.
+ * Uses fs.stat polling via setInterval (no extra deps).
+ * @param {string} filePath - Absolute path to the .jsonl file
+ * @param {(entry: object) => void} onLine - Called for each new parsed entry
+ * @returns {Promise<() => void>} cleanup function — call to stop watching
+ */
+export async function tailLogFile(filePath, onLine) {
+  let currentSize;
+  try {
+    const s = await stat(filePath);
+    currentSize = s.size;
+  } catch {
+    currentSize = 0;
+  }
+
+  const interval = setInterval(async () => {
+    let newSize;
+    try {
+      const s = await stat(filePath);
+      newSize = s.size;
+    } catch {
+      return;
+    }
+    if (newSize <= currentSize) return;
+
+    // Read only the new bytes
+    const stream = createReadStream(filePath, { start: currentSize, end: newSize - 1 });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    rl.on('line', line => {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      try { onLine(JSON.parse(trimmed)); } catch { /* skip malformed */ }
+    });
+    currentSize = newSize;
+  }, 500);
+
+  return () => clearInterval(interval);
+}

package/dashboard/src/services/notes.service.js

@@ -48,3 +48,19 @@ export async function listNotes(projectDir) {
 
   return notes;
 }
+
+export async function getNoteBySlug(projectDir, slug) {
+  const notesDir = join(projectDir, '.planning', 'notes');
+  let entries;
+  try {
+    entries = await readdir(notesDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+  const filename = entries.find(f => f.endsWith('.md') && f.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.md$/, '') === slug);
+  if (!filename) return null;
+  const { frontmatter, html } = await readMarkdownFile(join(notesDir, filename));
+  const title = slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+  return { filename, slug, title, date: frontmatter.date || null, promoted: !!frontmatter.promoted, html };
+}

package/dashboard/src/services/phase.service.js

@@ -2,6 +2,42 @@ import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { readMarkdownFile, validatePath } from '../repositories/planning.repository.js';
 
+/**
+ * Extract plan title and task count from raw PLAN.md content.
+ *
+ * @param {string|null} rawContent - Raw PLAN.md file content
+ * @returns {{ planTitle: string|null, taskCount: number }}
+ */
+export function extractPlanMeta(rawContent) {
+  if (!rawContent) return { planTitle: null, taskCount: 0 };
+  const titleMatch = rawContent.match(/\*\*Plan \d{2}-\d{2}\*\*:\s*(.+)/);
+  const planTitle = titleMatch ? titleMatch[1].trim() : null;
+  const taskCount = (rawContent.match(/<task /g) || []).length;
+  return { planTitle, taskCount };
+}
+
+/**
+ * Normalise VERIFICATION.md frontmatter to include a flat mustHaves array.
+ * Each entry has { category, text, passed }.
+ *
+ * @param {object|null|undefined} frontmatter - Parsed VERIFICATION.md frontmatter
+ * @returns {object|null|undefined} - Original frontmatter extended with mustHaves array, or unchanged
+ */
+export function enrichVerification(frontmatter) {
+  if (!frontmatter || !frontmatter.must_haves) return frontmatter;
+  const allPassed = frontmatter.result === 'pass' || frontmatter.result === 'passed';
+  const gaps = Array.isArray(frontmatter.gaps) ? frontmatter.gaps : [];
+  const mustHaves = [];
+  for (const [category, items] of Object.entries(frontmatter.must_haves)) {
+    if (!Array.isArray(items)) continue;
+    for (const text of items) {
+      const inGap = gaps.some(g => g.includes(text.slice(0, 30)));
+      mustHaves.push({ category, text, passed: allPassed || !inGap });
+    }
+  }
+  return { ...frontmatter, mustHaves };
+}
+
 /**
  * Format a phase directory name into a human-readable title.
  * Strips the numeric prefix and title-cases each word.
@@ -130,30 +166,43 @@ export async function getPhaseDetail(projectDir, phaseId) {
     summaryPaths.map(({ summaryPath }) => readMarkdownFile(summaryPath))
   );
 
+  // Read raw PLAN.md content for each plan to extract metadata
+  const planRawResults = await Promise.allSettled(
+    summaryPaths.map(({ planFile }) => readMarkdownFile(join(phaseFullPath, planFile)))
+  );
+
   // Map results to plan objects
   const plans = summaryPaths.map(({ planId, planFile }, index) => {
-    const result = summaryResults[index];
-    if (result.status === 'fulfilled') {
+    const summaryResult = summaryResults[index];
+    const planRawResult = planRawResults[index];
+
+    // Extract planTitle and taskCount from raw PLAN.md content
+    const rawPlanContent = planRawResult.status === 'fulfilled' ? planRawResult.value.rawContent : null;
+    const { planTitle, taskCount } = extractPlanMeta(rawPlanContent);
+
+    if (summaryResult.status === 'fulfilled') {
       return {
         planId,
         planFile,
-        summary: result.value.frontmatter,
-        content: result.value.html,
-        commits: parseTaskResultsTable(result.value.rawContent)
+        planTitle,
+        taskCount,
+        summary: summaryResult.value.frontmatter,
+        content: summaryResult.value.html,
+        commits: parseTaskResultsTable(summaryResult.value.rawContent)
       };
     }
-    if (result.reason && result.reason.code === 'ENOENT') {
-      return { planId, planFile, summary: null, content: null, commits: [] };
+    if (summaryResult.reason && summaryResult.reason.code === 'ENOENT') {
+      return { planId, planFile, planTitle, taskCount, summary: null, content: null, commits: [] };
     }
     // Unexpected error -- re-throw
-    throw result.reason;
+    throw summaryResult.reason;
   });
 
   // Read VERIFICATION.md
   let verification = null;
   try {
     const verDoc = await readMarkdownFile(join(phaseFullPath, 'VERIFICATION.md'));
-    verification = verDoc.frontmatter;
+    verification = enrichVerification(verDoc.frontmatter);
   } catch (error) {
     if (error.code !== 'ENOENT') {
       throw error;

package/dashboard/src/services/requirements.service.js

@@ -0,0 +1,130 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readMarkdownFile } from '../repositories/planning.repository.js';
+
+/**
+ * Parse requirement IDs and text from REQUIREMENTS.md markdown body.
+ * Looks for lines matching: - **ID**: description text
+ * Groups them by the nearest ## heading (section).
+ *
+ * @param {string} rawContent - Raw markdown string
+ * @returns {Array<{sectionTitle: string, requirements: Array<{id: string, text: string, planRefs: string[]}>}>}
+ */
+function parseRequirementSections(rawContent) {
+  const sections = [];
+  let currentSection = null;
+
+  for (const line of rawContent.split('\n')) {
+    const headingMatch = line.match(/^##\s+(.+)/);
+    if (headingMatch) {
+      currentSection = { sectionTitle: headingMatch[1].trim(), requirements: [] };
+      sections.push(currentSection);
+      continue;
+    }
+    // Match: - **P02-G1**: Some text  OR  - **P02-G1** Some text
+    const reqMatch = line.match(/^[-*]\s+\*\*([A-Z][A-Z0-9]*-[A-Z0-9]+)\*\*[:\s]+(.+)/);
+    if (reqMatch && currentSection) {
+      currentSection.requirements.push({
+        id: reqMatch[1].trim(),
+        text: reqMatch[2].trim(),
+        planRefs: []
+      });
+    }
+  }
+
+  return sections.filter(s => s.requirements.length > 0);
+}
+
+/**
+ * Scan all PLAN-*.md files in all phase directories and collect requirement_ids
+ * from their frontmatter. Returns a Map<requirementId, planId[]>.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<Map<string, string[]>>}
+ */
+async function buildRequirementIndex(projectDir) {
+  const phasesDir = join(projectDir, '.planning', 'phases');
+  const index = new Map();
+
+  let phaseDirs;
+  try {
+    phaseDirs = await readdir(phasesDir, { withFileTypes: true });
+  } catch (err) {
+    if (err.code === 'ENOENT') return index;
+    throw err;
+  }
+
+  const planReadTasks = [];
+  for (const entry of phaseDirs) {
+    if (!entry.isDirectory()) continue;
+    const phaseFullPath = join(phasesDir, entry.name);
+    let phaseFiles;
+    try {
+      phaseFiles = await readdir(phaseFullPath);
+    } catch { continue; }
+
+    for (const filename of phaseFiles) {
+      if (!/^PLAN-\d{2}\.md$/.test(filename)) continue;
+      planReadTasks.push(
+        readMarkdownFile(join(phaseFullPath, filename))
+          .then(({ frontmatter }) => {
+            const ids = frontmatter.requirement_ids;
+            const planId = frontmatter.plan;
+            if (!Array.isArray(ids) || !planId) return;
+            for (const id of ids) {
+              if (!index.has(id)) index.set(id, []);
+              index.get(id).push(planId);
+            }
+          })
+          .catch(() => { /* skip unreadable plan files */ })
+      );
+    }
+  }
+
+  await Promise.all(planReadTasks);
+  return index;
+}
+
+/**
+ * Build the full requirements traceability dataset:
+ * - Parses REQUIREMENTS.md into sections + requirements
+ * - Cross-references each requirement ID against plan frontmatter
+ * - Returns coverage counts and per-requirement plan references
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<{sections: Array, totalCount: number, coveredCount: number}>}
+ */
+export async function getRequirementsData(projectDir) {
+  const reqPath = join(projectDir, '.planning', 'REQUIREMENTS.md');
+
+  let rawContent;
+  try {
+    const parsed = await readMarkdownFile(reqPath);
+    rawContent = parsed.rawContent || '';
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      return { sections: [], totalCount: 0, coveredCount: 0 };
+    }
+    throw err;
+  }
+
+  const [sections, reqIndex] = await Promise.all([
+    Promise.resolve(parseRequirementSections(rawContent)),
+    buildRequirementIndex(projectDir)
+  ]);
+
+  let totalCount = 0;
+  let coveredCount = 0;
+
+  for (const section of sections) {
+    for (const req of section.requirements) {
+      const refs = reqIndex.get(req.id) || [];
+      req.planRefs = refs;
+      req.covered = refs.length > 0;
+      totalCount++;
+      if (req.covered) coveredCount++;
+    }
+  }
+
+  return { sections, totalCount, coveredCount };
+}

package/dashboard/src/services/research.service.js

@@ -0,0 +1,137 @@
+import { readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { readMarkdownFile } from '../repositories/planning.repository.js';
+
+/**
+ * List all research docs from .planning/research/*.md, sorted by filename descending.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<Array>}
+ */
+export async function listResearchDocs(projectDir) {
+  const dir = join(projectDir, '.planning', 'research');
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const mdFiles = entries.filter(f => f.endsWith('.md')).sort().reverse();
+  const results = await Promise.allSettled(
+    mdFiles.map(f => readMarkdownFile(join(dir, f)))
+  );
+  const docs = [];
+  for (let i = 0; i < mdFiles.length; i++) {
+    if (results[i].status !== 'fulfilled') continue;
+    const { frontmatter, html } = results[i].value;
+    const filename = mdFiles[i];
+    const slug = filename.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.md$/, '');
+    const title = slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    docs.push({
+      filename,
+      slug,
+      title,
+      topic: frontmatter.topic || null,
+      date: frontmatter.research_date
+        ? (frontmatter.research_date instanceof Date
+          ? frontmatter.research_date.toISOString().slice(0, 10)
+          : String(frontmatter.research_date))
+        : null,
+      confidence: frontmatter.confidence || null,
+      coverage: frontmatter.coverage || null,
+      html
+    });
+  }
+  return docs;
+}
+
+/**
+ * List all codebase docs from .planning/codebase/*.md, sorted by filename descending.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @returns {Promise<Array>}
+ */
+export async function listCodebaseDocs(projectDir) {
+  const dir = join(projectDir, '.planning', 'codebase');
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const mdFiles = entries.filter(f => f.endsWith('.md')).sort().reverse();
+  const results = await Promise.allSettled(
+    mdFiles.map(f => readMarkdownFile(join(dir, f)))
+  );
+  const docs = [];
+  for (let i = 0; i < mdFiles.length; i++) {
+    if (results[i].status !== 'fulfilled') continue;
+    const { frontmatter, html } = results[i].value;
+    const filename = mdFiles[i];
+    const slug = filename.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.md$/, '');
+    const title = slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    docs.push({
+      filename,
+      slug,
+      title,
+      date: frontmatter.scan_date
+        ? (frontmatter.scan_date instanceof Date
+          ? frontmatter.scan_date.toISOString().slice(0, 10)
+          : String(frontmatter.scan_date))
+        : null,
+      html
+    });
+  }
+  return docs;
+}
+
+/**
+ * Get a single research or codebase doc by slug.
+ * Searches research/ first, then codebase/.
+ *
+ * @param {string} projectDir - Absolute path to the project root
+ * @param {string} slug - Slug derived from filename (without date prefix and .md extension)
+ * @returns {Promise<object|null>}
+ */
+export async function getResearchDocBySlug(projectDir, slug) {
+  for (const subdir of ['research', 'codebase']) {
+    const dir = join(projectDir, '.planning', subdir);
+    let entries;
+    try {
+      entries = await readdir(dir);
+    } catch (err) {
+      if (err.code === 'ENOENT') continue;
+      throw err;
+    }
+    const filename = entries.find(
+      f => f.endsWith('.md') &&
+           f.replace(/^\d{4}-\d{2}-\d{2}-/, '').replace(/\.md$/, '') === slug
+    );
+    if (!filename) continue;
+    const { frontmatter, html } = await readMarkdownFile(join(dir, filename));
+    const title = slug.split('-').map(w => w.charAt(0).toUpperCase() + w.slice(1)).join(' ');
+    return {
+      filename,
+      slug,
+      title,
+      topic: frontmatter.topic || null,
+      date: frontmatter.research_date
+        ? (frontmatter.research_date instanceof Date
+          ? frontmatter.research_date.toISOString().slice(0, 10)
+          : String(frontmatter.research_date))
+        : frontmatter.scan_date
+          ? (frontmatter.scan_date instanceof Date
+            ? frontmatter.scan_date.toISOString().slice(0, 10)
+            : String(frontmatter.scan_date))
+          : null,
+      confidence: frontmatter.confidence || null,
+      sources_checked: frontmatter.sources_checked || null,
+      coverage: frontmatter.coverage || null,
+      section: subdir,
+      html
+    };
+  }
+  return null;
+}

package/dashboard/src/services/todo.service.js

@@ -230,6 +230,36 @@ export async function createTodo(projectDir, todoData) {
   });
 }
 
+export async function listDoneTodos(projectDir) {
+  const doneDir = join(projectDir, '.planning', 'todos', 'done');
+  let files;
+  try {
+    files = await readdir(doneDir);
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const mdFiles = files.filter(f => f.endsWith('.md')).sort().reverse();
+  const todos = [];
+  for (const filename of mdFiles) {
+    const match = filename.match(/^(\d{3})-(.+)\.md$/);
+    if (!match) continue;
+    const [, id, slugPart] = match;
+    try {
+      const raw = await readFile(join(doneDir, filename), 'utf-8');
+      const { data } = matter(raw);
+      todos.push({
+        id, filename,
+        title: data.title || slugPart,
+        priority: data.priority || '',
+        phase: data.phase || '',
+        completedAt: data.completed_at || null
+      });
+    } catch { /* skip */ }
+  }
+  return todos;
+}
+
 export async function completeTodo(projectDir, todoId) {
   return writeQueue.enqueue(async () => {
     const pendingDir = join(projectDir, '.planning', 'todos', 'pending');

package/dashboard/src/views/config.ejs

@@ -0,0 +1,5 @@
+<%- include('partials/layout-top', { title: 'Config', activePage: 'config' }) %>
+
+<%- include('partials/config-content') %>
+
+<%- include('partials/layout-bottom') %>

package/dashboard/src/views/logs.ejs

@@ -0,0 +1,3 @@
+<%- include('partials/layout-top', { title: 'Logs', activePage: 'logs' }) %>
+<%- include('partials/logs-content') %>
+<%- include('partials/layout-bottom') %>

package/dashboard/src/views/note-detail.ejs

@@ -0,0 +1,3 @@
+<%- include('partials/layout-top', { title: title, activePage: 'notes' }) %>
+<%- include('partials/note-detail-content') %>
+<%- include('partials/layout-bottom') %>

package/dashboard/src/views/partials/activity-feed.ejs

@@ -0,0 +1,12 @@
+<% if (!recentActivity || recentActivity.length === 0) { %>
+  <p class="muted">No recent activity.</p>
+<% } else { %>
+<ul class="activity-feed">
+  <% recentActivity.forEach(function(item) { %>
+  <li class="activity-item">
+    <span class="activity-path"><%= item.path %></span>
+    <time class="activity-time" datetime="<%= item.timestamp %>"><%= item.timestamp %></time>
+  </li>
+  <% }); %>
+</ul>
+<% } %>