@jaimevalasek/aioson 1.6.0 → 1.7.2

package/src/commands/spec-sync.js

@@ -0,0 +1,190 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb } = 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 {};
+  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;
+  }
+  return result;
+}
+
+function extractSection(content, sectionName) {
+  const re = new RegExp(`^#{1,4}\\s+${sectionName}[\\s\\S]*?(?=^#{1,4}\\s|$)`, 'im');
+  const match = content.match(re);
+  if (!match) return '';
+  return match[0].replace(/^#{1,4}\s+\S.*\n/, '').trim();
+}
+
+function extractLearnings(content) {
+  const section = extractSection(content, 'Session 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 extractLastCheckpoint(content) {
+  const section = extractSection(content, 'last_checkpoint');
+  if (section) return section.replace(/^.*:\s*/, '').trim();
+  const fmMatch = content.match(/^---[\s\S]*?last_checkpoint:\s*(.+)/m);
+  return fmMatch ? fmMatch[1].trim().replace(/^["']|["']$/g, '') : 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 = ?'
+  ).get(title, 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 };
+}
+
+function syncPlanPhases(db, featureSlug, phaseGates) {
+  if (!phaseGates || typeof phaseGates !== 'object') return 0;
+  const plan = db.prepare(
+    "SELECT plan_id FROM implementation_plans WHERE feature_slug = ? AND status != 'archived' ORDER BY created_at DESC LIMIT 1"
+  ).get(featureSlug);
+  if (!plan) return 0;
+
+  let updated = 0;
+  const gateMap = { plan: 1, requirements: 2, design: 3 };
+  for (const [gate, status] of Object.entries(phaseGates)) {
+    const phaseNum = gateMap[gate];
+    if (!phaseNum) continue;
+    const phase = db.prepare(
+      'SELECT phase_number, status FROM plan_phases WHERE plan_id = ? AND phase_number = ?'
+    ).get(plan.plan_id, phaseNum);
+    if (!phase) continue;
+
+    const newStatus = status === 'approved' ? 'completed' : (status === 'pending' ? 'pending' : phase.status);
+    if (newStatus !== phase.status) {
+      db.prepare(
+        'UPDATE plan_phases SET status = ?, completed_at = ? WHERE plan_id = ? AND phase_number = ?'
+      ).run(newStatus, newStatus === 'completed' ? nowIso() : null, plan.plan_id, phaseNum);
+      updated++;
+    }
+  }
+  return updated;
+}
+
+async function syncSpecFile(db, specPath, { verbose = false } = {}) {
+  let content;
+  try {
+    content = await fs.readFile(specPath, 'utf8');
+  } catch {
+    return { skipped: true, reason: 'not_found' };
+  }
+
+  const filename = path.basename(specPath, '.md');
+  const featureSlug = filename.startsWith('spec-') ? filename.slice(5) : null;
+  const fm = parseFrontmatter(content);
+  const phaseGates = fm.phase_gates ? JSON.parse(fm.phase_gates.replace(/'/g, '"')).catch?.() || null : null;
+
+  const learnings = extractLearnings(content);
+  const lastCheckpoint = extractLastCheckpoint(content);
+
+  let learningsSynced = 0;
+  for (const { type, title } of learnings) {
+    upsertProjectLearning(db, { title, type, featureSlug, sourceSession: filename });
+    learningsSynced++;
+  }
+
+  let phasesSynced = 0;
+  if (featureSlug && fm.phase_gates) {
+    try {
+      const gates = JSON.parse(fm.phase_gates.replace(/'/g, '"'));
+      phasesSynced = syncPlanPhases(db, featureSlug, gates);
+    } catch { /* malformed phase_gates — skip */ }
+  }
+
+  return { featureSlug, learningsSynced, phasesSynced, lastCheckpoint };
+}
+
+async function runSpecSync({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const contextDir = path.join(targetDir, '.aioson', 'context');
+
+  let files;
+  try {
+    const entries = await fs.readdir(contextDir);
+    files = entries.filter((f) => f.startsWith('spec') && f.endsWith('.md'));
+  } catch {
+    if (!options.json) logger.log('No .aioson/context/ directory found.');
+    return { ok: false, reason: 'no_context_dir' };
+  }
+
+  const { db, dbPath } = await openRuntimeDb(targetDir);
+  const results = [];
+
+  try {
+    for (const file of files) {
+      const result = await syncSpecFile(db, path.join(contextDir, file), { verbose: options.verbose });
+      if (!result.skipped) {
+        results.push({ file, ...result });
+      }
+    }
+  } finally {
+    db.close();
+  }
+
+  const totalLearnings = results.reduce((s, r) => s + (r.learningsSynced || 0), 0);
+  const totalPhases = results.reduce((s, r) => s + (r.phasesSynced || 0), 0);
+
+  if (options.json) {
+    return { ok: true, files: results, totalLearnings, totalPhases, dbPath };
+  }
+
+  logger.log(`Spec Sync — ${targetDir}`);
+  logger.log('─'.repeat(50));
+  for (const r of results) {
+    logger.log(`${r.file}`);
+    if (r.learningsSynced > 0) logger.log(`  Learnings synced: ${r.learningsSynced}`);
+    if (r.phasesSynced > 0) logger.log(`  Plan phases updated: ${r.phasesSynced}`);
+    if (r.lastCheckpoint) logger.log(`  last_checkpoint: "${r.lastCheckpoint}"`);
+  }
+  logger.log('─'.repeat(50));
+  logger.log(`Summary: ${totalLearnings} learnings synced, ${totalPhases} plan phases updated`);
+
+  return { ok: true, files: results, totalLearnings, totalPhases, dbPath };
+}
+
+module.exports = { runSpecSync };

package/src/commands/spec-tasks.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  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;
+  }
+  return result;
+}
+
+function extractBulletValue(text, label) {
+  // Matches "**Label:**" or "- **Label:**" patterns (case-insensitive)
+  const re = new RegExp(`\\*\\*${label}[:\\s][*]*\\*\\*:?\\s*(.+)`, 'i');
+  const match = text.match(re);
+  if (match) return match[1].trim();
+  // Fallback: plain "Label:" without bold
+  const re2 = new RegExp(`^[-*]?\\s*${label}[:\\s]+(.+)`, 'im');
+  const m2 = text.match(re2);
+  return m2 ? m2[1].trim() : null;
+}
+
+function parsePhases(content) {
+  // Match phase headers: ### Fase N — title or ## Phase N — title
+  const phasePattern = /^#{2,4}\s+(Fase|Phase)\s+(\d+)\s*[—\-–]\s*(.+)$/im;
+  const phases = [];
+
+  // Split by phase headers
+  const lines = content.split(/\r?\n/);
+  let currentPhase = null;
+  let currentLines = [];
+
+  for (const line of lines) {
+    const m = line.match(/^(#{2,4})\s+(Fase|Phase)\s+(\d+)\s*[—\-–]\s*(.+)$/i);
+    if (m) {
+      if (currentPhase) {
+        currentPhase.body = currentLines.join('\n');
+        phases.push(currentPhase);
+      }
+      currentPhase = {
+        number: parseInt(m[3], 10),
+        title: m[4].trim(),
+        body: ''
+      };
+      currentLines = [];
+    } else if (currentPhase) {
+      currentLines.push(line);
+    }
+  }
+  if (currentPhase) {
+    currentPhase.body = currentLines.join('\n');
+    phases.push(currentPhase);
+  }
+
+  return phases.map((phase) => {
+    const what = extractBulletValue(phase.body, 'O que') ||
+                 extractBulletValue(phase.body, 'What');
+    const dependsOn = extractBulletValue(phase.body, 'Depende de') ||
+                      extractBulletValue(phase.body, 'Depends on');
+    const inputs = extractBulletValue(phase.body, 'Artefatos de entrada') ||
+                   extractBulletValue(phase.body, 'Input artifacts') ||
+                   extractBulletValue(phase.body, 'Inputs');
+    const done = extractBulletValue(phase.body, 'Critério de done') ||
+                 extractBulletValue(phase.body, 'Done criterion') ||
+                 extractBulletValue(phase.body, 'Done criteria') ||
+                 extractBulletValue(phase.body, 'Criterio de done');
+    const checkpoint = extractBulletValue(phase.body, 'Checkpoint');
+    const parallel = /parallel:\s*true/i.test(phase.body);
+
+    return {
+      number: phase.number,
+      title: phase.title,
+      what,
+      dependsOn,
+      inputs,
+      done,
+      checkpoint,
+      parallel
+    };
+  });
+}
+
+function extractParallelNotes(content) {
+  // Find "Fases paralelas" or "Parallel" section
+  const re = /^#{1,4}\s+(Fases paralelas|Parallel phases?)[^\n]*\n([\s\S]*?)(?=^#{1,4}|\s*$)/im;
+  const m = content.match(re);
+  if (!m) return [];
+  return m[2]
+    .split(/\r?\n/)
+    .map((l) => l.replace(/^[-*]\s*/, '').trim())
+    .filter(Boolean);
+}
+
+function extractOpenAssumptions(content) {
+  const re = /^#{1,4}\s+(Decisões adiadas|Deferred decisions|Open assumptions)[^\n]*\n([\s\S]*?)(?=^#{1,4}|\s*$)/im;
+  const m = content.match(re);
+  if (!m) return [];
+  return m[2]
+    .split(/\r?\n/)
+    .map((l) => l.replace(/^[-*]\s*/, '').trim())
+    .filter(Boolean)
+    .slice(0, 5); // cap to avoid bloat
+}
+
+function buildTasksDoc({ title, slug, planPath, phases, parallelNotes, openAssumptions, generatedAt }) {
+  const lines = [];
+  const header = title || (slug ? `tasks-${slug}` : 'tasks');
+
+  lines.push(`# Tasks — ${header}`);
+  lines.push('');
+  lines.push(`> Generated from: \`${path.basename(planPath)}\``);
+  lines.push(`> Generated at: ${generatedAt}`);
+  lines.push(`> Do not edit manually — regenerate from the plan when phases change.`);
+  lines.push('');
+
+  for (const phase of phases) {
+    lines.push(`## Phase ${phase.number} — ${phase.title}`);
+    lines.push('');
+
+    if (phase.inputs) {
+      lines.push(`- [ ] Read input artifacts: ${phase.inputs}`);
+    } else {
+      lines.push(`- [ ] Read required input artifacts`);
+    }
+
+    if (phase.what) {
+      lines.push(`- [ ] Execute: ${phase.what}`);
+    } else {
+      lines.push(`- [ ] Execute planned work`);
+    }
+
+    if (phase.done) {
+      lines.push(`- [ ] Verify done criterion: ${phase.done}`);
+    } else {
+      lines.push(`- [ ] Verify done criterion`);
+    }
+
+    if (phase.checkpoint) {
+      lines.push(`- [ ] Pass checkpoint gate: ${phase.checkpoint}`);
+    } else {
+      lines.push(`- [ ] Pass checkpoint gate`);
+    }
+
+    if (phase.dependsOn && phase.dependsOn !== 'nada' && phase.dependsOn !== 'nothing' && phase.dependsOn !== 'none') {
+      lines.push('');
+      lines.push(`> Depends on: ${phase.dependsOn}`);
+    }
+
+    if (phase.parallel) {
+      lines.push(`> Can run in parallel (no shared entities with adjacent phases)`);
+    }
+
+    lines.push('');
+  }
+
+  if (parallelNotes.length > 0) {
+    lines.push('## Parallel notes');
+    lines.push('');
+    for (const note of parallelNotes) {
+      lines.push(`- ${note}`);
+    }
+    lines.push('');
+  }
+
+  if (openAssumptions.length > 0) {
+    lines.push('## Deferred decisions');
+    lines.push('');
+    for (const item of openAssumptions) {
+      lines.push(`- ${item}`);
+    }
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+async function runSpecTasks({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const contextDir = path.join(targetDir, '.aioson', 'context');
+
+  // Resolve plan path
+  let planPath;
+  if (options.plan) {
+    // If absolute path or starts with ./ — use as-is relative to cwd
+    planPath = path.resolve(process.cwd(), options.plan);
+  } else {
+    // Default: look for implementation-plan.md in context dir
+    planPath = path.join(contextDir, 'implementation-plan.md');
+  }
+
+  let planContent;
+  try {
+    planContent = await fs.readFile(planPath, 'utf8');
+  } catch {
+    if (!options.json) {
+      logger.log(`Error: plan file not found: ${planPath}`);
+      logger.log('Usage: aioson spec:tasks . --plan=.aioson/context/implementation-plan-{slug}.md');
+    }
+    return { ok: false, reason: 'plan_not_found', planPath };
+  }
+
+  const fm = parseFrontmatter(planContent);
+  const featureSlug = fm.feature_slug && fm.feature_slug !== 'null' ? fm.feature_slug : null;
+  const planTitle = fm.project || null;
+
+  const phases = parsePhases(planContent);
+
+  if (phases.length === 0) {
+    if (!options.json) {
+      logger.log('Warning: no phases found in plan. Check that phases follow the format:');
+      logger.log('  ### Fase N — title');
+    }
+    return { ok: false, reason: 'no_phases', planPath };
+  }
+
+  const parallelNotes = extractParallelNotes(planContent);
+  const openAssumptions = extractOpenAssumptions(planContent);
+  const generatedAt = nowIso();
+
+  const tasksContent = buildTasksDoc({
+    title: planTitle,
+    slug: featureSlug,
+    planPath,
+    phases,
+    parallelNotes,
+    openAssumptions,
+    generatedAt
+  });
+
+  // Determine output path
+  const outputFilename = featureSlug ? `tasks-${featureSlug}.md` : 'tasks.md';
+  const outputPath = path.join(contextDir, outputFilename);
+
+  // Ensure context dir exists
+  try {
+    await fs.mkdir(contextDir, { recursive: true });
+  } catch { /* already exists */ }
+
+  await fs.writeFile(outputPath, tasksContent, 'utf8');
+
+  if (options.json) {
+    return {
+      ok: true,
+      planPath,
+      outputPath,
+      featureSlug,
+      phasesCount: phases.length,
+      generatedAt
+    };
+  }
+
+  logger.log(`spec:tasks — ${path.basename(planPath)}`);
+  logger.log('─'.repeat(50));
+  logger.log(`Phases parsed: ${phases.length}`);
+  for (const p of phases) {
+    const parallelLabel = p.parallel ? ' [parallel]' : '';
+    logger.log(`  Phase ${p.number}: ${p.title}${parallelLabel}`);
+  }
+  if (parallelNotes.length > 0) logger.log(`Parallel notes: ${parallelNotes.length}`);
+  if (openAssumptions.length > 0) logger.log(`Deferred decisions: ${openAssumptions.length}`);
+  logger.log('─'.repeat(50));
+  logger.log(`Output: ${outputPath}`);
+  logger.log('');
+  logger.log(`Next: open ${outputFilename} and start executing phase by phase with @dev or @deyvin`);
+
+  return {
+    ok: true,
+    planPath,
+    outputPath,
+    featureSlug,
+    phasesCount: phases.length,
+    generatedAt
+  };
+}
+
+module.exports = { runSpecTasks };