@jaimevalasek/aioson 1.6.0 → 1.7.0

package/src/commands/workflow-execute.js

@@ -0,0 +1,241 @@
+'use strict';
+
+/**
+ * aioson workflow:execute — orchestrate the full agent workflow for a feature.
+ *
+ * Uses agent:prompt, gate:check, pulse:update, feature:close as building blocks.
+ * Always supports --dry-run to preview the plan without executing.
+ *
+ * Usage:
+ *   aioson workflow:execute . --feature=checkout --tool=claude --dry-run
+ *   aioson workflow:execute . --feature=checkout --tool=claude
+ *   aioson workflow:execute . --feature=checkout --tool=claude --start-from=dev
+ *   aioson workflow:execute . --feature=checkout --json --dry-run
+ */
+
+const path = require('node:path');
+const { execSync } = require('node:child_process');
+const {
+  detectClassification,
+  scanArtifacts,
+  readPhaseGates
+} = require('../preflight-engine');
+
+const BAR = '━'.repeat(45);
+
+const WORKFLOW_BY_CLASSIFICATION = {
+  MICRO: [
+    { agent: 'dev', gate_before: null, gate_after: null, description: 'Direct implementation' }
+  ],
+  SMALL: [
+    { agent: 'product', gate_before: null, gate_after: null, description: 'Generate PRD' },
+    { agent: 'sheldon', gate_before: null, gate_after: null, description: 'Enrich PRD (recommended)', optional: true },
+    { agent: 'analyst', gate_before: null, gate_after: 'A', description: 'Map requirements + spec' },
+    { agent: 'dev', gate_before: 'A', gate_after: 'C', description: 'Implementation' },
+    { agent: 'qa', gate_before: 'C', gate_after: 'D', description: 'QA + feature closure' }
+  ],
+  MEDIUM: [
+    { agent: 'product', gate_before: null, gate_after: null, description: 'Generate PRD' },
+    { agent: 'sheldon', gate_before: null, gate_after: null, description: 'Enrich PRD (required)', optional: false },
+    { agent: 'analyst', gate_before: null, gate_after: 'A', description: 'Map requirements + spec' },
+    { agent: 'architect', gate_before: 'A', gate_after: 'B', description: 'Architecture design' },
+    { agent: 'ux-ui', gate_before: 'A', gate_after: 'B', description: 'UI/UX design', optional: true },
+    { agent: 'pm', gate_before: 'B', gate_after: null, description: 'Backlog + PM plan' },
+    { agent: 'dev', gate_before: 'C', gate_after: 'C', description: 'Implementation' },
+    { agent: 'qa', gate_before: 'C', gate_after: 'D', description: 'QA + feature closure' }
+  ]
+};
+
+const GATE_NAMES = { A: 'requirements', B: 'design', C: 'plan', D: 'execution' };
+
+async function buildExecutionPlan(targetDir, slug, classification, startFrom) {
+  const steps = WORKFLOW_BY_CLASSIFICATION[classification] || WORKFLOW_BY_CLASSIFICATION.SMALL;
+  const artifacts = await scanArtifacts(targetDir, slug);
+  const gates = await readPhaseGates(targetDir, slug);
+
+  const plan = [];
+  let stepNum = 1;
+  let startFromReached = !startFrom;
+
+  for (const step of steps) {
+    if (startFrom && !startFromReached) {
+      if (step.agent === startFrom) startFromReached = true;
+      else continue;
+    }
+
+    // Determine if step can be skipped (artifact already exists)
+    let skip = false;
+    let skipReason = null;
+
+    if (step.agent === 'product' && artifacts.prd.exists) {
+      skip = true; skipReason = 'prd already exists';
+    } else if (step.agent === 'sheldon' && artifacts.sheldon_enrichment.exists) {
+      skip = true; skipReason = 'sheldon enrichment already exists';
+    } else if (step.agent === 'analyst' && artifacts.requirements.exists && gates.requirements === 'approved') {
+      skip = true; skipReason = 'requirements + Gate A already approved';
+    } else if (step.agent === 'architect' && artifacts.architecture.exists && gates.design === 'approved') {
+      skip = true; skipReason = 'architecture + Gate B already approved';
+    }
+
+    plan.push({
+      step: stepNum++,
+      agent: step.agent,
+      description: step.description,
+      gate_before: step.gate_before,
+      gate_after: step.gate_after,
+      optional: step.optional || false,
+      skip,
+      skip_reason: skipReason
+    });
+  }
+
+  return plan;
+}
+
+function runCommand(cmd) {
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+async function runWorkflowExecute({ args, options = {}, logger }) {
+  const targetDir = path.resolve(process.cwd(), args[0] || '.');
+  const slug = options.feature ? String(options.feature) : null;
+  const tool = options.tool ? String(options.tool) : 'claude';
+  const dryRun = Boolean(options['dry-run'] || options.dry);
+  const startFrom = options['start-from'] ? String(options['start-from']) : null;
+  const skipOptional = Boolean(options['skip-optional']);
+
+  if (!slug) {
+    if (options.json) return { ok: false, reason: 'missing_feature' };
+    logger.log('--feature=<slug> is required.');
+    return { ok: false };
+  }
+
+  let classification = await detectClassification(targetDir, slug);
+  if (!classification) classification = options.classification ? String(options.classification).toUpperCase() : 'SMALL';
+
+  const plan = await buildExecutionPlan(targetDir, slug, classification, startFrom);
+  const activePlan = plan.filter((s) => !s.skip && !(skipOptional && s.optional));
+  const skippedPlan = plan.filter((s) => s.skip);
+
+  if (dryRun || options.json) {
+    const result = {
+      ok: true,
+      feature: slug,
+      classification,
+      tool,
+      dry_run: true,
+      steps: plan,
+      active_steps: activePlan.length,
+      skipped_steps: skippedPlan.length
+    };
+
+    if (options.json) return result;
+
+    logger.log('');
+    logger.log(`Workflow Execution Plan — ${slug} (${classification})`);
+    logger.log(BAR);
+
+    for (const step of plan) {
+      const icon = step.skip ? '○ (skip)' : `Step ${step.step}:`;
+      const optional = step.optional ? ' (optional)' : '';
+      const gateInfo = step.gate_after ? ` → Gate ${step.gate_after} check` : '';
+      const skipInfo = step.skip ? ` — ${step.skip_reason}` : '';
+      logger.log(`${icon} @${step.agent}${optional} — ${step.description}${gateInfo}${skipInfo}`);
+    }
+
+    logger.log('');
+    logger.log(`Gates enforced: ${plan.filter((s) => s.gate_after && !s.skip).map((s) => s.gate_after).join(', ') || 'none'}`);
+    logger.log(`Active sessions: ${activePlan.length} | Skipped: ${skippedPlan.length}`);
+    logger.log('');
+    logger.log('Run without --dry-run to execute.');
+    logger.log('');
+
+    return result;
+  }
+
+  // Execute
+  logger.log('');
+  logger.log(`Workflow Execution — ${slug} (${classification})`);
+  logger.log(BAR);
+
+  let completed = 0;
+  let failed = 0;
+  const executionLog = [];
+
+  for (const step of plan) {
+    if (step.skip) {
+      logger.log(`[skip] @${step.agent} — ${step.skip_reason}`);
+      executionLog.push({ step: step.step, agent: step.agent, status: 'skipped', reason: step.skip_reason });
+      continue;
+    }
+
+    if (skipOptional && step.optional) {
+      logger.log(`[skip] @${step.agent} — optional, skipped`);
+      executionLog.push({ step: step.step, agent: step.agent, status: 'skipped', reason: 'optional' });
+      continue;
+    }
+
+    // Gate check before
+    if (step.gate_before) {
+      logger.log(`[Gate ${step.gate_before} check] pre-step ${step.step}...`);
+      const gateCmd = `aioson gate:check ${targetDir} --feature=${slug} --gate=${step.gate_before}`;
+      const gateResult = runCommand(gateCmd);
+      if (!gateResult.ok) {
+        logger.log(`[Gate ${step.gate_before}] BLOCKED — cannot proceed with @${step.agent}`);
+        executionLog.push({ step: step.step, agent: step.agent, status: 'blocked', gate: step.gate_before });
+        failed++;
+        break;
+      }
+    }
+
+    logger.log(`[Step ${step.step}/${activePlan.length}] @${step.agent} — ${step.description}...`);
+    const agentCmd = `aioson agent:prompt ${targetDir} --agent=${step.agent} --feature=${slug} --tool=${tool}`;
+    const agentResult = runCommand(agentCmd);
+
+    if (!agentResult.ok) {
+      logger.log(`[Step ${step.step}] @${step.agent} FAILED`);
+      executionLog.push({ step: step.step, agent: step.agent, status: 'failed' });
+      failed++;
+      break;
+    }
+
+    // Gate check after
+    if (step.gate_after) {
+      logger.log(`[Gate ${step.gate_after} check] post-step ${step.step}...`);
+    }
+
+    // Pulse update
+    const pulseCmd = `aioson pulse:update ${targetDir} --agent=${step.agent} --feature=${slug} --action="${step.description}" 2>/dev/null || true`;
+    runCommand(pulseCmd);
+
+    executionLog.push({ step: step.step, agent: step.agent, status: 'completed' });
+    completed++;
+    logger.log(`[Step ${step.step}] @${step.agent} ✓`);
+  }
+
+  const allDone = completed === activePlan.length;
+  if (allDone) {
+    logger.log('');
+    logger.log(`Workflow complete: ${slug} → done`);
+    logger.log(`Total sessions: ${completed}`);
+  } else {
+    logger.log('');
+    logger.log(`Workflow stopped: ${completed} completed, ${failed} failed.`);
+  }
+
+  return {
+    ok: allDone,
+    feature: slug,
+    classification,
+    completed,
+    failed,
+    execution_log: executionLog
+  };
+}
+
+module.exports = { runWorkflowExecute };

package/src/constants.js

@@ -34,6 +34,7 @@ const MANAGED_FILES = [
   '.aioson/agents/orache.md',
   '.aioson/agents/genome.md',
   '.aioson/agents/design-hybrid-forge.md',
+  '.aioson/agents/site-forge.md',
   '.aioson/agents/profiler-researcher.md',
   '.aioson/agents/profiler-enricher.md',
   '.aioson/agents/profiler-forge.md',
@@ -358,6 +359,14 @@ const AGENT_DEFINITIONS = [
     dependsOn: ['.aioson/context/project.context.md'],
     output: '.aioson/installed-skills/{hybrid-slug}/SKILL.md + .aioson/installed-skills/{hybrid-slug}/references/ + .aioson/installed-skills/{hybrid-slug}/previews/ + .aioson/installed-skills/{hybrid-slug}/.skill-meta.json'
   },
+  {
+    id: 'site-forge',
+    displayName: 'Site Forge',
+    command: '@site-forge',
+    path: '.aioson/agents/site-forge.md',
+    dependsOn: ['.aioson/context/project.context.md'],
+    output: 'src/components/*.tsx + src/app/page.tsx + docs/research/{hostname}/ + public/images/{hostname}/'
+  },
   {
     id: 'profiler-researcher',
     displayName: 'Profiler Researcher',

package/src/install-profile.js

@@ -20,7 +20,7 @@ const TOOL_FILES = {
 
 // Squad agent/task/skill paths (non-locale)
 const SQUAD_PATHS = [
-  /^\.aioson\/agents\/(squad|orache|genome|profiler-researcher|profiler-enricher|profiler-forge|design-hybrid-forge)\.md$/,
+  /^\.aioson\/agents\/(squad|orache|genome|profiler-researcher|profiler-enricher|profiler-forge)\.md$/,
   /^\.aioson\/tasks\/squad-/,
   /^\.aioson\/skills\/squad\//,
   /^\.aioson\/templates\/squads\//,
@@ -28,7 +28,7 @@ const SQUAD_PATHS = [
 ];
 
 // Squad agents inside locale dirs — filtered by BOTH locale AND squad
-const SQUAD_LOCALE_AGENT_RE = /^\.aioson\/locales\/([^/]+)\/agents\/(squad|orache|genome|profiler-researcher|profiler-enricher|profiler-forge|design-hybrid-forge)\.md$/;
+const SQUAD_LOCALE_AGENT_RE = /^\.aioson\/locales\/([^/]+)\/agents\/(squad|orache|genome|profiler-researcher|profiler-enricher|profiler-forge)\.md$/;
 
 // Design skill IDs disponíveis
 const DESIGN_IDS = [

package/src/install-wizard.js

@@ -118,7 +118,7 @@ function renderScreen1(cursor, selected, warn, stdout) {
   stdout.write('\n');
 }
 
-function renderScreen2(cursor, selected, stdout) {
+function renderScreen2(cursor, selected, warn, stdout) {
   header(2, 4, stdout);
   stdout.write('  What will you do with AIOSON?\n');
   stdout.write('  (space to select, enter to continue)\n\n');
@@ -130,6 +130,7 @@ function renderScreen2(cursor, selected, stdout) {
     stdout.write(`  ${pointer} [${check}] ${use.label}${lock}\n`);
     stdout.write(`         ${use.desc}\n`);
   }
+  if (warn) stdout.write('\n  ⚠  Select at least one use to continue.\n');
   stdout.write('\n');
 }
 
@@ -413,7 +414,7 @@ async function runInstallWizard(options = {}, io = {}) {
     items: USES,
     defaultSelected: defaultUses,
     lockFirst: true,
-    render: (cursor, selected, _warn, out) => renderScreen2(cursor, selected, out),
+    render: (cursor, selected, warn, out) => renderScreen2(cursor, selected, warn, out),
     io
   });
   if (!uses) { finalCleanup(); return null; }

package/src/installer.js

@@ -186,6 +186,7 @@ async function installTemplate(targetDir, options = {}) {
     backupOnOverwrite = mode === 'update',
     frameworkDetection = null,
     installProfile = null,
+    selectiveUpdate = false,
     onProgress = null
   } = options;
 
@@ -219,6 +220,11 @@ async function installTemplate(targetDir, options = {}) {
       continue;
     }
 
+    if (!destExists && selectiveUpdate) {
+      skipped.push({ path: rel, reason: 'not-installed' });
+      continue;
+    }
+
     if (destExists && !overwrite && mode !== 'update') {
       skipped.push({ path: rel, reason: 'already-exists' });
       continue;

package/src/lib/health-check.js

@@ -0,0 +1,158 @@
+'use strict';
+
+/**
+ * Ambient Intelligence Health Check — Phase 5.3
+ *
+ * Aggregates state from multiple SQLite tables and file-system checks
+ * to produce a list of items awaiting attention.
+ *
+ * Used by:
+ *   - live:start   → shows alert at session start
+ *   - daemon:start → triggers automatic actions in the background loop
+ */
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const { openRuntimeDb } = require('../runtime-store');
+
+const MIN_LEARNINGS_FOR_EVOLVE = 5;
+const MIN_LEARNING_FREQUENCY = 2;
+const SQUAD_INACTIVE_DAYS = 30;
+const TOOL_UNUSED_DAYS = 60;
+const EVENT_STALE_HOURS = 24;
+
+/**
+ * Run all health checks and return a list of items.
+ *
+ * @param {string} projectDir
+ * @returns {Promise<{ items: HealthItem[], ok: boolean }>}
+ */
+async function runHealthCheck(projectDir) {
+  const handle = await openRuntimeDb(projectDir, { mustExist: true });
+  if (!handle) return { items: [], ok: true };
+  const { db } = handle;
+
+  const items = [];
+
+  try {
+    // ── Check 1: Learnings ready for evolve ────────────────────────────────
+    try {
+      const learnings = db.prepare(`
+        SELECT squad_slug, COUNT(*) as count
+        FROM squad_learnings
+        WHERE status = 'active' AND frequency >= ?
+        GROUP BY squad_slug
+        HAVING count >= ?
+      `).all(MIN_LEARNING_FREQUENCY, MIN_LEARNINGS_FOR_EVOLVE);
+
+      for (const row of learnings) {
+        items.push({
+          type: 'learnings_ready',
+          priority: 'high',
+          squad: row.squad_slug,
+          count: row.count,
+          message: `${row.count} learnings prontos para evoluir (squad: ${row.squad_slug})`,
+          action: `aioson learning:evolve . --squad=${row.squad_slug} --auto-apply`
+        });
+      }
+    } catch { /* table might not exist yet */ }
+
+    // ── Check 2: Inactive squads ───────────────────────────────────────────
+    try {
+      const inactive = db.prepare(`
+        SELECT squad_slug, updated_at
+        FROM squads
+        WHERE status = 'active'
+          AND updated_at < datetime('now', '-${SQUAD_INACTIVE_DAYS} days')
+      `).all();
+
+      for (const row of inactive) {
+        const daysSince = Math.round((Date.now() - new Date(row.updated_at).getTime()) / 86400000);
+        items.push({
+          type: 'squad_inactive',
+          priority: 'low',
+          squad: row.squad_slug,
+          days: daysSince,
+          message: `Squad "${row.squad_slug}" inativo há ${daysSince} dias`,
+          action: null
+        });
+      }
+    } catch { /* ok */ }
+
+    // ── Check 3: Stale inter-squad events ─────────────────────────────────
+    try {
+      const stale = db.prepare(`
+        SELECT id, from_squad, event, created_at
+        FROM inter_squad_events
+        WHERE datetime(created_at, '+${EVENT_STALE_HOURS} hours') < datetime('now')
+          AND consumed_by = '[]'
+      `).all();
+
+      if (stale.length > 0) {
+        items.push({
+          type: 'stale_events',
+          priority: 'medium',
+          count: stale.length,
+          message: `${stale.length} evento(s) inter-squad pendentes há mais de ${EVENT_STALE_HOURS}h sem consumidor`,
+          action: null
+        });
+      }
+    } catch { /* ok */ }
+
+    // ── Check 4: Dynamic tools unused for a long time ─────────────────────
+    try {
+      const unusedTools = db.prepare(`
+        SELECT t.name, t.squad_slug, t.registered_at
+        FROM dynamic_squad_tools t
+        WHERE t.registered_at < datetime('now', '-${TOOL_UNUSED_DAYS} days')
+      `).all();
+
+      if (unusedTools.length > 0) {
+        items.push({
+          type: 'unused_tools',
+          priority: 'low',
+          count: unusedTools.length,
+          message: `${unusedTools.length} tool(s) dinâmico(s) sem uso há mais de ${TOOL_UNUSED_DAYS} dias`,
+          action: `aioson squad:tool:register . --list --squad=<slug>`
+        });
+      }
+    } catch { /* ok */ }
+  } finally {
+    db.close();
+  }
+
+  return { items, ok: true };
+}
+
+/**
+ * Format health items for display in terminal (live:start alert).
+ *
+ * @param {HealthItem[]} items
+ * @returns {string|null} Formatted alert string, or null if nothing to report
+ */
+function formatHealthAlert(items) {
+  if (items.length === 0) return null;
+
+  const high = items.filter((i) => i.priority === 'high');
+  const medium = items.filter((i) => i.priority === 'medium');
+  const low = items.filter((i) => i.priority === 'low');
+
+  const lines = [
+    `AIOSON — ${items.length} item(s) aguardam atenção:`
+  ];
+
+  for (const item of high) {
+    lines.push(`  ● ${item.message}`);
+    if (item.action) lines.push(`    → ${item.action}`);
+  }
+  for (const item of medium) {
+    lines.push(`  ◐ ${item.message}`);
+  }
+  for (const item of low) {
+    lines.push(`  ○ ${item.message}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { runHealthCheck, formatHealthAlert };

package/src/lib/hook-protocol.js

@@ -0,0 +1,76 @@
+'use strict';
+
+/**
+ * Hook Exit Code Protocol
+ *
+ * Standardized exit codes for AIOSON hook scripts:
+ *   HOOK_ALLOW (0): Allow the operation — continue normally
+ *   HOOK_DENY  (2): Deny the operation — abort with error message from stderr
+ *   Any other:      Warn — log stderr, continue (non-fatal)
+ *
+ * Used by squad:autorun to run `hooks.pre_run` scripts declared in squad manifests.
+ * Allows squads to gate their own execution based on inter-squad state.
+ *
+ * Example manifest:
+ *   "hooks": {
+ *     "pre_run": "sh .aioson/squads/distribution-team/hooks/check-content-ready.sh"
+ *   }
+ *
+ * Example hook script (exits 2 to deny):
+ *   #!/bin/sh
+ *   STATUS=$(aioson squad:status . --squad=content-team --json | jq -r '.status')
+ *   [ "$STATUS" = "active" ] && exit 0
+ *   echo "content-team not ready (status: $STATUS)" >&2
+ *   exit 2
+ */
+
+const { spawnSync } = require('node:child_process');
+
+const HOOK_ALLOW = 0;
+const HOOK_DENY = 2;
+
+/**
+ * Run a hook script and interpret its exit code.
+ *
+ * @param {string} script   Shell command to execute (via `sh -c`)
+ * @param {object} context  Key-value pairs passed as uppercase env vars to the script
+ * @param {object} opts     Options: { timeoutMs }
+ *
+ * @returns {{ allowed: boolean, denied: boolean, exitCode: number, stdout: string, stderr: string, warn?: boolean }}
+ */
+function runHook(script, context = {}, opts = {}) {
+  const timeoutMs = opts.timeoutMs || 10_000;
+
+  const env = {
+    ...process.env,
+    ...Object.fromEntries(
+      Object.entries(context).map(([k, v]) => [
+        'AIOSON_' + k.toUpperCase().replace(/[^A-Z0-9]/g, '_'),
+        String(v)
+      ])
+    )
+  };
+
+  const result = spawnSync('sh', ['-c', script], {
+    env,
+    timeout: timeoutMs,
+    encoding: 'utf8',
+    stdio: 'pipe'
+  });
+
+  const exitCode = result.status ?? 1;
+  const stdout = (result.stdout || '').trim();
+  const stderr = (result.stderr || '').trim();
+
+  if (exitCode === HOOK_DENY) {
+    return { allowed: false, denied: true, exitCode, stdout, stderr };
+  }
+
+  if (exitCode !== HOOK_ALLOW) {
+    return { allowed: true, denied: false, exitCode, stdout, stderr, warn: true };
+  }
+
+  return { allowed: true, denied: false, exitCode, stdout, stderr };
+}
+
+module.exports = { HOOK_ALLOW, HOOK_DENY, runHook };