sdtk-wiki-kit 0.2.2 → 0.3.0

package/assets/atlas/doc_atlas_viewer_template.html

@@ -524,6 +524,47 @@ body.nav-open .page-nav-toggle{display:none}
   .graph-toolbar-overlay,.graph-toolbar-overlay.compact,.graph-toolbar-overlay.minimized{position:relative;top:auto;left:auto;width:100%;max-width:none;margin-bottom:14px}
   .graph-focus-overlay,.graph-focus-overlay.minimized{position:relative;top:auto;right:auto;bottom:auto;width:100%;height:auto;max-height:none;pointer-events:auto}
 }
+/* BK-272 Agent Kaban board */
+.kaban-header{display:flex;align-items:flex-start;flex-wrap:wrap;gap:8px;padding:8px 2px}
+.kaban-feature-info{flex:1;min-width:0}
+.kaban-feature-name{font-size:14px;font-weight:700;color:var(--graph-text)}
+.kaban-meta{font-size:11px;color:var(--graph-muted);margin-top:2px}
+.kaban-liveness{font-size:11px;color:#b84c00;font-weight:700;padding:2px 8px;border:1px solid rgba(184,76,0,.35);border-radius:4px;white-space:nowrap;background:rgba(240,136,62,.07)}
+.kaban-freshness{font-size:10px;color:var(--graph-muted)}
+.kaban-notice{margin:0 0 6px;padding:5px 10px;border-radius:5px;font-size:11px;background:rgba(184,76,0,.06);color:#b84c00;border:1px solid rgba(184,76,0,.18)}
+.kaban-tabs{display:flex;border-bottom:1px solid var(--graph-border);margin-bottom:6px}
+.kaban-tab{background:none;border:none;border-bottom:2px solid transparent;padding:5px 14px;font-size:11px;font-weight:600;color:var(--graph-muted);cursor:pointer;margin-bottom:-1px}
+.kaban-tab:hover{color:var(--graph-text)}
+.kaban-tab.active{color:var(--graph-text);border-bottom-color:#5f89ff}
+.kaban-board-wrap{overflow-x:auto;padding-bottom:8px}
+.kaban-board{display:grid;grid-template-columns:80px repeat(4,minmax(110px,1fr));min-width:540px;column-gap:5px;row-gap:0}
+.kaban-col-header{font-size:9px;text-transform:uppercase;letter-spacing:.06em;font-weight:700;padding:3px 4px 6px;text-align:center;color:var(--graph-muted)}
+.kaban-col-header.kaban-col-inprog{color:#3156c9}
+.kaban-col-header.kaban-col-pending{color:#b84c00}
+.kaban-col-header.kaban-col-done{color:#1a7f37}
+.kaban-swimlane-header{font-size:8px;font-weight:700;text-transform:uppercase;letter-spacing:.05em;color:var(--graph-muted);padding:7px 4px 3px;text-align:right;border-top:1px solid var(--graph-border)}
+.kaban-cell{min-height:28px;padding:3px 2px;border-top:1px solid var(--graph-border);display:flex;flex-direction:column;gap:3px}
+.kaban-cell.kaban-cell-inprog .kaban-card{border-left:3px solid #3156c9}
+.kaban-cell.kaban-cell-pending .kaban-card{border-left:3px solid #b84c00}
+.kaban-cell.kaban-cell-done .kaban-card{border-left:3px solid #1a7f37}
+.kaban-cell.kaban-cell-todo .kaban-card{border-left:3px solid var(--border)}
+.kaban-card{background:var(--surface);border:1px solid var(--border);border-radius:4px;padding:5px 7px;font-size:11px;color:var(--text);cursor:pointer;line-height:1.4;transition:background .12s}
+.kaban-card:hover{background:var(--surface2)}
+.kaban-card-title{font-weight:600}
+.kaban-card-badges{display:flex;gap:3px;flex-wrap:wrap;margin-top:2px}
+.kaban-badge{font-size:9px;font-weight:700;text-transform:uppercase;letter-spacing:.04em;padding:1px 4px;border-radius:3px;display:inline-block}
+.kaban-badge-attention{background:rgba(184,76,0,.14);color:#b84c00;border:1px solid rgba(184,76,0,.28)}
+.kaban-badge-gate{background:rgba(100,60,200,.08);color:#6438c8;border:1px solid rgba(100,60,200,.2)}
+.kaban-card-detail{position:fixed;top:10%;left:10%;right:10%;max-height:76vh;z-index:200;background:var(--surface);border:1px solid var(--border);border-radius:10px;display:flex;flex-direction:column;box-shadow:0 16px 48px rgba(0,0,0,.7)}
+.kaban-detail-header{display:flex;align-items:flex-start;gap:10px;padding:12px 14px 8px;border-bottom:1px solid var(--border)}
+.kaban-detail-phase{font-size:9px;text-transform:uppercase;letter-spacing:.07em;color:var(--text2);font-weight:700}
+.kaban-detail-title{font-size:14px;font-weight:700;color:var(--text);margin-top:3px}
+.kaban-detail-close{background:none;border:none;color:var(--text2);font-size:18px;cursor:pointer;padding:0 4px;line-height:1;border-radius:3px;flex-shrink:0}
+.kaban-detail-close:hover{color:var(--text);background:var(--surface2)}
+.kaban-detail-body{padding:12px 14px;overflow-y:auto;flex:1;font-size:12px;line-height:1.6}
+.kaban-detail-row{display:flex;gap:8px;margin-bottom:5px}
+.kaban-detail-label{font-size:10px;text-transform:uppercase;letter-spacing:.05em;color:var(--text2);font-weight:600;min-width:68px;flex-shrink:0}
+.kaban-detail-value{color:var(--text);flex:1;word-break:break-word}
 
 </style>
 </head>
@@ -545,25 +586,33 @@ body.nav-open .page-nav-toggle{display:none}
       <p>Project-local wiki and knowledge graph - generated __ATLAS_GENERATED__</p>
     </div>
     <div class="screen-scroll">
-      <div class="dash-grid">
-        <div class="dash-card" style="border-color:#58a6ff">
-          <span class="num" style="color:#58a6ff" id="stat-total">-</span>
-          <span class="label">Total Docs</span>
+      <div class="kaban-header" id="kaban-header">
+        <div class="kaban-feature-info">
+          <div class="kaban-feature-name" id="kaban-feature-name">Agent Kaban Board</div>
+          <div class="kaban-meta" id="kaban-meta">Loading pipeline data...</div>
         </div>
-        <div class="dash-card" style="border-color:#3fb950">
-          <span class="num" style="color:#3fb950" id="stat-families">-</span>
-          <span class="label">Families</span>
-        </div>
-        <div class="dash-card" style="border-color:#f0883e">
-          <span class="num" style="color:#f0883e" id="stat-edges">-</span>
-          <span class="label">Graph Edges</span>
-        </div>
-        <div class="dash-card" style="border-color:#d2a8ff">
-          <span class="num" style="color:#d2a8ff" id="stat-issues">-</span>
-          <span class="label">BK Issues</span>
+        <div class="kaban-liveness" id="kaban-liveness" style="display:none">&#9888; <span id="kaban-liveness-text"></span></div>
+        <div class="kaban-freshness" id="kaban-freshness"></div>
+      </div>
+      <div class="kaban-notice" id="kaban-notice" style="display:none"></div>
+      <div class="kaban-tabs">
+        <button class="kaban-tab active" id="kaban-tab-pipeline" onclick="switchKabanTab('pipeline')">Pipeline</button>
+        <button class="kaban-tab" id="kaban-tab-quality" onclick="switchKabanTab('quality')">Quality Gates</button>
+      </div>
+      <div class="kaban-board-wrap">
+        <div id="kaban-board-pipeline"></div>
+        <div id="kaban-board-quality" style="display:none"></div>
+      </div>
+    </div>
+    <div class="kaban-card-detail" id="kaban-card-detail" style="display:none">
+      <div class="kaban-detail-header">
+        <div style="flex:1;min-width:0">
+          <div class="kaban-detail-phase" id="kd-phase"></div>
+          <div class="kaban-detail-title" id="kd-title"></div>
         </div>
+        <button class="kaban-detail-close" onclick="closeKabanDetail()" aria-label="Close card detail" title="Close card detail">&times;</button>
       </div>
-      <div id="dash-family-rows"></div>
+      <div class="kaban-detail-body" id="kd-body"></div>
     </div>
   </div>
 </div>
@@ -811,26 +860,179 @@ const FAMILY_GLYPHS = {
 };
 const GRAPH_EDGE_COLORS = { references_path: 'rgba(95,137,255,0.38)', references_wiki_link: 'rgba(46,181,125,0.44)' };
 const GRAPH_FRAME_MS = 40;
-(function initDash() {
-  const docs = INDEX.documents;
-  const families = new Set(docs.map(d => d.family));
-  const issues = new Set(docs.flatMap(d => d.issues));
-  const edges = GRAPH.edges.filter(e => e.type !== 'same_family');
-  document.getElementById('stat-total').textContent = docs.length;
-  document.getElementById('stat-families').textContent = families.size;
-  document.getElementById('stat-edges').textContent = edges.length;
-  document.getElementById('stat-issues').textContent = issues.size;
-  const famCounts = {};
-  docs.forEach(d => { famCounts[d.family] = (famCounts[d.family] || 0) + 1; });
-  const rows = document.getElementById('dash-family-rows');
-  Object.entries(famCounts).sort((a,b)=>b[1]-a[1]).forEach(([fam,cnt]) => {
-    const color = FAMILY_COLORS[fam] || '#8b949e';
-    const row = document.createElement('div');
-    row.className = 'stat-row';
-    row.innerHTML = `<span class="label"><span class="dot" style="background:${color}"></span> ${fam}</span><span class="val" style="color:${color}">${cnt}</span>`;
-    rows.appendChild(row);
-  });
-})();
+// BK-272: Agent Kaban board — state, render, and poll
+var kabanState = { data: null, activeTab: 'pipeline', pollTimer: null, lastFetch: null };
+const KABAN_POLL_MS = 3000;
+const KABAN_LIVENESS_MIN_JS = 15;
+const KABAN_COLS = ['todo', 'in_progress', 'pending', 'done'];
+const KABAN_COL_LABELS = { todo: 'Todo', in_progress: 'In Progress', pending: 'Pending', done: 'Done' };
+const KABAN_COL_CSS = { todo: '', in_progress: 'kaban-col-inprog', pending: 'kaban-col-pending', done: 'kaban-col-done' };
+const KABAN_CELL_CSS = { todo: 'kaban-cell-todo', in_progress: 'kaban-cell-inprog', pending: 'kaban-cell-pending', done: 'kaban-cell-done' };
+
+function safeKabanHtml(s) {
+  return String(s || '').replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/"/g,'&quot;');
+}
+function formatKabanFreshness(dt) {
+  if (!dt) return '';
+  const d = Math.floor((new Date() - dt) / 1000);
+  if (d < 5) return 'just now';
+  if (d < 60) return d + 's ago';
+  if (d < 3600) return Math.floor(d / 60) + 'm ago';
+  return Math.floor(d / 3600) + 'h ago';
+}
+function renderKabanCard(card) {
+  const badges = [];
+  if (card.attention) badges.push('<span class="kaban-badge kaban-badge-attention">&#9888; Pending</span>');
+  if (card.isGate) badges.push('<span class="kaban-badge kaban-badge-gate">GATE</span>');
+  const id = safeKabanHtml(card.id);
+  const tab = safeKabanHtml(kabanState.activeTab);
+  return '<div class="kaban-card" onclick="openKabanDetail(\'' + id + '\',\'' + tab + '\')" role="button" tabindex="0">' +
+    '<div class="kaban-card-title">' + safeKabanHtml(card.title || card.id) + '</div>' +
+    (badges.length ? '<div class="kaban-card-badges">' + badges.join('') + '</div>' : '') +
+    '</div>';
+}
+function renderKabanBoard(containerId, cards, agents) {
+  const container = document.getElementById(containerId);
+  if (!container) return;
+  if (!cards || cards.length === 0) {
+    container.innerHTML = '<div style="padding:16px;text-align:center;font-size:11px;color:var(--text2)">No data — SHARED_PLANNING.md or QUALITY_CHECKLIST.md not found in project root.</div>';
+    return;
+  }
+  let html = '<div class="kaban-board">';
+  html += '<div class="kaban-col-header"></div>';
+  for (const col of KABAN_COLS) {
+    html += '<div class="kaban-col-header ' + (KABAN_COL_CSS[col] || '') + '">' + KABAN_COL_LABELS[col] + '</div>';
+  }
+  for (const agent of agents) {
+    html += '<div class="kaban-swimlane-header">' + safeKabanHtml(agent) + '</div>';
+    for (const col of KABAN_COLS) {
+      const cellCards = cards.filter(function(c){ return c.agent === agent && c.column === col; });
+      html += '<div class="kaban-cell ' + KABAN_CELL_CSS[col] + '">';
+      for (const c of cellCards) html += renderKabanCard(c);
+      html += '</div>';
+    }
+  }
+  const otherCards = cards.filter(function(c){ return !agents.includes(c.agent); });
+  if (otherCards.length > 0) {
+    html += '<div class="kaban-swimlane-header">OTHER</div>';
+    for (const col of KABAN_COLS) {
+      const cellCards = otherCards.filter(function(c){ return c.column === col; });
+      html += '<div class="kaban-cell ' + KABAN_CELL_CSS[col] + '">';
+      for (const c of cellCards) html += renderKabanCard(c);
+      html += '</div>';
+    }
+  }
+  html += '</div>';
+  container.innerHTML = html;
+}
+function renderKaban(data) {
+  if (!data) return;
+  const meta = data.meta || {};
+  const agents = data.agents || ['PM','BA','ARCH','DEV','QA'];
+  const nameEl = document.getElementById('kaban-feature-name');
+  if (nameEl) nameEl.textContent = meta.featureName || meta.featureKey || 'Agent Kaban Board';
+  const metaEl = document.getElementById('kaban-meta');
+  if (metaEl) {
+    const parts = [];
+    if (meta.featureKey) parts.push(meta.featureKey);
+    if (meta.lastUpdated) parts.push('Updated: ' + meta.lastUpdated);
+    metaEl.textContent = parts.join(' · ') || 'No pipeline data';
+  }
+  const freshEl = document.getElementById('kaban-freshness');
+  if (freshEl && kabanState.lastFetch) freshEl.textContent = 'Fetched ' + formatKabanFreshness(kabanState.lastFetch);
+  const livenessEl = document.getElementById('kaban-liveness');
+  const livenessTextEl = document.getElementById('kaban-liveness-text');
+  if (livenessEl && meta.lastUpdated) {
+    try {
+      const lu = new Date(meta.lastUpdated.replace(' ','T'));
+      const diffMin = Math.floor((new Date() - lu) / 60000);
+      if (diffMin > KABAN_LIVENESS_MIN_JS && !isNaN(diffMin)) {
+        if (livenessTextEl) livenessTextEl.textContent = 'No movement for ' + diffMin + ' min';
+        livenessEl.style.display = '';
+      } else { livenessEl.style.display = 'none'; }
+    } catch(_) { livenessEl.style.display = 'none'; }
+  } else if (livenessEl) { livenessEl.style.display = 'none'; }
+  const noticeEl = document.getElementById('kaban-notice');
+  if (noticeEl) {
+    const notices = [];
+    if (!meta.pipelinePresent) notices.push('SHARED_PLANNING.md not found');
+    if (!meta.qualityPresent) notices.push('QUALITY_CHECKLIST.md not found');
+    (meta.errors || []).forEach(function(e){ notices.push(e); });
+    if (notices.length > 0) { noticeEl.textContent = notices.join(' · '); noticeEl.style.display = ''; }
+    else { noticeEl.style.display = 'none'; }
+  }
+  renderKabanBoard('kaban-board-pipeline', (data.pipeline || {}).cards || [], agents);
+  renderKabanBoard('kaban-board-quality', (data.quality || {}).cards || [], agents);
+}
+function openKabanDetail(cardId, tab) {
+  if (!kabanState.data) return;
+  const src = tab === 'quality' ? (kabanState.data.quality || {}) : (kabanState.data.pipeline || {});
+  const card = (src.cards || []).find(function(c){ return c.id === cardId; });
+  if (!card) return;
+  const phaseEl = document.getElementById('kd-phase');
+  const titleEl = document.getElementById('kd-title');
+  const bodyEl = document.getElementById('kd-body');
+  const detailEl = document.getElementById('kaban-card-detail');
+  if (!detailEl) return;
+  if (phaseEl) phaseEl.textContent = (card.agent || '') + (card.phase ? ' · ' + card.phase : '');
+  if (titleEl) titleEl.textContent = card.title || card.id;
+  if (bodyEl) {
+    const rows = [];
+    function addRow(label, value) {
+      if (!value) return;
+      rows.push('<div class="kaban-detail-row"><span class="kaban-detail-label">' + safeKabanHtml(label) + '</span><span class="kaban-detail-value">' + safeKabanHtml(value) + '</span></div>');
+    }
+    addRow('Column', KABAN_COL_LABELS[card.column] || card.column);
+    addRow('Status', card.rawStatus);
+    addRow('Owner', card.owner);
+    addRow('Artifact', card.artifact);
+    addRow('Notes', card.notes);
+    addRow('Issue', card.issue);
+    addRow('Last update', card.lastUpdate);
+    addRow('Handoff →', card.handoffNext);
+    if (card.isGate) rows.push('<div style="margin-top:8px"><span class="kaban-badge kaban-badge-gate">GATE CHECKPOINT</span></div>');
+    if (card.attention) rows.push('<div style="margin-top:4px"><span class="kaban-badge kaban-badge-attention">&#9888; Needs attention</span></div>');
+    bodyEl.innerHTML = rows.join('') || '<span style="color:var(--text2)">No additional detail.</span>';
+  }
+  detailEl.style.display = 'flex';
+}
+function closeKabanDetail() {
+  const el = document.getElementById('kaban-card-detail');
+  if (el) el.style.display = 'none';
+}
+function switchKabanTab(tab) {
+  kabanState.activeTab = tab;
+  const ptab = document.getElementById('kaban-tab-pipeline');
+  const qtab = document.getElementById('kaban-tab-quality');
+  const pboard = document.getElementById('kaban-board-pipeline');
+  const qboard = document.getElementById('kaban-board-quality');
+  if (ptab) ptab.classList.toggle('active', tab === 'pipeline');
+  if (qtab) qtab.classList.toggle('active', tab === 'quality');
+  if (pboard) pboard.style.display = tab === 'pipeline' ? '' : 'none';
+  if (qboard) qboard.style.display = tab === 'quality' ? '' : 'none';
+  closeKabanDetail();
+}
+async function fetchKabanData() {
+  try {
+    const resp = await fetch('/api/kaban');
+    if (!resp.ok) throw new Error('HTTP ' + resp.status);
+    const data = await resp.json();
+    kabanState.data = data;
+    kabanState.lastFetch = new Date();
+    renderKaban(data);
+  } catch(e) {
+    const noticeEl = document.getElementById('kaban-notice');
+    if (noticeEl) { noticeEl.textContent = 'Could not load kaban data: ' + e.message; noticeEl.style.display = ''; }
+  }
+}
+function startKabanPoll() {
+  stopKabanPoll();
+  fetchKabanData();
+  kabanState.pollTimer = setInterval(fetchKabanData, KABAN_POLL_MS);
+}
+function stopKabanPoll() {
+  if (kabanState.pollTimer) { clearInterval(kabanState.pollTimer); kabanState.pollTimer = null; }
+}
 
 
 function applySidebarState(collapsed) {
@@ -876,6 +1078,7 @@ function showPanel(name, btn) {
   } else {
     stopGraphAnimation();
   }
+  if (name === 'dash') { startKabanPoll(); } else { stopKabanPoll(); }
 }
 
 let activeFamily = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdtk-wiki-kit",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Project-local wiki and knowledge graph toolkit for SDTK workspaces.",
   "bin": {
     "sdtk-wiki": "bin/sdtk-wiki.js"

package/src/commands/help.js

@@ -53,6 +53,7 @@ R1 command model:
   wiki discover        Write a local-only discovery plan from WIKI gap evidence.
   wiki compile         Preview or explicitly apply local wiki compile plans.
   ask                  Ask grounded questions over the built SDTK-WIKI graph.
+  kaban                Open the Agent Kaban board (Dashboard panel) for the current project.
   search               Search generated local wiki pages without premium Ask.
   lint                 Write a report-first, non-destructive wiki lint report.
   update               Package-only updater; no wiki/.sdtk/wiki/.sdtk/atlas files are mutated in R1.

package/src/commands/kaban.js

@@ -0,0 +1,85 @@
+"use strict";
+
+// BK-272: sdtk-wiki kaban — open the viewer on the Dashboard (Kaban board) panel.
+// Follows the same flow as cmdAtlasOpen; Dashboard is the default active panel.
+
+const fs = require("fs");
+const path = require("path");
+const { resolveWikiConfig } = require("../lib/wiki-config");
+const { openViewer, runBuild } = require("../lib/wiki-runner");
+const { parseFlags } = require("../lib/args");
+const { OPEN_FLAG_DEFS } = require("../lib/wiki-flags");
+
+const KABAN_FLAG_DEFS = {
+  ...OPEN_FLAG_DEFS,
+  "project-path": { type: "string", alias: "project" },
+};
+
+function hasHelp(args) {
+  return args.includes("-h") || args.includes("--help");
+}
+
+async function cmdKaban(args) {
+  if (hasHelp(args)) {
+    console.log(`Usage:
+  sdtk-wiki kaban [--project <dir>] [--port <n>] [--no-open]
+
+Purpose:
+  Open the SDTK-WIKI viewer showing the Agent Kaban board (Dashboard panel).
+  The board reads SHARED_PLANNING.md and QUALITY_CHECKLIST.md from the project
+  directory and polls /api/kaban every 3 s while the Dashboard panel is active.
+
+Options:
+  --project, --project-path <dir>  Project root containing SHARED_PLANNING.md
+                                   and QUALITY_CHECKLIST.md (default: cwd)
+  --port <n>                       Local server port (default: from config or 7654)
+  --no-open                        Print the viewer URL without opening a browser
+  -h, --help                       Show this help and exit
+
+Example:
+  sdtk-wiki kaban --project /path/to/project
+  sdtk-wiki kaban --no-open`);
+    return 0;
+  }
+
+  const { flags } = parseFlags(args, KABAN_FLAG_DEFS);
+  const config = resolveWikiConfig(flags);
+
+  const viewerPath = path.join(config.outputDir, "viewer.html");
+  const legacyViewerPath = path.join(config.legacyAtlasDir || "", "viewer.html");
+
+  const hasViewer =
+    fs.existsSync(viewerPath) || fs.existsSync(legacyViewerPath);
+
+  if (!hasViewer) {
+    console.log("[kaban] No SDTK-WIKI viewer found. Running initial build...");
+    try {
+      await runBuild(config);
+    } catch (err) {
+      console.error("[kaban] Build failed: " + err.message);
+      console.error("[kaban] Run: sdtk-wiki atlas build");
+      return 1;
+    }
+  }
+
+  // Use legacy atlas dir if the wiki output dir has no viewer yet
+  const activeConfig = fs.existsSync(viewerPath)
+    ? config
+    : { ...config, outputDir: config.legacyAtlasDir };
+
+  const noOpen = !!flags["no-open"];
+  const { server } = await openViewer(activeConfig, noOpen);
+
+  if (noOpen) {
+    if (server) server.close();
+    return 0;
+  }
+
+  console.log("[kaban] Dashboard (Kaban board) is the active panel.");
+  console.log("[kaban] Edit SHARED_PLANNING.md or QUALITY_CHECKLIST.md to see live updates.");
+  console.log("[kaban] Press Ctrl+C to stop the viewer server.");
+  await new Promise(() => {});
+  return 0;
+}
+
+module.exports = { cmdKaban };

package/src/index.js

@@ -2,6 +2,7 @@
 
 const { cmdAtlas } = require("./commands/atlas");
 const { cmdAsk } = require("./commands/ask");
+const { cmdKaban } = require("./commands/kaban");
 const { cmdHelp } = require("./commands/help");
 const { cmdInit } = require("./commands/init");
 const { cmdLint } = require("./commands/lint");
@@ -47,6 +48,7 @@ const COMMANDS = new Set([
   "atlas",
   "wiki",
   "ask",
+  "kaban",
   "lint",
   "search",
   "ingest",
@@ -82,6 +84,8 @@ async function run(argv) {
       return cmdWiki(args);
     case "ask":
       return cmdAsk(args);
+    case "kaban":
+      return cmdKaban(args);
     case "lint":
       return cmdLint(args);
     case "search":

package/src/lib/wiki-kaban-parse.js

@@ -0,0 +1,529 @@
+"use strict";
+
+// BK-272: Agent Kaban — pure parser (no I/O). Caller passes file text.
+// Spec §D3: view model; §D4: column derivation rules; §D5: liveness.
+
+const KABAN_LIVENESS_MIN = 15;
+const COLUMNS = ["todo", "in_progress", "pending", "done"];
+const AGENT_ORDER = ["PM", "BA", "ARCH", "DEV", "QA"];
+const DONE_STATUSES = new Set(["done", "complete", "example complete"]);
+
+// Normalize agent identifier to canonical form (PM/BA/ARCH/DEV/QA)
+function normalizeAgent(raw) {
+  if (!raw) return null;
+  const s = raw.replace(/[`*@]/g, "").trim().toLowerCase();
+  if (!s) return null;
+  if (s.startsWith("pm")) return "PM";
+  if (s.startsWith("ba")) return "BA";
+  if (s.startsWith("arch")) return "ARCH";
+  if (s.startsWith("dev")) return "DEV";
+  if (s.startsWith("qa")) return "QA";
+  return null;
+}
+
+// Extract a header field matching **FieldName:** `value` or FieldName: value
+function getHeaderField(text) {
+  for (let i = 1; i < arguments.length; i++) {
+    const fieldName = arguments[i];
+    const patterns = [
+      new RegExp("\\*\\*" + fieldName + "[:\\s]*\\*\\*\\s*[:`]?\\s*`?([^`\\n]+)`?", "i"),
+      new RegExp("^\\s*\\*\\*" + fieldName + ":\\*\\*\\s+`?([^`\\n]+)`?", "im"),
+      new RegExp("^\\s*" + fieldName + ":\\s+([^\\n]+)", "im"),
+    ];
+    for (const re of patterns) {
+      const m = text.match(re);
+      if (m) return m[1].trim().replace(/`/g, "").replace(/\*\*/g, "");
+    }
+  }
+  return null;
+}
+
+// Parse a markdown table block from an array of pipe-delimited lines.
+// Returns { headerCols: string[], rows: string[][] }
+function parseMarkdownTable(tableLines) {
+  const rows = [];
+  let headerCols = null;
+  for (const line of tableLines) {
+    const t = line.trim();
+    if (!t.startsWith("|")) continue;
+    const cells = t.slice(1, t.endsWith("|") ? -1 : undefined)
+      .split("|")
+      .map((c) => c.trim());
+    if (headerCols === null) {
+      headerCols = cells.map((c) =>
+        c.replace(/\*\*/g, "").replace(/`/g, "").toLowerCase().trim()
+      );
+      continue;
+    }
+    if (cells.every((c) => /^[-: ]+$/.test(c) || c === "")) continue;
+    rows.push(cells);
+  }
+  return { headerCols: headerCols || [], rows };
+}
+
+// Find the first table in text whose header columns match all required patterns.
+function findTable(text, requiredColPatterns) {
+  const allLines = text.split("\n");
+  let i = 0;
+  while (i < allLines.length) {
+    const line = allLines[i].trim();
+    if (!line.startsWith("|")) {
+      i++;
+      continue;
+    }
+    const tableLines = [];
+    while (i < allLines.length && allLines[i].trim().startsWith("|")) {
+      tableLines.push(allLines[i]);
+      i++;
+    }
+    if (tableLines.length < 2) continue;
+    const parsed = parseMarkdownTable(tableLines);
+    const matches = requiredColPatterns.every((p) =>
+      parsed.headerCols.some((h) => p.test(h))
+    );
+    if (matches) return parsed;
+  }
+  return null;
+}
+
+// Parse planning file header (featureKey, featureName, lastUpdated)
+function parsePlanningHeader(text) {
+  return {
+    featureKey: getHeaderField(text, "Current Feature", "Feature key"),
+    featureName: getHeaderField(text, "Feature Name"),
+    lastUpdated: getHeaderField(text, "Last Updated"),
+    pipelineStatus: getHeaderField(text, "Pipeline Status", "Status"),
+  };
+}
+
+// Parse the pipeline status table into phase objects.
+// Handles both canonical shape (8 cols) and simplified demo shape (5 cols).
+function parsePipelinePhases(text) {
+  const result = findTable(text, [/phase/, /status/]);
+  if (!result) return [];
+  const { headerCols, rows } = result;
+
+  const phaseIdx = headerCols.findIndex((h) => h.includes("phase"));
+  const statusIdx = headerCols.findIndex((h) => h.includes("status"));
+  const ownerIdx = headerCols.findIndex((h) => h.includes("owner"));
+  const artifactIdx = headerCols.findIndex(
+    (h) => h.includes("artifact") || h.includes("output")
+  );
+  const notesIdx = headerCols.findIndex(
+    (h) => h.includes("notes") || h.includes("blockers")
+  );
+
+  if (phaseIdx < 0 || statusIdx < 0) return [];
+
+  const phases = [];
+  for (const cells of rows) {
+    const phase = (cells[phaseIdx] || "")
+      .replace(/\*\*/g, "")
+      .replace(/`/g, "")
+      .trim();
+    const rawStatus = (cells[statusIdx] || "")
+      .replace(/\*\*/g, "")
+      .replace(/`/g, "")
+      .trim();
+    const owner =
+      ownerIdx >= 0 ? (cells[ownerIdx] || "").trim() : "";
+    const artifact =
+      artifactIdx >= 0
+        ? (cells[artifactIdx] || "").replace(/`/g, "").trim()
+        : "";
+    const notes =
+      notesIdx >= 0
+        ? (cells[notesIdx] || "").replace(/\*\*/g, "").replace(/`/g, "").trim()
+        : "";
+
+    if (!phase || !rawStatus) continue;
+
+    phases.push({
+      phase,
+      rawStatus,
+      owner,
+      artifact,
+      notes,
+      agent: normalizeAgent(owner),
+    });
+  }
+  return phases;
+}
+
+// Extract blocker strings; returns [] if sentinel NO BLOCKERS or section absent.
+function parseBlockers(text) {
+  const m = text.match(
+    /##\s+CURRENT BLOCKERS[^\n]*([\s\S]*?)(?=\n##\s+|$)/i
+  );
+  if (!m) return [];
+  const section = m[1];
+  if (section.includes("NO BLOCKERS")) return [];
+  return section
+    .split("\n")
+    .map((l) => l.trim())
+    .filter((l) => l && l !== "```" && !l.startsWith("#"));
+}
+
+// Extract OPEN open questions from the OQ table.
+function parseOpenQuestions(text) {
+  const result = findTable(text, [/q-id|^id$/, /status/]);
+  if (!result) return [];
+  const { headerCols, rows } = result;
+
+  const idIdx = headerCols.findIndex((h) => h === "q-id" || h === "id");
+  const statusIdx = headerCols.findIndex((h) => h.includes("status"));
+  const ownerIdx = headerCols.findIndex((h) => h.includes("owner"));
+  const summaryIdx = headerCols.findIndex((h) => h.includes("summary"));
+
+  return rows
+    .filter((cells) => {
+      const st = (statusIdx >= 0 ? cells[statusIdx] || "" : "").trim().toUpperCase();
+      return st.includes("OPEN");
+    })
+    .map((cells) => ({
+      id: idIdx >= 0 ? (cells[idIdx] || "").trim() : "",
+      status: (statusIdx >= 0 ? cells[statusIdx] || "" : "").trim(),
+      owner: ownerIdx >= 0 ? (cells[ownerIdx] || "").trim() : "",
+      summary: summaryIdx >= 0 ? (cells[summaryIdx] || "").trim() : "",
+    }));
+}
+
+// Parse activity log lines for timestamps and @handoff hints.
+function parseActivityEntries(text) {
+  const re = /(\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2})[^|\n]*\|[^|\n]*\|[^|\n]*\|[^|\n]*?(\@\w+)?(?=\n|$)/g;
+  const entries = [];
+  let m;
+  while ((m = re.exec(text)) !== null) {
+    entries.push({ ts: m[1].trim(), handoffNext: m[2] ? m[2].trim() : null });
+  }
+  return entries;
+}
+
+// Derive pipeline card column per spec §D4.
+function derivePipelineColumn(rawStatus, hasOpenOQ, hasBlocker, trustMismatch) {
+  const s = rawStatus.toLowerCase();
+  const isDone = DONE_STATUSES.has(s);
+  if (isDone && !trustMismatch && !hasOpenOQ && !hasBlocker) {
+    return { column: "done", attention: false };
+  }
+  if (hasOpenOQ || hasBlocker || trustMismatch) {
+    return { column: "pending", attention: true };
+  }
+  if (s === "in_progress" || s === "in progress") {
+    return { column: "in_progress", attention: false };
+  }
+  return { column: "todo", attention: false };
+}
+
+// Derive quality card column per spec §D4.
+function deriveQualityColumn(checked, phaseHasBlocker, phaseHasOpenOQ, hasIssue, phaseStatus) {
+  if (checked) return { column: "done", attention: false };
+  if (phaseHasBlocker || phaseHasOpenOQ || hasIssue) {
+    return { column: "pending", attention: true };
+  }
+  const s = (phaseStatus || "").toLowerCase();
+  if (s === "in_progress" || s === "in progress") {
+    return { column: "in_progress", attention: false };
+  }
+  return { column: "todo", attention: false };
+}
+
+// Derive agent from QUALITY_CHECKLIST.md phase section heading.
+function deriveAgentFromPhaseName(name) {
+  const u = name.toUpperCase();
+  if (u.includes("PM") || u.includes("CLOSURE")) return "PM";
+  if (u.includes("BA") || u.includes("BUSINESS ANALYSIS")) return "BA";
+  if (u.includes("ARCH") || u.includes("ARCHITECTURE")) return "ARCH";
+  if (u.includes("DEV") || u.includes("DEVELOPMENT") || u.includes("IMPLEMENTATION")) return "DEV";
+  if (u.includes("QA") || u.includes("QUALITY")) return "QA";
+  return "PM";
+}
+
+// Parse QUALITY_CHECKLIST.md into phase objects with criteria + gate rows.
+function parseQualityCriteria(text) {
+  const phases = [];
+  const lines = text.split("\n");
+  let currentPhase = null;
+
+  for (const line of lines) {
+    const phaseMatch = line.match(
+      /^#{1,3}\s+PHASE\s+(\d+[+]?)[\s:]+(.+?)\s*(?:CHECKLIST)?\s*$/i
+    );
+    if (phaseMatch) {
+      currentPhase = {
+        phaseNum: phaseMatch[1],
+        phaseName: phaseMatch[2].replace(/\(.*?\)/g, "").trim(),
+        agent: deriveAgentFromPhaseName(phaseMatch[2]),
+        criteria: [],
+        gate: null,
+      };
+      phases.push(currentPhase);
+      continue;
+    }
+    if (!currentPhase) continue;
+
+    const t = line.trim();
+    if (!t.startsWith("|")) continue;
+    if (t.replace(/[\-:|]/g, "").trim() === "") continue;
+
+    const cells = t
+      .slice(1, t.endsWith("|") ? -1 : undefined)
+      .split("|")
+      .map((c) => c.trim());
+    if (cells.length < 3) continue;
+
+    const numRaw = cells[0].replace(/\*\*/g, "").trim();
+    if (!numRaw || numRaw === "#" || numRaw === "num") continue;
+
+    const criteriaRaw = cells[1] || "";
+    const statusRaw = cells[2] || "";
+    const verifiedByRaw = cells[3] || "";
+    const notesRaw = cells[4] || "";
+
+    const criteria = criteriaRaw.replace(/\*\*/g, "").replace(/`/g, "").trim();
+    if (!criteria) continue;
+
+    const verifiedByClean = verifiedByRaw.replace(/\*\*/g, "").trim();
+    const isGate = verifiedByClean.toLowerCase().includes("gate");
+
+    const checked =
+      statusRaw.includes("[x]") ||
+      statusRaw.toLowerCase() === "done" ||
+      statusRaw.toLowerCase() === "complete";
+
+    const issue = notesRaw.replace(/\*\*/g, "").replace(/`/g, "").trim();
+    const agent = normalizeAgent(verifiedByClean) || currentPhase.agent;
+
+    const item = {
+      criteria,
+      checked,
+      isGate,
+      issue,
+      agent,
+      phaseNum: currentPhase.phaseNum,
+      phaseName: currentPhase.phaseName,
+    };
+
+    if (isGate) {
+      currentPhase.gate = item;
+    } else {
+      currentPhase.criteria.push(item);
+    }
+  }
+  return phases;
+}
+
+// Fuzzy-match a phase name in a map to find the closest entry.
+function findMatchingEntry(map, targetName) {
+  const tn = targetName.toLowerCase().replace(/^\d+[+]?\.\s*/, "").replace(/\s*checklist\s*$/i, "").trim();
+  for (const [key, val] of Object.entries(map)) {
+    const k = key.replace(/^\d+[+]?\.\s*/, "").trim();
+    const firstWord = tn.split(/\s+/)[0];
+    if (k.includes(tn) || tn.includes(k) || k.startsWith(firstWord)) {
+      return val;
+    }
+  }
+  return null;
+}
+
+// Main parser — pure, no I/O.
+// Input: { planningText: string|null, qualityText: string|null, now: Date }
+// Output: { meta, agents, pipeline: { cards }, quality: { cards } }
+function parseKaban({ planningText, qualityText, now }) {
+  const nowDate = now instanceof Date ? now : new Date();
+  const errors = [];
+
+  const meta = {
+    featureKey: null,
+    featureName: null,
+    lastUpdated: null,
+    generatedAt: nowDate.toISOString(),
+    pipelinePresent: !!planningText,
+    qualityPresent: !!qualityText,
+  };
+
+  const pipeline = { cards: [] };
+  const quality = { cards: [] };
+
+  let phases = [];
+  let blockers = [];
+  let openQuestions = [];
+  let activityEntries = [];
+
+  // --- Parse SHARED_PLANNING.md ---
+  if (planningText) {
+    try {
+      const header = parsePlanningHeader(planningText);
+      meta.featureKey = header.featureKey;
+      meta.featureName = header.featureName;
+      meta.lastUpdated = header.lastUpdated;
+      phases = parsePipelinePhases(planningText);
+      blockers = parseBlockers(planningText);
+      openQuestions = parseOpenQuestions(planningText);
+      activityEntries = parseActivityEntries(planningText);
+    } catch (e) {
+      errors.push("planning parse error: " + e.message);
+    }
+  }
+
+  // --- Parse QUALITY_CHECKLIST.md ---
+  let qualityPhases = [];
+  const qualityGateByPhaseName = {};
+
+  if (qualityText) {
+    try {
+      const qHeader = parsePlanningHeader(qualityText);
+      if (!meta.featureKey) meta.featureKey = qHeader.featureKey;
+      if (!meta.lastUpdated) meta.lastUpdated = qHeader.lastUpdated;
+      qualityPhases = parseQualityCriteria(qualityText);
+      for (const qp of qualityPhases) {
+        qualityGateByPhaseName[qp.phaseName.toLowerCase()] = qp.gate;
+      }
+    } catch (e) {
+      errors.push("quality parse error: " + e.message);
+    }
+  }
+
+  // --- Enrich pipeline phases with OQ/blocker flags ---
+  const enrichedPhases = phases.map((phase) => {
+    const phaseKey = phase.phase.toLowerCase();
+    const hasOpenOQ = openQuestions.some((oq) => {
+      const oqAgent = normalizeAgent(oq.owner);
+      const firstWord = phaseKey.split(/[\s.]+/)[0];
+      return (
+        oqAgent === phase.agent ||
+        (oq.id || "").toLowerCase().includes(firstWord) ||
+        (oq.summary || "").toLowerCase().includes(firstWord)
+      );
+    });
+    const hasBlocker =
+      blockers.length > 0 &&
+      blockers.some((b) => {
+        const bl = b.toLowerCase();
+        const firstWord = phaseKey.split(/[\s.]+/)[0];
+        return (
+          bl.includes(firstWord) ||
+          (phase.agent && bl.includes(phase.agent.toLowerCase()))
+        );
+      });
+    return { ...phase, hasOpenOQ, hasBlocker };
+  });
+
+  // --- Build pipeline cards ---
+  for (const phase of enrichedPhases) {
+    const phaseKey = phase.phase.toLowerCase();
+
+    const matchedGate = findMatchingEntry(qualityGateByPhaseName, phaseKey);
+    const statusLower = phase.rawStatus.toLowerCase();
+    const isDone = DONE_STATUSES.has(statusLower);
+    const trustMismatch =
+      matchedGate !== null && isDone && matchedGate !== null && !matchedGate.checked;
+
+    const { column, attention } = derivePipelineColumn(
+      phase.rawStatus,
+      phase.hasOpenOQ,
+      phase.hasBlocker,
+      trustMismatch
+    );
+
+    const agentLower = (phase.agent || "").toLowerCase();
+    const relevantActivity = activityEntries.filter(
+      (e) => e.handoffNext && e.handoffNext.toLowerCase().includes(agentLower)
+    );
+    const lastActivity =
+      relevantActivity.length > 0
+        ? relevantActivity[relevantActivity.length - 1]
+        : activityEntries.length > 0
+        ? activityEntries[activityEntries.length - 1]
+        : null;
+
+    pipeline.cards.push({
+      id: "phase-" + phaseKey.replace(/[^a-z0-9]/g, "-"),
+      title: phase.phase
+        .replace(/^\*{0,2}\d+[+]?\.\s*\*{0,2}/, "")
+        .replace(/\*\*/g, "")
+        .trim(),
+      agent: phase.agent || "OTHER",
+      column,
+      rawStatus: phase.rawStatus,
+      owner: phase.owner,
+      artifact: phase.artifact,
+      notes: phase.notes,
+      attention,
+      lastUpdate: lastActivity ? lastActivity.ts : null,
+      handoffNext: lastActivity ? lastActivity.handoffNext : null,
+    });
+  }
+
+  // --- Build quality cards ---
+  const phaseInfoByName = {};
+  for (const p of enrichedPhases) {
+    phaseInfoByName[p.phase.toLowerCase()] = {
+      rawStatus: p.rawStatus,
+      hasBlocker: p.hasBlocker,
+      hasOpenOQ: p.hasOpenOQ,
+    };
+  }
+
+  for (const qPhase of qualityPhases) {
+    const phaseInfo = findMatchingEntry(phaseInfoByName, qPhase.phaseName);
+    const phaseStatus = phaseInfo ? phaseInfo.rawStatus : "";
+    const phaseHasBlocker = phaseInfo ? phaseInfo.hasBlocker : false;
+    const phaseHasOpenOQ = phaseInfo ? phaseInfo.hasOpenOQ : false;
+
+    const allItems = [
+      ...qPhase.criteria,
+      ...(qPhase.gate ? [qPhase.gate] : []),
+    ];
+
+    for (let i = 0; i < allItems.length; i++) {
+      const item = allItems[i];
+      // Issue is meaningful if it's not just an @-mention (those are handoff hints)
+      const hasIssue =
+        item.issue &&
+        item.issue.length > 0 &&
+        !item.issue.trim().startsWith("@");
+
+      const { column, attention } = deriveQualityColumn(
+        item.checked,
+        phaseHasBlocker,
+        phaseHasOpenOQ,
+        hasIssue,
+        phaseStatus
+      );
+
+      quality.cards.push({
+        id: "q-" + qPhase.phaseNum + "-" + i,
+        title: item.criteria,
+        agent: item.agent || qPhase.agent || "OTHER",
+        phase: qPhase.phaseName,
+        column,
+        checked: item.checked,
+        isGate: item.isGate,
+        issue: item.issue,
+        attention,
+      });
+    }
+  }
+
+  // --- Derive agents list (canonical order first, extras appended) ---
+  const seenAgents = new Set();
+  for (const c of [...pipeline.cards, ...quality.cards]) {
+    if (c.agent && c.agent !== "OTHER") seenAgents.add(c.agent);
+  }
+  const agents = AGENT_ORDER.filter((a) => seenAgents.has(a));
+  for (const a of seenAgents) {
+    if (!AGENT_ORDER.includes(a)) agents.push(a);
+  }
+  if (agents.length === 0) agents.push(...AGENT_ORDER);
+
+  meta.errors = errors;
+  return { meta, agents, pipeline, quality };
+}
+
+module.exports = {
+  parseKaban,
+  KABAN_LIVENESS_MIN,
+  COLUMNS,
+  AGENT_ORDER,
+};

package/src/lib/wiki-runner.js

@@ -9,6 +9,7 @@ const { spawn, execFile } = require("child_process");
 const { CliError, DependencyError } = require("./errors");
 const { resolveBuilderPath } = require("./wiki-config");
 const { openBrowser } = require("./browser-open");
+const { parseKaban } = require("./wiki-kaban-parse");
 
 const HEALTH_CHECK_RETRIES = 20;
 const HEALTH_CHECK_INTERVAL_MS = 300;
@@ -248,6 +249,51 @@ function startWikiServer(host, port, outputDir, projectPath) {
         return;
       }
 
+      if (url === "/api/kaban" || url === "/api/kaban/") {
+        const projectRoot = projectPath || outputDir;
+        let planningText = null;
+        let qualityText = null;
+
+        const planningFile = path.resolve(projectRoot, "SHARED_PLANNING.md");
+        const qualityFile = path.resolve(projectRoot, "QUALITY_CHECKLIST.md");
+        const inRoot = (f) =>
+          f.startsWith(projectRoot + path.sep) || f === projectRoot;
+
+        try {
+          if (inRoot(planningFile) && fs.existsSync(planningFile)) {
+            planningText = fs.readFileSync(planningFile, "utf-8");
+          }
+        } catch (_) {}
+        try {
+          if (inRoot(qualityFile) && fs.existsSync(qualityFile)) {
+            qualityText = fs.readFileSync(qualityFile, "utf-8");
+          }
+        } catch (_) {}
+
+        let viewModel;
+        try {
+          viewModel = parseKaban({ planningText, qualityText, now: new Date() });
+        } catch (e) {
+          viewModel = {
+            meta: {
+              errors: ["Server error: " + e.message],
+              pipelinePresent: false,
+              qualityPresent: false,
+            },
+            agents: [],
+            pipeline: { cards: [] },
+            quality: { cards: [] },
+          };
+        }
+
+        res.writeHead(200, {
+          "Content-Type": "application/json",
+          "Cache-Control": "no-cache",
+        });
+        res.end(JSON.stringify(viewModel));
+        return;
+      }
+
       if (url.startsWith("/api/note")) {
         const qs = new URL(url, `http://${host}:${port}`).searchParams;
         const notePath = qs.get("path");