@jaimevalasek/aioson 1.5.1 → 1.7.0

package/src/commands/devlog-process.js

@@ -0,0 +1,292 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb, startTask, startRun, updateRun, updateTask, appendRunEvent, attachArtifact } = require('../runtime-store');
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function createLearningId() {
+  return `learning-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return null;
+  const result = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const colonIdx = line.indexOf(':');
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim().replace(/^["']|["']$/g, '');
+    if (key) result[key] = value === 'null' ? null : value;
+  }
+  return result;
+}
+
+function extractSection(content, sectionName) {
+  const re = new RegExp(`^#{1,4}\\s+${sectionName}[\\s\\S]*?(?=^#{1,4}\\s|\\Z)`, 'im');
+  const match = content.match(re);
+  if (!match) return '';
+  return match[0].replace(/^#{1,4}\s+\S[^\n]*\n/, '').trim();
+}
+
+function extractListItems(content, sectionName) {
+  const section = extractSection(content, sectionName);
+  const items = [];
+  for (const line of section.split(/\r?\n/)) {
+    const trimmed = line.replace(/^[-*]\s*/, '').trim();
+    if (trimmed && trimmed.length > 2) items.push(trimmed);
+  }
+  return items;
+}
+
+function extractTaggedLearnings(content) {
+  const section = extractSection(content, 'Learnings');
+  const learnings = [];
+  for (const line of section.split(/\r?\n/)) {
+    const trimmed = line.replace(/^[-*]\s*/, '').trim();
+    if (!trimmed) continue;
+    const typeMatch = trimmed.match(/^\[(process|domain|quality|preference)\]\s+(.+)/i);
+    if (typeMatch) {
+      learnings.push({ type: typeMatch[1].toLowerCase(), title: typeMatch[2].trim() });
+    } else if (trimmed.length > 5) {
+      learnings.push({ type: 'process', title: trimmed });
+    }
+  }
+  return learnings;
+}
+
+function extractSummary(content) {
+  const section = extractSection(content, 'Summary');
+  if (section) return section.split(/\r?\n/)[0].trim();
+  // Fallback: first non-empty line of body after frontmatter
+  const body = content.replace(/^---[\s\S]*?---\r?\n/, '');
+  const firstHeading = body.match(/^#\s+(.+)/m);
+  return firstHeading ? firstHeading[1].trim() : null;
+}
+
+function upsertProjectLearning(db, { title, type, featureSlug, evidence, sourceSession }) {
+  const existing = db.prepare(
+    'SELECT learning_id, frequency FROM project_learnings WHERE title = ? AND (feature_slug = ? OR (feature_slug IS NULL AND ? IS NULL))'
+  ).get(title, featureSlug || null, featureSlug || null);
+
+  if (existing) {
+    db.prepare(
+      'UPDATE project_learnings SET frequency = ?, last_reinforced = ?, updated_at = ? WHERE learning_id = ?'
+    ).run(existing.frequency + 1, nowIso(), nowIso(), existing.learning_id);
+    return { action: 'updated', learningId: existing.learning_id };
+  }
+
+  const learningId = createLearningId();
+  db.prepare(`
+    INSERT INTO project_learnings
+      (learning_id, feature_slug, type, title, confidence, frequency, last_reinforced,
+       applies_to, source_session, evidence, status, created_at, updated_at)
+    VALUES (?, ?, ?, ?, 'medium', 1, ?, 'project', ?, ?, 'active', ?, ?)
+  `).run(learningId, featureSlug || null, type, title, nowIso(), sourceSession || null, evidence || null, nowIso(), nowIso());
+  return { action: 'inserted', learningId };
+}
+
+async function markAsProcessed(filePath, processedAt) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const ts = processedAt || nowIso();
+
+  // If file already has processed_at, skip
+  if (/^processed_at:/m.test(content)) return;
+
+  // Inject processed_at into frontmatter
+  const updated = content.replace(/^(---\r?\n[\s\S]*?)(---)/m, `$1processed_at: ${ts}\n$2`);
+  await fs.writeFile(filePath, updated, 'utf8');
+}
+
+async function processDevlogFile(db, filePath) {
+  const content = await fs.readFile(filePath, 'utf8');
+  const fm = parseFrontmatter(content);
+
+  if (!fm || !fm.agent) {
+    return { status: 'malformed', file: path.basename(filePath), reason: 'missing frontmatter or agent field' };
+  }
+
+  // Skip already-processed devlogs
+  if (fm.processed_at) {
+    return { status: 'skipped', file: path.basename(filePath), reason: 'already processed' };
+  }
+
+  const body = content.replace(/^---[\s\S]*?---\r?\n?/, '');
+  const summary = extractSummary(body) || `@${fm.agent} devlog`;
+  const featureSlug = fm.feature && fm.feature !== 'project' ? fm.feature : null;
+  const sessionKey = fm.session_key || null;
+  const startedAt = fm.started_at || fm.session_start || nowIso();
+  const finishedAt = fm.finished_at || fm.session_end || nowIso();
+  const status = fm.status === 'partial' ? 'running' : 'completed';
+  const verdict = fm.verdict ? String(fm.verdict).trim().toUpperCase() : null;
+  const planStepId = fm.plan_step || null;
+
+  // Create task + run
+  const taskKey = startTask(db, {
+    title: `devlog: ${summary}`,
+    squadSlug: null,
+    sessionKey: sessionKey || undefined,
+    status,
+    createdBy: fm.agent
+  });
+
+  const runKey = startRun(db, {
+    taskKey,
+    agentName: fm.agent,
+    agentKind: 'devlog',
+    squadSlug: null,
+    title: `@${fm.agent} devlog`,
+    message: summary
+  });
+
+  // Register artifacts
+  const artifactPaths = extractListItems(body, 'Artifacts');
+  for (const filePath_ of artifactPaths) {
+    // Only register file-like entries (containing a slash or dot)
+    if (/[/.]/.test(filePath_)) {
+      attachArtifact(db, { runKey, agentName: fm.agent, kind: 'output', filePath: filePath_ });
+    }
+  }
+
+  // Register decisions as execution events
+  const decisions = extractListItems(body, 'Decisions');
+  for (const decision of decisions) {
+    appendRunEvent(db, {
+      runKey,
+      eventType: 'decision',
+      phase: 'devlog',
+      status: 'completed',
+      message: decision,
+      createdAt: finishedAt
+    });
+  }
+
+  // Upsert learnings
+  const learnings = extractTaggedLearnings(body);
+  for (const { type, title } of learnings) {
+    upsertProjectLearning(db, { title, type, featureSlug, sourceSession: sessionKey || path.basename(filePath) });
+  }
+
+  // Log verdict if present
+  if (verdict && verdict !== 'NULL') {
+    appendRunEvent(db, {
+      runKey,
+      eventType: 'qa_verdict',
+      phase: 'devlog',
+      status: 'completed',
+      message: `QA VERDICT: ${verdict}`,
+      verdict,
+      planStepId,
+      createdAt: finishedAt
+    });
+  }
+
+  // Close run
+  updateRun(db, runKey, {
+    status,
+    summary,
+    finishedAt
+  });
+
+  if (status === 'completed') {
+    updateTask(db, taskKey, { status: 'completed', finishedAt });
+  }
+
+  // Mark devlog as processed
+  await markAsProcessed(filePath, nowIso());
+
+  return {
+    status: 'ok',
+    file: path.basename(filePath),
+    runKey,
+    taskKey,
+    featureSlug,
+    artifactsCount: artifactPaths.filter((p) => /[/.]/.test(p)).length,
+    decisionsCount: decisions.length,
+    learningsCount: learnings.length,
+    verdict: verdict && verdict !== 'NULL' ? verdict : null
+  };
+}
+
+async function runDevlogProcess({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const logsDir = path.join(targetDir, 'aioson-logs');
+
+  let entries;
+  try {
+    entries = await fs.readdir(logsDir);
+  } catch {
+    if (!options.json) logger.log('No aioson-logs/ directory found — nothing to process.');
+    return { ok: true, processed: 0, skipped: 0, malformed: 0 };
+  }
+
+  const devlogFiles = entries
+    .filter((f) => f.startsWith('devlog-') && f.endsWith('.md'))
+    .sort();
+
+  if (devlogFiles.length === 0) {
+    if (!options.json) logger.log('No devlog files found.');
+    return { ok: true, processed: 0, skipped: 0, malformed: 0 };
+  }
+
+  const { db, dbPath } = await openRuntimeDb(targetDir);
+  const results = [];
+
+  try {
+    for (const file of devlogFiles) {
+      const result = await processDevlogFile(db, path.join(logsDir, file));
+      results.push(result);
+    }
+  } finally {
+    db.close();
+  }
+
+  const processed = results.filter((r) => r.status === 'ok');
+  const skipped = results.filter((r) => r.status === 'skipped');
+  const malformed = results.filter((r) => r.status === 'malformed');
+
+  const totalArtifacts = processed.reduce((s, r) => s + (r.artifactsCount || 0), 0);
+  const totalLearnings = processed.reduce((s, r) => s + (r.learningsCount || 0), 0);
+
+  if (options.json) {
+    return { ok: true, results, processed: processed.length, skipped: skipped.length, malformed: malformed.length, totalArtifacts, totalLearnings, dbPath };
+  }
+
+  logger.log(`Devlog Processing — ${path.basename(targetDir)}`);
+  logger.log('─'.repeat(50));
+
+  if (results.length === 0) {
+    logger.log('No devlogs to process.');
+  } else {
+    logger.log(`Found ${devlogFiles.length} devlog(s):`);
+    logger.log('');
+    for (const r of results) {
+      if (r.status === 'ok') {
+        logger.log(`${r.file}`);
+        logger.log(`  Agent: @${r.featureSlug ? `${r.featureSlug}` : 'project'} | run: ${r.runKey}`);
+        if (r.artifactsCount > 0) logger.log(`  Artifacts: ${r.artifactsCount} registered ✓`);
+        if (r.decisionsCount > 0) logger.log(`  Decisions: ${r.decisionsCount} logged ✓`);
+        if (r.learningsCount > 0) logger.log(`  Learnings: ${r.learningsCount} upserted ✓`);
+        if (r.verdict) logger.log(`  Verdict: ${r.verdict} ✓`);
+      } else if (r.status === 'skipped') {
+        logger.log(`${r.file} — skipped (${r.reason})`);
+      } else {
+        logger.log(`${r.file} — ⚠ ${r.reason}. Fix frontmatter and re-run.`);
+      }
+    }
+  }
+
+  logger.log('─'.repeat(50));
+  logger.log(`Processed: ${processed.length}/${devlogFiles.length} devlogs`);
+  if (totalLearnings > 0) logger.log(`New learnings: ${totalLearnings} (queued for brains export)`);
+  if (totalArtifacts > 0) logger.log(`Artifacts registered: ${totalArtifacts}`);
+  if (malformed.length > 0) logger.log(`Malformed (skipped): ${malformed.length}`);
+
+  return { ok: true, results, processed: processed.length, skipped: skipped.length, malformed: malformed.length, totalArtifacts, totalLearnings, dbPath };
+}
+
+module.exports = { runDevlogProcess, processDevlogFile };

package/src/commands/devlog-watch.js

@@ -0,0 +1,131 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const fsSync = require('node:fs');
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+const { processDevlogFile } = require('./devlog-process');
+
+const POLL_INTERVAL_MS = 5000;
+const WSL_VERSION_PATH = '/proc/version';
+
+async function isWsl2() {
+  try {
+    const version = await fs.readFile(WSL_VERSION_PATH, 'utf8');
+    return version.toLowerCase().includes('microsoft');
+  } catch {
+    return false;
+  }
+}
+
+async function processNewDevlog(targetDir, filePath, logger) {
+  const { db, dbPath } = await openRuntimeDb(targetDir).catch(() => ({ db: null }));
+  if (!db) {
+    logger.log(`[DEVLOG WATCHER] No database available — skipping ${path.basename(filePath)}`);
+    return;
+  }
+  try {
+    const result = await processDevlogFile(db, filePath);
+    if (result.status === 'ok') {
+      const parts = [];
+      if (result.learningsCount > 0) parts.push(`${result.learningsCount} learnings`);
+      if (result.artifactsCount > 0) parts.push(`${result.artifactsCount} artifacts`);
+      if (result.verdict) parts.push(`VERDICT: ${result.verdict}`);
+      const detail = parts.length > 0 ? ` → ${parts.join(', ')} → SQLite ✓` : ' → SQLite ✓';
+      logger.log(`[${new Date().toISOString().slice(11, 19)}] Processed: ${result.file}${detail}`);
+    } else if (result.status === 'skipped') {
+      // silently skip already-processed files
+    } else {
+      logger.log(`[${new Date().toISOString().slice(11, 19)}] ⚠ ${result.file}: ${result.reason}`);
+    }
+  } finally {
+    db.close();
+  }
+}
+
+async function watchWithFsWatch(logsDir, targetDir, logger) {
+  logger.log(`[DEVLOG WATCHER] Using fs.watch on ${logsDir}`);
+
+  return new Promise((resolve) => {
+    const watcher = fsSync.watch(logsDir, { persistent: true }, async (eventType, filename) => {
+      if (!filename || !filename.startsWith('devlog-') || !filename.endsWith('.md')) return;
+      if (eventType !== 'rename' && eventType !== 'change') return;
+
+      const filePath = path.join(logsDir, filename);
+      // Small delay to ensure file is fully written
+      setTimeout(async () => {
+        try {
+          await fs.access(filePath);
+          logger.log(`[${new Date().toISOString().slice(11, 19)}] New: ${filename} → processing...`);
+          await processNewDevlog(targetDir, filePath, logger);
+        } catch { /* file may have been removed */ }
+      }, 200);
+    });
+
+    process.on('SIGINT', () => { watcher.close(); resolve(); });
+    process.on('SIGTERM', () => { watcher.close(); resolve(); });
+  });
+}
+
+async function watchWithPolling(logsDir, targetDir, logger) {
+  logger.log(`[DEVLOG WATCHER] WSL2 detected — using polling (${POLL_INTERVAL_MS / 1000}s interval)`);
+
+  const seen = new Set();
+
+  // Seed with already-existing files so we don't reprocess them
+  try {
+    const entries = await fs.readdir(logsDir);
+    for (const f of entries) {
+      if (f.startsWith('devlog-') && f.endsWith('.md')) seen.add(f);
+    }
+  } catch { /* logsDir not yet created */ }
+
+  return new Promise((resolve) => {
+    const timer = setInterval(async () => {
+      try {
+        const entries = await fs.readdir(logsDir);
+        const devlogs = entries.filter((f) => f.startsWith('devlog-') && f.endsWith('.md'));
+        for (const filename of devlogs) {
+          if (!seen.has(filename)) {
+            seen.add(filename);
+            const filePath = path.join(logsDir, filename);
+            logger.log(`[${new Date().toISOString().slice(11, 19)}] New: ${filename} → processing...`);
+            await processNewDevlog(targetDir, filePath, logger);
+          }
+        }
+      } catch { /* directory may not exist yet */ }
+    }, POLL_INTERVAL_MS);
+
+    process.on('SIGINT', () => { clearInterval(timer); resolve(); });
+    process.on('SIGTERM', () => { clearInterval(timer); resolve(); });
+  });
+}
+
+async function runDevlogWatch({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const logsDir = path.join(targetDir, 'aioson-logs');
+  const usePolling = options.poll || await isWsl2();
+
+  // Ensure the directory exists
+  await fs.mkdir(logsDir, { recursive: true });
+
+  logger.log(`[DEVLOG WATCHER] Watching ${logsDir} for new devlogs...`);
+  logger.log('[DEVLOG WATCHER] Press Ctrl+C to stop.');
+
+  if (usePolling) {
+    await watchWithPolling(logsDir, targetDir, logger);
+  } else {
+    try {
+      await watchWithFsWatch(logsDir, targetDir, logger);
+    } catch (err) {
+      // Fall back to polling if fs.watch fails (can happen in some environments)
+      logger.log(`[DEVLOG WATCHER] fs.watch failed (${err.message}) — falling back to polling`);
+      await watchWithPolling(logsDir, targetDir, logger);
+    }
+  }
+
+  logger.log('[DEVLOG WATCHER] Stopped.');
+  return { ok: true };
+}
+
+module.exports = { runDevlogWatch };

package/src/commands/feature-close.js

@@ -0,0 +1,165 @@
+'use strict';
+
+/**
+ * aioson feature:close — close a feature after QA sign-off.
+ *
+ * Updates spec-{slug}.md (adds QA sign-off block), features.md (sets status to done),
+ * and project-pulse.md (removes from active work).
+ *
+ * Usage:
+ *   aioson feature:close . --feature=checkout --verdict=PASS
+ *   aioson feature:close . --feature=checkout --verdict=PASS --residual="Email delivery not tested E2E"
+ *   aioson feature:close . --feature=checkout --verdict=FAIL --notes="Auth edge case missing"
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { contextDir, readFileSafe, parseFrontmatter } = require('../preflight-engine');
+
+function nowDate() {
+  return new Date().toISOString().slice(0, 10);
+}
+
+async function updateSpecFile(specPath, verdict, residual, date) {
+  const content = await readFileSafe(specPath);
+  if (!content) return false;
+
+  const signOff = [
+    '',
+    '## QA Sign-off',
+    '',
+    `- **Date:** ${date}`,
+    `- **Verdict:** ${verdict}`,
+    residual ? `- **Residual:** ${residual}` : null,
+    `- **Gate D (execution):** ${verdict === 'PASS' ? 'approved' : 'rejected'}`,
+    ''
+  ].filter((l) => l !== null).join('\n');
+
+  // Update gate_execution in frontmatter first (on original content)
+  const newStatus = verdict === 'PASS' ? 'approved' : 'rejected';
+  const fm = parseFrontmatter(content);
+  let baseContent = content;
+  if (Object.keys(fm).length > 0) {
+    baseContent = content.replace(
+      /^---\r?\n[\s\S]*?\r?\n---/,
+      (block) => {
+        if (block.includes('gate_execution')) {
+          return block.replace(/gate_execution:\s*.+/, `gate_execution: ${newStatus}`);
+        }
+        return block.replace(/^---\r?\n/, `---\ngate_execution: ${newStatus}\n`);
+      }
+    );
+  }
+
+  // Now apply QA sign-off on top of the frontmatter-updated content
+  if (baseContent.includes('## QA Sign-off')) {
+    const updated = baseContent.replace(
+      /## QA Sign-off[\s\S]*?(?=\n##|\s*$)/,
+      signOff.trimStart()
+    );
+    await fs.writeFile(specPath, updated, 'utf8');
+  } else {
+    await fs.writeFile(specPath, baseContent + signOff, 'utf8');
+  }
+
+  return true;
+}
+
+async function updateFeaturesFile(featuresPath, slug, verdict, date) {
+  const content = await readFileSafe(featuresPath);
+  if (!content) return false;
+
+  const status = verdict === 'PASS' ? 'done' : 'qa_failed';
+
+  // Try to find and update the feature row
+  const updated = content.replace(
+    new RegExp(`(\\|[^|]*${slug}[^|]*\\|[^|]*\\|)[^|]*(\\|)`, 'g'),
+    (match, before, after) => `${before} ${status} (${date}) ${after}`
+  );
+
+  if (updated !== content) {
+    await fs.writeFile(featuresPath, updated, 'utf8');
+    return true;
+  }
+
+  // Append if not found
+  const line = `| ${slug} | ${verdict === 'PASS' ? 'done' : 'qa_failed'} | ${date} | QA ${verdict} |`;
+  await fs.appendFile(featuresPath, `\n${line}\n`, 'utf8');
+  return true;
+}
+
+async function runFeatureClose({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.feature ? String(options.feature) : null;
+  const verdict = options.verdict ? String(options.verdict).toUpperCase() : null;
+  const residual = options.residual ? String(options.residual) : null;
+  const notes = options.notes ? String(options.notes) : null;
+
+  if (!slug) {
+    if (options.json) return { ok: false, reason: 'missing_feature' };
+    logger.log('--feature=<slug> is required.');
+    return { ok: false };
+  }
+
+  if (!verdict || !['PASS', 'FAIL'].includes(verdict)) {
+    if (options.json) return { ok: false, reason: 'invalid_verdict' };
+    logger.log('--verdict=PASS or --verdict=FAIL is required.');
+    return { ok: false };
+  }
+
+  const today = nowDate();
+  const dir = contextDir(targetDir);
+  const updates = [];
+
+  // 1. Update spec file
+  const specPath = path.join(dir, `spec-${slug}.md`);
+  const specUpdated = await updateSpecFile(specPath, verdict, residual || notes, today);
+  if (specUpdated) {
+    updates.push(`spec-${slug}.md: added QA sign-off (${today}, ${verdict})`);
+  } else {
+    updates.push(`spec-${slug}.md: not found (skipped)`);
+  }
+
+  // 2. Update features.md
+  const featuresPath = path.join(dir, 'features.md');
+  const featuresContent = await readFileSafe(featuresPath);
+  if (featuresContent) {
+    await updateFeaturesFile(featuresPath, slug, verdict, today);
+    updates.push(`features.md: ${slug} → ${verdict === 'PASS' ? 'done' : 'qa_failed'} (${today})`);
+  } else {
+    updates.push('features.md: not found (skipped)');
+  }
+
+  // 3. Update project-pulse.md
+  const pulsePath = path.join(dir, 'project-pulse.md');
+  const pulseContent = await readFileSafe(pulsePath);
+  if (pulseContent) {
+    const fm = parseFrontmatter(pulseContent);
+    const status = verdict === 'PASS' ? 'closed' : 'qa_failed';
+    const updatedPulse = pulseContent
+      .replace(/active_feature:\s*.+/, `active_feature: (none)`)
+      .replace(/active_work:\s*".+"/, `active_work: ""`)
+      .replace(/last_agent:\s*.+/, `last_agent: qa`)
+      .replace(/last_gate:\s*.+/, `last_gate: Gate D: ${verdict === 'PASS' ? 'approved' : 'rejected'}`);
+    await fs.writeFile(pulsePath, updatedPulse, 'utf8');
+    updates.push('project-pulse.md: updated active work');
+  }
+
+  const result = {
+    ok: true,
+    feature: slug,
+    verdict,
+    date: today,
+    residual: residual || notes || null,
+    updates
+  };
+
+  if (options.json) return result;
+
+  logger.log(`Feature closure — ${slug}:`);
+  for (const u of updates) logger.log(`  ${u}`);
+
+  return result;
+}
+
+module.exports = { runFeatureClose };