@jaimevalasek/aioson 1.3.0

package/src/commands/parallel-status.js

@@ -0,0 +1,290 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { exists } = require('../utils');
+const { recordRuntimeOperation } = require('../execution-gateway');
+
+const KNOWN_STATUSES = ['pending', 'in_progress', 'completed', 'blocked'];
+
+function parseLaneIndex(fileName) {
+  const match = String(fileName || '').match(/^agent-(\d+)\.status\.md$/);
+  if (!match) return null;
+  const value = Number(match[1]);
+  if (!Number.isFinite(value) || value <= 0) return null;
+  return Math.floor(value);
+}
+
+function extractMetadata(content, key, fallback = '') {
+  const regex = new RegExp(`^-\\s*${key}:\\s*(.*)$`, 'im');
+  const match = String(content || '').match(regex);
+  if (!match) return fallback;
+  return String(match[1] || '').trim();
+}
+
+function extractSectionLines(content, title) {
+  const lines = String(content || '').split(/\r?\n/);
+  const start = lines.findIndex((line) => line.trim() === `## ${title}`);
+  if (start === -1) return [];
+
+  const output = [];
+  for (let i = start + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line.startsWith('## ')) break;
+    output.push(line);
+  }
+  return output;
+}
+
+function extractSectionBullets(content, title) {
+  const lines = extractSectionLines(content, title);
+  const items = [];
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s+(.*)$/);
+    if (!match) continue;
+    items.push(String(match[1] || '').trim());
+  }
+  return items;
+}
+
+function parseDeliverables(content) {
+  const lines = extractSectionLines(content, 'Deliverables');
+  let total = 0;
+  let completed = 0;
+  for (const line of lines) {
+    const match = line.match(/^\s*-\s+\[([ xX])\]\s+(.+)$/);
+    if (!match) continue;
+    total += 1;
+    if (match[1].toLowerCase() === 'x') completed += 1;
+  }
+  return { completed, total };
+}
+
+function normalizeStatus(value) {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  if (KNOWN_STATUSES.includes(normalized)) return normalized;
+  return normalized || 'other';
+}
+
+function sanitizeScopeItems(items) {
+  return (items || []).filter((item) => {
+    const value = String(item || '').trim().toLowerCase();
+    if (!value) return false;
+    if (value === '[define module or feature boundary]') return false;
+    if (value === '[unassigned]') return false;
+    return true;
+  });
+}
+
+function sanitizeBlockerItems(items) {
+  return (items || []).filter((item) => {
+    const value = String(item || '').trim().toLowerCase();
+    if (!value) return false;
+    if (value === '[none]') return false;
+    return true;
+  });
+}
+
+function countDecisionRows(content) {
+  const lines = String(content || '').split(/\r?\n/);
+  return lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('|')) return false;
+    if (trimmed.includes('| time | decision | rationale | impact |')) return false;
+    if (/^\|\-+\|/.test(trimmed)) return false;
+    return true;
+  }).length;
+}
+
+function createStatusCounts() {
+  return {
+    pending: 0,
+    in_progress: 0,
+    completed: 0,
+    blocked: 0,
+    other: 0
+  };
+}
+
+function formatStatusLabel(status, t) {
+  const normalized = String(status || '')
+    .trim()
+    .toLowerCase();
+  if (normalized === 'pending') return t('parallel_status.status_pending');
+  if (normalized === 'in_progress') return t('parallel_status.status_in_progress');
+  if (normalized === 'completed') return t('parallel_status.status_completed');
+  if (normalized === 'blocked') return t('parallel_status.status_blocked');
+  return t('parallel_status.status_other');
+}
+
+async function parseLaneFile(parallelDir, index) {
+  const fileName = `agent-${index}.status.md`;
+  const absPath = path.join(parallelDir, fileName);
+  const content = await fs.readFile(absPath, 'utf8');
+  const status = normalizeStatus(extractMetadata(content, 'status', 'pending'));
+  const owner = extractMetadata(content, 'owner', '[unassigned]');
+  const priority = extractMetadata(content, 'priority', 'medium');
+  const updatedAt = extractMetadata(content, 'updated_at', '');
+  const scopeItems = sanitizeScopeItems(extractSectionBullets(content, 'Scope'));
+  const blockerItems = sanitizeBlockerItems(extractSectionBullets(content, 'Blockers'));
+  const deliverables = parseDeliverables(content);
+
+  return {
+    lane: index,
+    file: path.join('.aioson/context/parallel', fileName).replace(/\\/g, '/'),
+    status,
+    owner,
+    priority,
+    updatedAt,
+    scopeCount: scopeItems.length,
+    blockerCount: blockerItems.length,
+    deliverables,
+    scopeItems,
+    blockerItems
+  };
+}
+
+async function runParallelStatus({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const parallelDir = path.join(targetDir, '.aioson/context/parallel');
+
+  if (!(await exists(parallelDir))) {
+    throw new Error(t('parallel_status.parallel_missing', { path: parallelDir }));
+  }
+
+  const entries = await fs.readdir(parallelDir);
+  const laneIndices = entries
+    .map(parseLaneIndex)
+    .filter((value) => value !== null)
+    .sort((a, b) => a - b);
+
+  if (laneIndices.length === 0) {
+    throw new Error(t('parallel_status.no_lanes'));
+  }
+
+  const lanes = [];
+  for (const index of laneIndices) {
+    lanes.push(await parseLaneFile(parallelDir, index));
+  }
+
+  const statusCounts = createStatusCounts();
+  let scopeCount = 0;
+  let blockerCount = 0;
+  let deliverablesCompleted = 0;
+  let deliverablesTotal = 0;
+
+  for (const lane of lanes) {
+    const key = Object.prototype.hasOwnProperty.call(statusCounts, lane.status) ? lane.status : 'other';
+    statusCounts[key] += 1;
+    scopeCount += lane.scopeCount;
+    blockerCount += lane.blockerCount;
+    deliverablesCompleted += lane.deliverables.completed;
+    deliverablesTotal += lane.deliverables.total;
+  }
+
+  const sharedPath = path.join(parallelDir, 'shared-decisions.md');
+  const sharedExists = await exists(sharedPath);
+  const sharedDecisionEntries = sharedExists
+    ? countDecisionRows(await fs.readFile(sharedPath, 'utf8'))
+    : 0;
+
+  const output = {
+    ok: true,
+    targetDir,
+    parallelDir,
+    laneCount: lanes.length,
+    statusCounts,
+    scopeCount,
+    blockerCount,
+    deliverables: {
+      completed: deliverablesCompleted,
+      total: deliverablesTotal
+    },
+    sharedDecisions: {
+      exists: sharedExists,
+      entries: sharedDecisionEntries
+    },
+    lanes: lanes.map((lane) => ({
+      lane: lane.lane,
+      file: lane.file,
+      status: lane.status,
+      owner: lane.owner,
+      priority: lane.priority,
+      updatedAt: lane.updatedAt,
+      scopeCount: lane.scopeCount,
+      blockerCount: lane.blockerCount,
+      deliverables: lane.deliverables
+    }))
+  };
+
+  output.runtime = await recordRuntimeOperation(targetDir, {
+    agentName: 'orchestrator',
+    source: 'orchestration',
+    sessionKey: 'parallel:workspace',
+    title: 'Parallel orchestration workspace',
+    goal: 'Prepare and manage parallel development lanes',
+    runTitle: 'parallel:status',
+    message: 'Parallel status inspection started',
+    summary: `Parallel status inspected for ${output.laneCount} lanes`,
+    eventType: 'parallel.status_reported',
+    phase: 'parallel',
+    payload: {
+      command: 'parallel:status',
+      laneCount: output.laneCount,
+      statusCounts,
+      scopeCount,
+      blockerCount,
+      deliverables: output.deliverables,
+      sharedDecisions: output.sharedDecisions
+    }
+  });
+
+  if (options.json) {
+    return output;
+  }
+
+  logger.log(t('parallel_status.title', { path: targetDir }));
+  logger.log(t('parallel_status.lanes_count', { count: output.laneCount }));
+  logger.log(t('parallel_status.statuses_title'));
+  for (const key of Object.keys(statusCounts)) {
+    logger.log(
+      t('parallel_status.status_line', {
+        status: formatStatusLabel(key, t),
+        count: statusCounts[key]
+      })
+    );
+  }
+  logger.log(t('parallel_status.scopes_count', { count: scopeCount }));
+  logger.log(
+    t('parallel_status.deliverables_progress', {
+      completed: deliverablesCompleted,
+      total: deliverablesTotal
+    })
+  );
+  logger.log(t('parallel_status.blockers_count', { count: blockerCount }));
+  logger.log(
+    t('parallel_status.shared_decisions', {
+      count: sharedDecisionEntries
+    })
+  );
+  for (const lane of output.lanes) {
+    logger.log(
+      t('parallel_status.lane_line', {
+        lane: lane.lane,
+        status: formatStatusLabel(lane.status, t),
+        scope: lane.scopeCount,
+        blockers: lane.blockerCount
+      })
+    );
+  }
+
+  return output;
+}
+
+module.exports = {
+  runParallelStatus,
+  parseLaneIndex,
+  countDecisionRows
+};

package/src/commands/qa-doctor.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const path = require('node:path');
+const { readTextIfExists, exists } = require('../utils');
+const { validateProjectContextFile } = require('../context');
+
+function makeCheck(id, ok, severity, message, hint = '') {
+  return { id, ok: Boolean(ok), severity, message: String(message || ''), hint: String(hint || '') };
+}
+
+function summarizeChecks(checks) {
+  const passed = checks.filter((c) => c.ok).length;
+  const failed = checks.filter((c) => !c.ok && c.severity === 'error').length;
+  const warnings = checks.filter((c) => !c.ok && c.severity === 'warn').length;
+  return { total: checks.length, passed, failed, warnings };
+}
+
+function formatPrefix(check, t) {
+  if (check.ok) return t('qa_doctor.prefix_ok');
+  if (check.severity === 'warn') return t('qa_doctor.prefix_warn');
+  return t('qa_doctor.prefix_fail');
+}
+
+function requirePlaywright() {
+  try {
+    return require('playwright');
+  } catch {
+    return null;
+  }
+}
+
+async function checkTargetUrl(url) {
+  if (!url) return { reachable: false, error: 'no_url' };
+  try {
+    const http = url.startsWith('https') ? require('node:https') : require('node:http');
+    await new Promise((resolve, reject) => {
+      const req = http.get(url, { timeout: 5000 }, (res) => {
+        res.destroy();
+        resolve(res.statusCode);
+      });
+      req.on('error', reject);
+      req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+    });
+    return { reachable: true, error: '' };
+  } catch (err) {
+    return { reachable: false, error: err.message };
+  }
+}
+
+function countAcItems(prdContent) {
+  if (!prdContent) return 0;
+  const tableMatches = prdContent.matchAll(/\|\s*(AC-\d+)\s*\|/g);
+  return [...tableMatches].length;
+}
+
+async function runQaDoctor({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const configPath = path.join(targetDir, 'aios-qa.config.json');
+  const prdPath = path.join(targetDir, '.aioson/context/prd.md');
+  const checks = [];
+
+  // Check 1 — Playwright installed
+  const pw = requirePlaywright();
+  checks.push(makeCheck(
+    'playwright.installed',
+    Boolean(pw),
+    'error',
+    pw ? t('qa_doctor.playwright_ok') : t('qa_doctor.playwright_missing'),
+    pw ? '' : t('qa_doctor.playwright_missing_hint')
+  ));
+
+  // Check 2 — Chromium binary
+  if (pw) {
+    let chromiumOk = false;
+    try {
+      const execPath = pw.chromium.executablePath();
+      chromiumOk = Boolean(execPath) && await exists(execPath);
+    } catch {
+      chromiumOk = false;
+    }
+    checks.push(makeCheck(
+      'chromium.binary',
+      chromiumOk,
+      'error',
+      chromiumOk ? t('qa_doctor.chromium_ok') : t('qa_doctor.chromium_missing'),
+      chromiumOk ? '' : t('qa_doctor.chromium_missing_hint')
+    ));
+  }
+
+  // Check 3 — Config file
+  const configExists = await exists(configPath);
+  let config = null;
+  let configParsed = false;
+  let configError = '';
+
+  if (configExists) {
+    try {
+      const raw = await require('node:fs/promises').readFile(configPath, 'utf8');
+      config = JSON.parse(raw);
+      configParsed = true;
+    } catch (err) {
+      configError = err.message;
+    }
+  }
+
+  if (!configExists) {
+    checks.push(makeCheck('config.exists', false, 'error', t('qa_doctor.config_missing'), t('qa_doctor.config_missing_hint')));
+  } else if (!configParsed) {
+    checks.push(makeCheck('config.parsed', false, 'error', t('qa_doctor.config_invalid', { error: configError }), t('qa_doctor.config_missing_hint')));
+  } else {
+    checks.push(makeCheck('config.exists', true, 'info', t('qa_doctor.config_ok')));
+  }
+
+  // Check 4 — Target URL reachable
+  const configUrl = config && config.url ? config.url : '';
+  if (!configUrl) {
+    checks.push(makeCheck('url.reachable', false, 'warn', t('qa_doctor.url_missing'), t('qa_doctor.url_missing_hint')));
+  } else {
+    const { reachable, error } = await checkTargetUrl(configUrl);
+    checks.push(makeCheck(
+      'url.reachable',
+      reachable,
+      'warn',
+      reachable
+        ? t('qa_doctor.url_ok', { url: configUrl })
+        : t('qa_doctor.url_unreachable', { url: configUrl, error }),
+      reachable ? '' : t('qa_doctor.url_unreachable_hint')
+    ));
+  }
+
+  // Check 5 — project.context.md
+  const contextResult = await validateProjectContextFile(targetDir);
+  checks.push(makeCheck(
+    'context.exists',
+    contextResult.exists,
+    'warn',
+    contextResult.exists ? t('qa_doctor.context_ok') : t('qa_doctor.context_missing')
+  ));
+
+  // Check 6 — prd.md (optional enrichment)
+  const prdContent = await readTextIfExists(prdPath);
+  const acCount = countAcItems(prdContent || '');
+  checks.push(makeCheck(
+    'prd.exists',
+    Boolean(prdContent),
+    'warn',
+    prdContent
+      ? t('qa_doctor.prd_ok', { count: acCount })
+      : t('qa_doctor.prd_missing')
+  ));
+
+  const summary = summarizeChecks(checks);
+  const output = {
+    ok: summary.failed === 0,
+    targetDir,
+    configPath,
+    configExists,
+    configParsed,
+    url: configUrl,
+    checks,
+    summary
+  };
+
+  if (options.json) return output;
+
+  logger.log(t('qa_doctor.report_title', { path: targetDir }));
+  for (const check of checks) {
+    logger.log(t('qa_doctor.check_line', {
+      prefix: formatPrefix(check, t),
+      id: check.id,
+      message: check.message
+    }));
+    if (check.hint) logger.log(t('qa_doctor.hint_line', { hint: check.hint }));
+  }
+  logger.log(t('qa_doctor.summary', {
+    passed: summary.passed,
+    failed: summary.failed,
+    warnings: summary.warnings
+  }));
+
+  if (!output.ok) process.exitCode = 1;
+  return output;
+}
+
+module.exports = { runQaDoctor };

package/src/commands/qa-init.js

@@ -0,0 +1,161 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const { readTextIfExists, ensureDir, exists } = require('../utils');
+const { validateProjectContextFile } = require('../context');
+
+const DEFAULT_PERSONAS = ['naive', 'hacker', 'power', 'mobile'];
+
+const DEFAULT_SECURITY_PROBES = [
+  'exposed_env_vars',
+  'xss_inputs',
+  'open_redirect',
+  'sensitive_files',
+  'idor_probe',
+  'console_leaks',
+  'debug_routes',
+  'mixed_content',
+  'sensitive_get_params'
+];
+
+const DEFAULT_PERFORMANCE_THRESHOLDS = {
+  page_load_ms: 3000,
+  ttfb_ms: 800,
+  requests_max: 80,
+  transfer_max_kb: 2048
+};
+
+function extractFrontmatterValue(markdown, key) {
+  if (!markdown) return '';
+  const regex = new RegExp(`^-\\s*${key}:\\s*(.*)$`, 'im');
+  const match = String(markdown).match(regex);
+  return match ? String(match[1] || '').trim() : '';
+}
+
+function extractYamlValue(markdown, key) {
+  if (!markdown) return '';
+  const regex = new RegExp(`^${key}:\\s*(.*)$`, 'im');
+  const match = String(markdown).match(regex);
+  return match ? String(match[1] || '').trim().replace(/^['"]|['"]$/g, '') : '';
+}
+
+function parseAcItems(prdContent) {
+  if (!prdContent) return [];
+  const items = [];
+  // Match table rows: | AC-01 | description |
+  const tableRows = [...String(prdContent).matchAll(/\|\s*(AC-\d+)\s*\|\s*([^|]+)\|/g)];
+  for (const match of tableRows) {
+    items.push({ id: match[1].trim(), description: match[2].trim() });
+  }
+  // Match must-have items in MVP section
+  const mvpMatches = [...String(prdContent).matchAll(/🔴\s*([^\n]+)/g)];
+  for (const match of mvpMatches) {
+    if (items.length >= 20) break;
+    items.push({ id: `AC-${String(items.length + 1).padStart(2, '0')}`, description: match[1].trim() });
+  }
+  return items.slice(0, 20);
+}
+
+function parseBusinessRules(discoveryContent) {
+  if (!discoveryContent) return [];
+  const rules = [];
+  const matches = [...String(discoveryContent).matchAll(/[-*]\s*([A-Z][^\n]{10,80})/g)];
+  for (const match of matches.slice(0, 15)) {
+    rules.push(match[1].trim());
+  }
+  return rules;
+}
+
+async function runQaInit({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const dryRun = Boolean(options['dry-run']);
+  const configPath = path.join(targetDir, 'aios-qa.config.json');
+
+  const contextResult = await validateProjectContextFile(targetDir);
+  const contextMarkdown = await readTextIfExists(path.join(targetDir, '.aioson/context/project.context.md'));
+  const prdContent = await readTextIfExists(path.join(targetDir, '.aioson/context/prd.md'));
+  const discoveryContent = await readTextIfExists(path.join(targetDir, '.aioson/context/discovery.md'));
+
+  const contextData = contextResult.parsed && contextResult.data ? contextResult.data : {};
+
+  // Resolve URL: CLI flag > context app_url > context framework hint > ask
+  let url = String(options.url || '').trim();
+  if (!url && contextMarkdown) {
+    url = extractFrontmatterValue(contextMarkdown, 'app_url') ||
+          extractFrontmatterValue(contextMarkdown, 'dev_url') || '';
+  }
+  if (!url) {
+    url = 'http://localhost:3000';
+  }
+
+  const projectName = String(contextData.project_name || path.basename(targetDir) || 'Project');
+  const language = String(contextData.conversation_language || 'en');
+
+  // Parse prd.md for AC items
+  const acItems = parseAcItems(prdContent);
+  const businessRules = parseBusinessRules(discoveryContent);
+
+  if (contextResult.exists) {
+    logger.log(t('qa_init.context_found', { name: projectName, url }));
+  }
+
+  if (prdContent) {
+    logger.log(t('qa_init.prd_found', { count: acItems.length }));
+  } else {
+    logger.log(t('qa_init.prd_missing'));
+  }
+
+  const config = {
+    project_name: projectName,
+    url,
+    language,
+    personas: DEFAULT_PERSONAS,
+    security_probes: DEFAULT_SECURITY_PROBES,
+    performance_thresholds: DEFAULT_PERFORMANCE_THRESHOLDS,
+    accessibility: true,
+    network_capture: true,
+    screenshot_on_finding: true,
+    scenarios: acItems,
+    business_rules: businessRules,
+    generated_at: new Date().toISOString(),
+    aioson_version: require('../../package.json').version
+  };
+
+  if (!dryRun) {
+    await ensureDir(path.dirname(configPath));
+    await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  }
+
+  const output = {
+    ok: true,
+    targetDir,
+    configPath,
+    dryRun,
+    written: !dryRun,
+    url,
+    projectName,
+    scenariosCount: acItems.length,
+    personasCount: DEFAULT_PERSONAS.length,
+    probesCount: DEFAULT_SECURITY_PROBES.length,
+    config
+  };
+
+  if (options.json) return output;
+
+  logger.log(
+    dryRun
+      ? t('qa_init.dry_run_generated', { path: configPath })
+      : t('qa_init.generated', { path: configPath })
+  );
+  logger.log(t('qa_init.scenarios_count', { count: acItems.length }));
+  logger.log(t('qa_init.personas_count', { count: DEFAULT_PERSONAS.length }));
+  logger.log(t('qa_init.probes_count', { count: DEFAULT_SECURITY_PROBES.length }));
+  logger.log(t('qa_init.next_steps'));
+  logger.log(t('qa_init.step_doctor'));
+  logger.log(t('qa_init.step_run'));
+
+  return output;
+}
+
+module.exports = { runQaInit };

package/src/commands/qa-report.js

@@ -0,0 +1,58 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const { readTextIfExists, exists } = require('../utils');
+
+async function runQaReport({ args, options = {}, logger, t }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const mdPath = path.join(targetDir, 'aios-qa-report.md');
+  const jsonPath = path.join(targetDir, 'aios-qa-report.json');
+
+  if (options.json) {
+    if (!(await exists(jsonPath))) {
+      return { ok: false, error: 'report_not_found', path: jsonPath };
+    }
+    try {
+      const raw = await fs.readFile(jsonPath, 'utf8');
+      return { ok: true, ...JSON.parse(raw) };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+
+  if (options.html) {
+    if (!(await exists(jsonPath))) {
+      logger.error(t('qa_report.not_found'));
+      process.exitCode = 1;
+      return { ok: false, error: 'report_not_found' };
+    }
+    try {
+      const raw = await fs.readFile(jsonPath, 'utf8');
+      const data = JSON.parse(raw);
+      const { writeHtmlReport } = require('../qa-html-report');
+      const screenshotsDir = path.join(targetDir, 'aios-qa-screenshots');
+      const result = await writeHtmlReport(
+        targetDir, data.project || 'Project', data.url || '',
+        data.findings || [], data.ac_coverage || [], data.performance || null,
+        data.mode || 'run', screenshotsDir, { routes: data.routes_scanned }
+      );
+      logger.log(t('qa_report.html_report_written', { path: result.htmlPath }));
+      return { ok: true, htmlPath: result.htmlPath };
+    } catch (err) {
+      return { ok: false, error: err.message };
+    }
+  }
+
+  const content = await readTextIfExists(mdPath);
+  if (!content) {
+    logger.error(t('qa_report.not_found'));
+    process.exitCode = 1;
+    return { ok: false, error: 'report_not_found' };
+  }
+
+  logger.log(content);
+  return { ok: true, path: mdPath };
+}
+
+module.exports = { runQaReport };