@jaimevalasek/aioson 1.5.1 → 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

@@ -33,6 +33,8 @@ const MANAGED_FILES = [
   '.aioson/agents/squad.md',
   '.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',
@@ -349,6 +351,22 @@ const AGENT_DEFINITIONS = [
     dependsOn: [],
     output: '.aioson/genomes/[slug].md + .aioson/genomes/[slug].meta.json + optional binding in .aioson/squads/{slug}/squad.md or .aioson/squads/{slug}/squad.manifest.json'
   },
+  {
+    id: 'design-hybrid-forge',
+    displayName: 'Design Hybrid Forge',
+    command: '@design-hybrid-forge',
+    path: '.aioson/agents/design-hybrid-forge.md',
+    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/context-cache.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const CACHE_DIR = path.join(os.homedir(), '.aioson', 'temp');
+const MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24h
+const META_FILE = 'sessions.json';
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function generateSessionId() {
+  return crypto.randomBytes(8).toString('hex');
+}
+
+async function ensureDir(dir) {
+  await fs.mkdir(dir, { recursive: true });
+}
+
+async function readMeta(cacheDir) {
+  const p = path.join(cacheDir, META_FILE);
+  try {
+    return JSON.parse(await fs.readFile(p, 'utf8'));
+  } catch {
+    return { sessions: {} };
+  }
+}
+
+async function writeMeta(cacheDir, meta) {
+  const p = path.join(cacheDir, META_FILE);
+  await ensureDir(cacheDir);
+  await fs.writeFile(p, JSON.stringify(meta, null, 2), 'utf8');
+}
+
+/**
+ * Save a context snapshot to the RAM cache (shadow file in ~/.aioson/temp/).
+ * @param {string} content — context content to save
+ * @param {object} metadata — { goal?, agent?, projectDir? }
+ * @param {object} opts — { cacheDir?, sessionId? }
+ * @returns {{ ok: boolean, sessionId: string, path: string }}
+ */
+async function saveContextShadow(content, metadata = {}, opts = {}) {
+  const cacheDir = opts.cacheDir || CACHE_DIR;
+  const sessionId = opts.sessionId || generateSessionId();
+  const sessionDir = path.join(cacheDir, sessionId);
+
+  await ensureDir(sessionDir);
+
+  const contentPath = path.join(sessionDir, 'context.md');
+  await fs.writeFile(contentPath, content, 'utf8');
+
+  const entry = {
+    sessionId,
+    path: contentPath,
+    createdAt: nowIso(),
+    metadata: {
+      goal: metadata.goal || '',
+      agent: metadata.agent || '',
+      projectDir: metadata.projectDir || ''
+    },
+    size: content.length
+  };
+
+  const meta = await readMeta(cacheDir);
+  meta.sessions[sessionId] = entry;
+  await writeMeta(cacheDir, meta);
+
+  return { ok: true, sessionId, path: contentPath };
+}
+
+/**
+ * List all cached sessions, newest first.
+ * @param {object} opts — { cacheDir? }
+ * @returns {Array<session_entry>}
+ */
+async function listSessions(opts = {}) {
+  const cacheDir = opts.cacheDir || CACHE_DIR;
+  const meta = await readMeta(cacheDir);
+  const sessions = Object.values(meta.sessions || {});
+  sessions.sort((a, b) => {
+    return new Date(b.createdAt) - new Date(a.createdAt);
+  });
+  return sessions;
+}
+
+/**
+ * Restore a cached context by sessionId.
+ * @param {string} sessionId
+ * @param {object} opts — { cacheDir?, query? }
+ * @returns {{ ok: boolean, content: string, metadata: object }|null}
+ */
+async function restoreContext(sessionId, opts = {}) {
+  const cacheDir = opts.cacheDir || CACHE_DIR;
+  const meta = await readMeta(cacheDir);
+  const entry = meta.sessions[sessionId];
+
+  if (!entry) {
+    return { ok: false, error: 'session_not_found' };
+  }
+
+  let content;
+  try {
+    content = await fs.readFile(entry.path, 'utf8');
+  } catch {
+    return { ok: false, error: 'file_not_found', sessionId };
+  }
+
+  // If query is provided, extract relevant excerpt
+  if (opts.query) {
+    const lines = content.split('\n');
+    const qLower = opts.query.toLowerCase();
+    const relevant = lines.filter(l => l.toLowerCase().includes(qLower));
+    if (relevant.length > 0) {
+      content = relevant.join('\n');
+    }
+  }
+
+  return { ok: true, sessionId, content, metadata: entry.metadata };
+}
+
+/**
+ * Remove sessions older than maxAge ms.
+ * @param {object} opts — { cacheDir?, maxAge? }
+ * @returns {{ removed: number }}
+ */
+async function cleanup(opts = {}) {
+  const cacheDir = opts.cacheDir || CACHE_DIR;
+  const maxAge = opts.maxAge !== undefined ? opts.maxAge : MAX_AGE_MS;
+  const cutoff = Date.now() - maxAge + 1;
+
+  const meta = await readMeta(cacheDir);
+  const sessions = meta.sessions || {};
+  let removed = 0;
+
+  for (const [id, entry] of Object.entries(sessions)) {
+    const createdMs = new Date(entry.createdAt).getTime();
+    if (createdMs < cutoff) {
+      // Remove session dir
+      try {
+        await fs.rm(path.join(cacheDir, id), { recursive: true, force: true });
+      } catch {
+        // best-effort
+      }
+      delete sessions[id];
+      removed++;
+    }
+  }
+
+  meta.sessions = sessions;
+  await writeMeta(cacheDir, meta);
+
+  return { removed };
+}
+
+module.exports = { saveContextShadow, listSessions, restoreContext, cleanup };