dw-kit 1.4.0 → 1.7.0-rc.1

package/src/lib/lint-rules.mjs

@@ -0,0 +1,149 @@
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { parseFrontmatter, loadSchema, validateFrontmatter } from './frontmatter.mjs';
+import { parseTimeline } from './timeline-parser.mjs';
+
+const DRIFT_MARKERS = [
+  /✅\s*(COMPLETED|DONE)/i,
+  /🟡\s*(IN[\s_-]?PROGRESS|WIP)/i,
+  /\b(?:Status|Trạng thái):\s*(?:Done|Completed|In Progress|Blocked)\b/i,
+  /^\s*\*\*ST-\d+:.*?(?:✅|🟡|🔴|⏸)/m,
+];
+
+const GENERIC_APPENDAGE_NAMES = new Set([
+  'notes.md',
+  'extra.md',
+  'extra-2.md',
+  'temp.md',
+  'tmp.md',
+  'wip.md',
+  'misc.md',
+  'todo.md',
+]);
+
+const SECTION_LIMITS = {
+  2: 200,
+  3: 80,
+  4: 400,
+};
+
+export function lintTimeline(taskDir, opts = {}) {
+  const violations = [];
+  const timelineFile = join(taskDir, 'task.md');
+
+  if (!existsSync(timelineFile)) {
+    return { ok: false, violations: [{ severity: 'error', rule: 'file', message: 'task.md not found', path: taskDir }] };
+  }
+
+  const content = readFileSync(timelineFile, 'utf8');
+  const fm = parseFrontmatter(content);
+  const parsed = parseTimeline(content);
+
+  const schema = loadSchema(process.cwd());
+  if (schema) {
+    const result = validateFrontmatter(fm, schema);
+    if (!result.ok) {
+      for (const e of result.errors) {
+        violations.push({
+          severity: 'error',
+          rule: 'frontmatter-schema',
+          message: `${e.path}: ${e.message}${e.keyword ? ` (${e.keyword})` : ''}`,
+          file: timelineFile,
+        });
+      }
+    }
+  }
+
+  const section2 = parsed.sections[2];
+  if (section2) {
+    const stripped = stripCodeAndQuotes(section2.text);
+    for (const re of DRIFT_MARKERS) {
+      if (re.test(stripped)) {
+        violations.push({
+          severity: 'error',
+          rule: 'section2-status-leak',
+          message: `Status markers in Section 2 (Intent & Scope). Status lives only in Section 3 (Tracker).`,
+          file: timelineFile,
+          line: findFirstMatchLine(content, re),
+        });
+        break;
+      }
+    }
+  }
+
+  for (const [num, max] of Object.entries(SECTION_LIMITS)) {
+    const sec = parsed.sections[Number(num)];
+    if (!sec) continue;
+    const lines = sec.text.split('\n').length;
+    if (lines > max) {
+      violations.push({
+        severity: num === '4' ? 'warning' : 'warning',
+        rule: 'section-line-cap',
+        message: `Section ${num} (${sec.name}) is ${lines} lines (limit ${max}). ${num === '4' ? 'Auto-rotate to timeline-history.md via stop-check hook.' : 'Consider trimming.'}`,
+        file: timelineFile,
+      });
+    }
+  }
+
+  const section3 = parsed.sections[3];
+  if (section3 && !/Status legend/i.test(section3.text)) {
+    violations.push({
+      severity: 'warning',
+      rule: 'tracker-legend-missing',
+      message: 'Section 3 missing "Status legend" line. Add: Status legend: ⬜ Pending · 🟡 In Progress · ✅ Done · 🔴 Blocked · ⏸ Paused',
+      file: timelineFile,
+    });
+  }
+
+  try {
+    const files = readdirSync(taskDir);
+    for (const f of files) {
+      if (GENERIC_APPENDAGE_NAMES.has(f.toLowerCase())) {
+        violations.push({
+          severity: 'warning',
+          rule: 'generic-appendage-name',
+          message: `Generic appendage name "${f}" — prefer specific names like baseline.md, experiment-{id}.md, debate-r{N}.md`,
+          file: join(taskDir, f),
+        });
+      }
+    }
+  } catch { /* skip */ }
+
+  if (parsed.body.includes('![Timeline](./timeline.svg)') === false && parsed.body.includes('timeline.svg') === false) {
+    violations.push({
+      severity: 'warning',
+      rule: 'svg-reference-missing',
+      message: 'Section 1 missing `![Timeline](./timeline.svg)` reference. Human GitHub preview will not render visual.',
+      file: timelineFile,
+    });
+  }
+
+  return { ok: violations.every((v) => v.severity !== 'error'), violations };
+}
+
+function findFirstMatchLine(content, re) {
+  const lines = content.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (re.test(stripCodeAndQuotes(lines[i]))) return i + 1;
+  }
+  return null;
+}
+
+function stripCodeAndQuotes(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, '')
+    .replace(/`[^`\n]*`/g, '')
+    .replace(/^\s*>\s.*$/gm, '');
+}
+
+export function findAllTaskDirs(rootDir) {
+  const tasksRoot = join(rootDir, '.dw', 'tasks');
+  if (!existsSync(tasksRoot)) return [];
+  return readdirSync(tasksRoot)
+    .filter((e) => e !== 'archive' && e !== 'ACTIVE.md')
+    .map((e) => join(tasksRoot, e))
+    .filter((p) => {
+      try { return statSync(p).isDirectory() && existsSync(join(p, 'task.md')); }
+      catch { return false; }
+    });
+}

package/src/lib/sse-broker.mjs

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync, statSync, watch as fsWatch } from 'node:fs';
+import { eventsGlobalFile, readGoalEvents } from './goal-events.mjs';
+
+const MAX_CLIENTS_DEFAULT = 10;
+const KEEPALIVE_MS = 30 * 1000;
+const INITIAL_BACKFILL = 100;
+
+export function createSseBroker(rootDir = process.cwd(), { maxClients = MAX_CLIENTS_DEFAULT } = {}) {
+  const clients = new Set();
+  let lastByteRead = 0;
+  let watcher = null;
+  let keepaliveTimer = null;
+
+  function broadcast(line) {
+    const frame = `data: ${line}\n\n`;
+    for (const res of clients) {
+      try { res.write(frame); } catch { /* dead conn; cleanup via close handler */ }
+    }
+  }
+
+  function startWatcher() {
+    const file = eventsGlobalFile(rootDir);
+    if (!existsSync(file)) return;
+    try { lastByteRead = statSync(file).size; } catch { lastByteRead = 0; }
+    try {
+      watcher = fsWatch(file, { persistent: true }, () => {
+        try {
+          const content = readFileSync(file, 'utf8');
+          if (content.length <= lastByteRead) {
+            lastByteRead = content.length;
+            return;
+          }
+          const newSegment = content.slice(lastByteRead);
+          lastByteRead = content.length;
+          const lines = newSegment.split('\n').filter(Boolean);
+          for (const line of lines) broadcast(line);
+        } catch { /* read error; skip cycle */ }
+      });
+    } catch { /* fs.watch unsupported on some platforms; SSE will only emit on new connections via backfill */ }
+  }
+
+  function startKeepalive() {
+    keepaliveTimer = setInterval(() => {
+      for (const res of clients) {
+        try { res.write(': ping\n\n'); } catch { /* cleanup via close */ }
+      }
+    }, KEEPALIVE_MS);
+  }
+
+  function addClient(req, res) {
+    if (clients.size >= maxClients) {
+      res.writeHead(503, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ error: 'max_clients', detail: `Max ${maxClients} SSE clients (W-4 cap)` }));
+      return false;
+    }
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-store, no-transform',
+      'Connection': 'keep-alive',
+      'X-Accel-Buffering': 'no',
+    });
+    res.write('retry: 5000\n\n');
+
+    // Initial backfill
+    const events = readGoalEvents(rootDir, { limit: INITIAL_BACKFILL });
+    for (const ev of events) {
+      try { res.write(`data: ${JSON.stringify(ev)}\n\n`); } catch { break; }
+    }
+
+    clients.add(res);
+    const cleanup = () => { clients.delete(res); };
+    res.on('close', cleanup);
+    res.on('error', cleanup);
+
+    if (!watcher) startWatcher();
+    if (!keepaliveTimer) startKeepalive();
+
+    return true;
+  }
+
+  function shutdown() {
+    if (keepaliveTimer) { clearInterval(keepaliveTimer); keepaliveTimer = null; }
+    if (watcher) { try { watcher.close(); } catch { /* ignore */ } watcher = null; }
+    for (const res of clients) {
+      try { res.end(); } catch { /* ignore */ }
+    }
+    clients.clear();
+  }
+
+  return { addClient, shutdown, clientCount: () => clients.size };
+}

package/src/lib/timeline-parser.mjs

@@ -0,0 +1,80 @@
+import { extractFrontmatterBlock } from './frontmatter.mjs';
+
+const SECTION_RE = /^##\s+(\d+)\.\s+(.+?)\s*$/gm;
+
+export function parseTimeline(content) {
+  const { body, raw, hasFrontmatter } = extractFrontmatterBlock(content);
+
+  const titleMatch = body.match(/^#\s+(.+?)\s*$/m);
+  const title = titleMatch ? titleMatch[1] : '';
+
+  const sections = {};
+  const matches = [...body.matchAll(SECTION_RE)];
+  for (let i = 0; i < matches.length; i++) {
+    const m = matches[i];
+    const num = Number(m[1]);
+    const name = m[2];
+    const start = m.index + m[0].length;
+    const end = i + 1 < matches.length ? matches[i + 1].index : body.length;
+    const text = body.slice(start, end).trim();
+    sections[num] = { num, name, text };
+  }
+
+  return {
+    frontmatter: hasFrontmatter ? raw : '',
+    title,
+    body,
+    sections,
+    hasFrontmatter,
+  };
+}
+
+export function parseSubtaskTracker(sectionText) {
+  if (!sectionText) return [];
+  const lines = sectionText.split('\n').map((l) => l.trim()).filter(Boolean);
+  const rows = [];
+  let inTable = false;
+  for (const line of lines) {
+    if (line.startsWith('|---') || line.match(/^\|[\s|:-]+\|$/)) { inTable = true; continue; }
+    if (!line.startsWith('|')) { inTable = false; continue; }
+    const cells = line.split('|').map((c) => c.trim()).filter((_, i, arr) => i > 0 && i < arr.length - 1);
+    if (cells.length < 2) continue;
+    if (!inTable && (cells[0].toLowerCase().startsWith('#') || cells[0].toLowerCase() === 'ws' || cells[0].toLowerCase() === 'st')) {
+      // header row
+      continue;
+    }
+    if (cells.length >= 3) {
+      rows.push({
+        id: cells[0],
+        name: cells[1],
+        status: cells[2],
+        date: cells[3] || '',
+        notes: cells[4] || '',
+      });
+    }
+  }
+  return rows;
+}
+
+export function countChangelogLines(sectionText) {
+  if (!sectionText) return 0;
+  return sectionText.split('\n').length;
+}
+
+export function splitChangelogEntries(sectionText) {
+  if (!sectionText) return [];
+  const lines = sectionText.split('\n');
+  const entries = [];
+  let current = null;
+  for (const line of lines) {
+    const headingMatch = line.match(/^###\s+(.+?)\s*$/);
+    if (headingMatch) {
+      if (current) entries.push(current);
+      current = { heading: headingMatch[1], lines: [] };
+    } else if (current) {
+      current.lines.push(line);
+    }
+  }
+  if (current) entries.push(current);
+  return entries;
+}

package/src/lib/watch-auth.mjs

@@ -0,0 +1,64 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { randomBytes } from 'node:crypto';
+
+const TOKEN_FILE = '.dw/cache/watch.token';
+
+export function tokenFile(rootDir = process.cwd()) {
+  return join(rootDir, TOKEN_FILE);
+}
+
+export function ensureToken(rootDir = process.cwd(), { rotate = false } = {}) {
+  const file = tokenFile(rootDir);
+  const dir = dirname(file);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!rotate && existsSync(file)) {
+    const t = readFileSync(file, 'utf8').trim();
+    if (t.length === 64) return t;
+  }
+  const token = randomBytes(32).toString('hex');
+  writeFileSync(file, token + '\n', { encoding: 'utf8', mode: 0o600 });
+  return token;
+}
+
+export function readToken(rootDir = process.cwd()) {
+  const file = tokenFile(rootDir);
+  if (!existsSync(file)) return null;
+  return readFileSync(file, 'utf8').trim() || null;
+}
+
+export function extractRequestToken(req) {
+  const header = req.headers['x-watch-token'];
+  if (header) return String(header).trim();
+  const cookies = req.headers.cookie;
+  if (cookies) {
+    const m = cookies.match(/(?:^|;\s*)dw_watch_token=([a-f0-9]{64})\b/);
+    if (m) return m[1];
+  }
+  if (req.url) {
+    try {
+      const url = new URL(req.url, 'http://localhost');
+      const q = url.searchParams.get('token');
+      if (q) return q;
+    } catch { /* ignore */ }
+  }
+  return null;
+}
+
+export function isAuthorized(req, token) {
+  const provided = extractRequestToken(req);
+  if (!provided || !token) return false;
+  if (provided.length !== token.length) return false;
+  let mismatch = 0;
+  for (let i = 0; i < provided.length; i++) {
+    mismatch |= provided.charCodeAt(i) ^ token.charCodeAt(i);
+  }
+  return mismatch === 0;
+}
+
+export function isWriteEndpoint(req) {
+  const method = (req.method || '').toUpperCase();
+  if (method === 'GET' || method === 'HEAD') return false;
+  // Treat all non-read methods as writes
+  return true;
+}