mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/accessibility-audit.js

@@ -10,110 +10,108 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const AUDIT_SCHEMA = {
-    type: 'object',
-    properties: {
-      principle: { type: 'string' },
-      issues: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            wcagCriterion: { type: 'string' },
-            level: { type: 'string', enum: ['A', 'AA', 'AAA'] },
-            severity: { type: 'string', enum: ['blocker', 'critical', 'major', 'minor'] },
-            component: { type: 'string' },
-            description: { type: 'string' },
-            fix: { type: 'string' },
-          },
-          required: ['wcagCriterion', 'level', 'severity', 'description', 'fix'],
+const AUDIT_SCHEMA = {
+  type: 'object',
+  properties: {
+    principle: { type: 'string' },
+    issues: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          wcagCriterion: { type: 'string' },
+          level: { type: 'string', enum: ['A', 'AA', 'AAA'] },
+          severity: { type: 'string', enum: ['blocker', 'critical', 'major', 'minor'] },
+          component: { type: 'string' },
+          description: { type: 'string' },
+          fix: { type: 'string' },
         },
+        required: ['wcagCriterion', 'level', 'severity', 'description', 'fix'],
       },
     },
-    required: ['principle', 'issues'],
-  };
+  },
+  required: ['principle', 'issues'],
+};
 
-  const VERDICT_SCHEMA = {
-    type: 'object',
-    properties: {
-      isRealIssue: { type: 'boolean' },
-      affectsRealUsers: { type: 'boolean' },
-      reason: { type: 'string' },
-    },
-    required: ['isRealIssue', 'affectsRealUsers', 'reason'],
-  };
+const VERDICT_SCHEMA = {
+  type: 'object',
+  properties: {
+    isRealIssue: { type: 'boolean' },
+    affectsRealUsers: { type: 'boolean' },
+    reason: { type: 'string' },
+  },
+  required: ['isRealIssue', 'affectsRealUsers', 'reason'],
+};
 
-  const REMEDIATION_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      wcagLevel: { type: 'string', enum: ['Level A non-compliant', 'Level AA non-compliant', 'Level AA compliant', 'Level AAA compliant'] },
-      criticalFixes: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            issue: { type: 'string' },
-            wcagRef: { type: 'string' },
-            fix: { type: 'string' },
-            codeExample: { type: 'string' },
-          },
-          required: ['issue', 'wcagRef', 'fix', 'codeExample'],
+const REMEDIATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    wcagLevel: { type: 'string', enum: ['Level A non-compliant', 'Level AA non-compliant', 'Level AA compliant', 'Level AAA compliant'] },
+    criticalFixes: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          issue: { type: 'string' },
+          wcagRef: { type: 'string' },
+          fix: { type: 'string' },
+          codeExample: { type: 'string' },
         },
+        required: ['issue', 'wcagRef', 'fix', 'codeExample'],
       },
     },
-    required: ['summary', 'wcagLevel', 'criticalFixes'],
-  };
+  },
+  required: ['summary', 'wcagLevel', 'criticalFixes'],
+};
 
-  const target = args || 'current UI codebase (run from repo root)';
+const target = args || 'current UI codebase (run from repo root)';
 
-  phase('Scope');
-  log(`Accessibility audit target: ${target}`);
+phase('Scope');
+log(`Accessibility audit target: ${target}`);
 
-  const AUDITORS = [
-    { label: 'perceivable', prompt: `Audit WCAG 2.2 Perceivable criteria for: "${target}". Check: 1.1.1 Non-text content (alt text), 1.2.x captions/transcripts, 1.3.x info/structure (semantic HTML, labels), 1.4.x distinguishable (contrast ratio ≥4.5:1, resize text, no reliance on color alone). List every failure with WCAG criterion, level (A/AA/AAA), severity, and exact fix.` },
-    { label: 'operable', prompt: `Audit WCAG 2.2 Operable criteria for: "${target}". Check: 2.1.x keyboard accessible (all functionality via keyboard, no traps), 2.2.x enough time (no time limits, pause/stop/hide), 2.3.x seizures (no flashing ≥3Hz), 2.4.x navigable (skip links, page titles, focus order, link purpose), 2.5.x input modalities (touch target ≥24×24px). List every failure with criterion, level, and fix.` },
-    { label: 'understandable', prompt: `Audit WCAG 2.2 Understandable criteria for: "${target}". Check: 3.1.x readable (lang attribute, unusual words), 3.2.x predictable (no context changes on focus, consistent navigation), 3.3.x input assistance (error identification, labels/instructions, error suggestion, error prevention). List every failure with criterion, level, and fix.` },
-    { label: 'robust', prompt: `Audit WCAG 2.2 Robust criteria for: "${target}". Check: 4.1.2 Name/Role/Value (all UI components have accessible name, role, state/value), 4.1.3 Status messages (announced to AT without focus). Also check for valid, parseable HTML. List every failure with criterion, level, and fix.` },
-    { label: 'aria', prompt: `Audit ARIA usage for: "${target}". Check: roles match actual element behavior, required aria-* properties present, aria-labelledby/describedby IDs exist, no aria-hidden on interactive elements, no redundant role+element, proper live region usage. List every failure with fix showing correct ARIA attributes.` },
-    { label: 'keyboard', prompt: `Audit keyboard navigation for: "${target}". Check: tab order is logical, visible focus indicator present (not just outline:none), modals trap focus and release on close, custom widgets (accordions, tabs, dropdowns, sliders) follow ARIA authoring practices keyboard patterns, no keyboard traps. List every failure with fix.` },
-  ];
+const AUDITORS = [
+  { label: 'perceivable', prompt: `Audit WCAG 2.2 Perceivable criteria for: "${target}". Check: 1.1.1 Non-text content (alt text), 1.2.x captions/transcripts, 1.3.x info/structure (semantic HTML, labels), 1.4.x distinguishable (contrast ratio ≥4.5:1, resize text, no reliance on color alone). List every failure with WCAG criterion, level (A/AA/AAA), severity, and exact fix.` },
+  { label: 'operable', prompt: `Audit WCAG 2.2 Operable criteria for: "${target}". Check: 2.1.x keyboard accessible (all functionality via keyboard, no traps), 2.2.x enough time (no time limits, pause/stop/hide), 2.3.x seizures (no flashing ≥3Hz), 2.4.x navigable (skip links, page titles, focus order, link purpose), 2.5.x input modalities (touch target ≥24×24px). List every failure with criterion, level, and fix.` },
+  { label: 'understandable', prompt: `Audit WCAG 2.2 Understandable criteria for: "${target}". Check: 3.1.x readable (lang attribute, unusual words), 3.2.x predictable (no context changes on focus, consistent navigation), 3.3.x input assistance (error identification, labels/instructions, error suggestion, error prevention). List every failure with criterion, level, and fix.` },
+  { label: 'robust', prompt: `Audit WCAG 2.2 Robust criteria for: "${target}". Check: 4.1.2 Name/Role/Value (all UI components have accessible name, role, state/value), 4.1.3 Status messages (announced to AT without focus). Also check for valid, parseable HTML. List every failure with criterion, level, and fix.` },
+  { label: 'aria', prompt: `Audit ARIA usage for: "${target}". Check: roles match actual element behavior, required aria-* properties present, aria-labelledby/describedby IDs exist, no aria-hidden on interactive elements, no redundant role+element, proper live region usage. List every failure with fix showing correct ARIA attributes.` },
+  { label: 'keyboard', prompt: `Audit keyboard navigation for: "${target}". Check: tab order is logical, visible focus indicator present (not just outline:none), modals trap focus and release on close, custom widgets (accordions, tabs, dropdowns, sliders) follow ARIA authoring practices keyboard patterns, no keyboard traps. List every failure with fix.` },
+];
 
-  phase('Audit');
-  const audits = await parallel(
-    AUDITORS.map(a => () => agent(a.prompt, { schema: AUDIT_SCHEMA, label: `audit:${a.label}`, phase: 'Audit' }))
-  );
+phase('Audit');
+const audits = await parallel(
+  AUDITORS.map(a => () => agent(a.prompt, { schema: AUDIT_SCHEMA, label: `audit:${a.label}`, phase: 'Audit' }))
+);
 
-  phase('Verify');
-  const allIssues = audits.filter(Boolean).flatMap(a => (a.issues || []).map(i => ({ ...i, principle: a.principle })));
-  const levelAandAA = allIssues.filter(i => i.level === 'A' || i.level === 'AA');
-  log(`${allIssues.length} total issues, ${levelAandAA.length} Level A/AA → 3-vote verify`);
+phase('Verify');
+const allIssues = audits.filter(Boolean).flatMap(a => (a.issues || []).map(i => ({ ...i, principle: a.principle })));
+const levelAandAA = allIssues.filter(i => i.level === 'A' || i.level === 'AA');
+log(`${allIssues.length} total issues, ${levelAandAA.length} Level A/AA → 3-vote verify`);
 
-  const verified = await parallel(
-    levelAandAA.map(issue => () =>
-      parallel([
-        () => agent(`Is this WCAG ${issue.level} accessibility issue real, or a false positive? Try to REFUTE it. Issue: "${issue.description}" (${issue.wcagCriterion}). Default isRealIssue=false only if clearly not applicable.`, { schema: VERDICT_SCHEMA, label: `v1:${issue.wcagCriterion}`, phase: 'Verify' }),
-        () => agent(`Would a real assistive technology user (screen reader, keyboard-only, low-vision) actually encounter this issue? Issue: "${issue.description}" (${issue.wcagCriterion}). Be specific about which user group is affected.`, { schema: VERDICT_SCHEMA, label: `v2:${issue.wcagCriterion}`, phase: 'Verify' }),
-        () => agent(`Is the WCAG criterion reference accurate for this issue? "${issue.description}" cited as ${issue.wcagCriterion} Level ${issue.level}. Confirm or correct the WCAG reference.`, { schema: VERDICT_SCHEMA, label: `v3:${issue.wcagCriterion}`, phase: 'Verify' }),
-      ]).then(votes => {
-        if (!votes) return { ...issue, confirmed: false };
-        const confirmed = votes.filter(Boolean).filter(v => v.isRealIssue).length;
-        return { ...issue, confirmed: confirmed >= 2 };
-      })
-    )
-  );
+const verified = await parallel(
+  levelAandAA.map(issue => () =>
+    parallel([
+      () => agent(`Is this WCAG ${issue.level} accessibility issue real, or a false positive? Try to REFUTE it. Issue: "${issue.description}" (${issue.wcagCriterion}). Default isRealIssue=false only if clearly not applicable.`, { schema: VERDICT_SCHEMA, label: `v1:${issue.wcagCriterion}`, phase: 'Verify' }),
+      () => agent(`Would a real assistive technology user (screen reader, keyboard-only, low-vision) actually encounter this issue? Issue: "${issue.description}" (${issue.wcagCriterion}). Be specific about which user group is affected.`, { schema: VERDICT_SCHEMA, label: `v2:${issue.wcagCriterion}`, phase: 'Verify' }),
+      () => agent(`Is the WCAG criterion reference accurate for this issue? "${issue.description}" cited as ${issue.wcagCriterion} Level ${issue.level}. Confirm or correct the WCAG reference.`, { schema: VERDICT_SCHEMA, label: `v3:${issue.wcagCriterion}`, phase: 'Verify' }),
+    ]).then(votes => {
+      if (!votes) return { ...issue, confirmed: false };
+      const confirmed = votes.filter(Boolean).filter(v => v.isRealIssue).length;
+      return { ...issue, confirmed: confirmed >= 2 };
+    })
+  )
+);
 
-  const confirmedIssues = verified.filter(Boolean).filter(i => i.confirmed);
-  log(`${confirmedIssues.length}/${levelAandAA.length} Level A/AA issues confirmed`);
+const confirmedIssues = verified.filter(Boolean).filter(i => i.confirmed);
+log(`${confirmedIssues.length}/${levelAandAA.length} Level A/AA issues confirmed`);
 
-  phase('Spec');
-  const issueSummary = confirmedIssues.slice(0, 15).map(i => `[${i.level}/${i.severity}] ${i.wcagCriterion}: ${i.description} → Fix: ${i.fix}`).join('\n');
-  const remediation = await agent(
-    `Create an accessibility remediation spec for: "${target}"\n\nConfirmed WCAG issues:\n${issueSummary}\n\nFor each critical/blocker issue provide: WCAG reference, exact fix description, and a code example (HTML/ARIA/CSS) showing the corrected implementation. Determine the overall WCAG compliance level.`,
-    { schema: REMEDIATION_SCHEMA, label: 'remediation-spec' }
-  );
-  if (!remediation) { return { target, confirmedIssues, error: 'remediation-agent-null', stats: { total: allIssues.length, levelAAFailures: levelAandAA.length, confirmed: confirmedIssues.length } }; }
+phase('Spec');
+const issueSummary = confirmedIssues.slice(0, 15).map(i => `[${i.level}/${i.severity}] ${i.wcagCriterion}: ${i.description} → Fix: ${i.fix}`).join('\n');
+const remediation = await agent(
+  `Create an accessibility remediation spec for: "${target}"\n\nConfirmed WCAG issues:\n${issueSummary}\n\nFor each critical/blocker issue provide: WCAG reference, exact fix description, and a code example (HTML/ARIA/CSS) showing the corrected implementation. Determine the overall WCAG compliance level.`,
+  { schema: REMEDIATION_SCHEMA, label: 'remediation-spec' }
+);
+if (!remediation) { return { target, confirmedIssues, error: 'remediation-agent-null', stats: { total: allIssues.length, levelAAFailures: levelAandAA.length, confirmed: confirmedIssues.length } }; }
 
-  return { target, audits: audits.filter(Boolean), confirmedIssues, remediation, stats: { total: allIssues.length, levelAAFailures: levelAandAA.length, confirmed: confirmedIssues.length } };
-}
+return { target, audits: audits.filter(Boolean), confirmedIssues, remediation, stats: { total: allIssues.length, levelAAFailures: levelAandAA.length, confirmed: confirmedIssues.length } };

package/.mindforge/dynamic-workflows/scripts/ai-model-eval.js

@@ -10,73 +10,71 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const CRITERIA_SCHEMA = {
-    type: 'object',
-    properties: {
-      useCase: { type: 'string' },
-      testPrompts: { type: 'array', items: { type: 'string' } },
-      priorities: { type: 'array', items: { type: 'string' } },
-      modelsToEvaluate: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['useCase', 'testPrompts', 'priorities', 'modelsToEvaluate'],
-  };
+const CRITERIA_SCHEMA = {
+  type: 'object',
+  properties: {
+    useCase: { type: 'string' },
+    testPrompts: { type: 'array', items: { type: 'string' } },
+    priorities: { type: 'array', items: { type: 'string' } },
+    modelsToEvaluate: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['useCase', 'testPrompts', 'priorities', 'modelsToEvaluate'],
+};
 
-  const EVAL_SCHEMA = {
-    type: 'object',
-    properties: {
-      dimension: { type: 'string' },
-      scores: { type: 'array', items: { type: 'object', properties: { model: { type: 'string' }, score: { type: 'number' }, notes: { type: 'string' } }, required: ['model', 'score'] } },
-    },
-    required: ['dimension', 'scores'],
-  };
+const EVAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    dimension: { type: 'string' },
+    scores: { type: 'array', items: { type: 'object', properties: { model: { type: 'string' }, score: { type: 'number' }, notes: { type: 'string' } }, required: ['model', 'score'] } },
+  },
+  required: ['dimension', 'scores'],
+};
 
-  const RECOMMENDATION_SCHEMA = {
-    type: 'object',
-    properties: {
-      winner: { type: 'string' },
-      rationale: { type: 'string' },
-      ranking: { type: 'array', items: { type: 'object', properties: { model: { type: 'string' }, totalScore: { type: 'number' }, bestFor: { type: 'string' } }, required: ['model', 'totalScore', 'bestFor'] } },
-      costNote: { type: 'string' },
-    },
-    required: ['winner', 'rationale', 'ranking'],
-  };
+const RECOMMENDATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    winner: { type: 'string' },
+    rationale: { type: 'string' },
+    ranking: { type: 'array', items: { type: 'object', properties: { model: { type: 'string' }, totalScore: { type: 'number' }, bestFor: { type: 'string' } }, required: ['model', 'totalScore', 'bestFor'] } },
+    costNote: { type: 'string' },
+  },
+  required: ['winner', 'rationale', 'ranking'],
+};
 
-  const useCase = args || 'general purpose AI assistant for coding tasks';
+const useCase = args || 'general purpose AI assistant for coding tasks';
 
-  phase('Scope');
-  const criteria = await agent(`Define evaluation criteria and test prompts for this AI model use case: "${useCase}". Create 3-5 representative test prompts that reflect the actual workload. List evaluation priorities (quality/speed/cost/context-length/reasoning) in order of importance. Suggest which models to evaluate (e.g., claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5, gpt-4o, gemini-2.0-flash).`, { schema: CRITERIA_SCHEMA, label: 'scope' });
-  if (!criteria) { return { useCase, error: 'criteria-agent-null' }; }
-  log(`Evaluating ${criteria.modelsToEvaluate.length} models on ${criteria.priorities.length} dimensions`);
+phase('Scope');
+const criteria = await agent(`Define evaluation criteria and test prompts for this AI model use case: "${useCase}". Create 3-5 representative test prompts that reflect the actual workload. List evaluation priorities (quality/speed/cost/context-length/reasoning) in order of importance. Suggest which models to evaluate (e.g., claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5, gpt-4o, gemini-2.0-flash).`, { schema: CRITERIA_SCHEMA, label: 'scope' });
+if (!criteria) { return { useCase, error: 'criteria-agent-null' }; }
+log(`Evaluating ${criteria.modelsToEvaluate.length} models on ${criteria.priorities.length} dimensions`);
 
-  phase('Benchmark');
-  const DIMENSIONS = [
-    { label: 'quality', prompt: `Evaluate OUTPUT QUALITY of these models for: "${useCase}". Test prompts: ${criteria.testPrompts.slice(0, 3).join(' | ')}. Models: ${criteria.modelsToEvaluate.join(', ')}. Score each 0-100 for accuracy, completeness, and usefulness. Base scores on published benchmarks (MMLU, HumanEval, SWE-bench, coding evals) and known model capabilities.` },
-    { label: 'reasoning', prompt: `Evaluate REASONING CAPABILITY of these models for: "${useCase}". Models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 for multi-step reasoning, code understanding, logical deduction. Reference published benchmarks (MATH, BBH, ARC).` },
-    { label: 'speed-latency', prompt: `Evaluate SPEED AND LATENCY of these models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 (100=fastest). Include: typical time-to-first-token, output tokens/second, and whether the model supports streaming. Reference publicly available benchmarks and known provider SLAs.` },
-    { label: 'cost-efficiency', prompt: `Evaluate COST EFFICIENCY of these models for: "${useCase}" with typical usage of ~1000 input tokens and ~500 output tokens per call. Models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 (100=cheapest). Include: price per 1M input/output tokens from official pricing pages, estimated monthly cost at 100K calls/month.` },
-  ];
+phase('Benchmark');
+const DIMENSIONS = [
+  { label: 'quality', prompt: `Evaluate OUTPUT QUALITY of these models for: "${useCase}". Test prompts: ${criteria.testPrompts.slice(0, 3).join(' | ')}. Models: ${criteria.modelsToEvaluate.join(', ')}. Score each 0-100 for accuracy, completeness, and usefulness. Base scores on published benchmarks (MMLU, HumanEval, SWE-bench, coding evals) and known model capabilities.` },
+  { label: 'reasoning', prompt: `Evaluate REASONING CAPABILITY of these models for: "${useCase}". Models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 for multi-step reasoning, code understanding, logical deduction. Reference published benchmarks (MATH, BBH, ARC).` },
+  { label: 'speed-latency', prompt: `Evaluate SPEED AND LATENCY of these models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 (100=fastest). Include: typical time-to-first-token, output tokens/second, and whether the model supports streaming. Reference publicly available benchmarks and known provider SLAs.` },
+  { label: 'cost-efficiency', prompt: `Evaluate COST EFFICIENCY of these models for: "${useCase}" with typical usage of ~1000 input tokens and ~500 output tokens per call. Models: ${criteria.modelsToEvaluate.join(', ')}. Score 0-100 (100=cheapest). Include: price per 1M input/output tokens from official pricing pages, estimated monthly cost at 100K calls/month.` },
+];
 
-  const evals = await parallel(
-    DIMENSIONS.map(d => () => agent(d.prompt, { schema: EVAL_SCHEMA, label: `eval:${d.label}`, phase: 'Benchmark' }))
-  );
+const evals = await parallel(
+  DIMENSIONS.map(d => () => agent(d.prompt, { schema: EVAL_SCHEMA, label: `eval:${d.label}`, phase: 'Benchmark' }))
+);
 
-  phase('Score');
-  const validEvals = evals.filter(Boolean);
-  const modelScores = {};
-  criteria.modelsToEvaluate.forEach(model => {
-    modelScores[model] = validEvals.reduce((sum, e) => {
-      const s = (e.scores || []).find(sc => sc.model === model);
-      return sum + (s ? s.score : 0);
-    }, 0);
-  });
-  const sorted = Object.entries(modelScores).sort((a, b) => b[1] - a[1]);
-  if (sorted.length > 0) log(`Scoring complete — top model: ${sorted[0][0]}`);
+phase('Score');
+const validEvals = evals.filter(Boolean);
+const modelScores = {};
+criteria.modelsToEvaluate.forEach(model => {
+  modelScores[model] = validEvals.reduce((sum, e) => {
+    const s = (e.scores || []).find(sc => sc.model === model);
+    return sum + (s ? s.score : 0);
+  }, 0);
+});
+const sorted = Object.entries(modelScores).sort((a, b) => b[1] - a[1]);
+if (sorted.length > 0) log(`Scoring complete — top model: ${sorted[0][0]}`);
 
-  phase('Recommend');
-  const scoreText = Object.entries(modelScores).sort((a, b) => b[1] - a[1]).map(([m, s]) => `${m}: ${s} total`).join(', ');
-  const recommendation = await agent(`Provide a model recommendation for: "${useCase}"\n\nScores: ${scoreText}\n\nPriorities: ${criteria.priorities.join(' > ')}\n\nRank all models, declare the winner with rationale, note the best model for each specific priority, and include a cost note for the top 2 models.`, { schema: RECOMMENDATION_SCHEMA, label: 'recommend' });
-  if (!recommendation) { return { useCase, criteria, evals: validEvals, modelScores, error: 'recommendation-agent-null' }; }
+phase('Recommend');
+const scoreText = Object.entries(modelScores).sort((a, b) => b[1] - a[1]).map(([m, s]) => `${m}: ${s} total`).join(', ');
+const recommendation = await agent(`Provide a model recommendation for: "${useCase}"\n\nScores: ${scoreText}\n\nPriorities: ${criteria.priorities.join(' > ')}\n\nRank all models, declare the winner with rationale, note the best model for each specific priority, and include a cost note for the top 2 models.`, { schema: RECOMMENDATION_SCHEMA, label: 'recommend' });
+if (!recommendation) { return { useCase, criteria, evals: validEvals, modelScores, error: 'recommendation-agent-null' }; }
 
-  return { useCase, criteria, evals: validEvals, modelScores, recommendation };
-}
+return { useCase, criteria, evals: validEvals, modelScores, recommendation };

package/.mindforge/dynamic-workflows/scripts/api-contract-test.js

@@ -10,105 +10,107 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const SPEC_SCHEMA = {
-    type: 'object',
-    properties: {
-      apiName: { type: 'string' },
-      endpoints: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            method: { type: 'string' },
-            path: { type: 'string' },
-            requestSchema: { type: 'string' },
-            responseSchema: { type: 'string' },
-            authRequired: { type: 'boolean' },
-            errorCodes: { type: 'array', items: { type: 'string' } },
-          },
-          required: ['method', 'path', 'responseSchema'],
+const SPEC_SCHEMA = {
+  type: 'object',
+  properties: {
+    apiName: { type: 'string' },
+    endpoints: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          method: { type: 'string' },
+          path: { type: 'string' },
+          requestSchema: { type: 'string' },
+          responseSchema: { type: 'string' },
+          authRequired: { type: 'boolean' },
+          errorCodes: { type: 'array', items: { type: 'string' } },
         },
+        required: ['method', 'path', 'responseSchema'],
       },
     },
-    required: ['apiName', 'endpoints'],
-  };
+  },
+  required: ['apiName', 'endpoints'],
+};
 
-  const IMPL_SCHEMA = {
-    type: 'object',
-    properties: {
-      implementedEndpoints: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            method: { type: 'string' },
-            path: { type: 'string' },
-            actualRequestHandling: { type: 'string' },
-            actualResponseShape: { type: 'string' },
-            authImplemented: { type: 'boolean' },
-          },
-          required: ['method', 'path', 'actualResponseShape'],
+const IMPL_SCHEMA = {
+  type: 'object',
+  properties: {
+    implementedEndpoints: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          method: { type: 'string' },
+          path: { type: 'string' },
+          actualRequestHandling: { type: 'string' },
+          actualResponseShape: { type: 'string' },
+          authImplemented: { type: 'boolean' },
         },
+        required: ['method', 'path', 'actualResponseShape'],
       },
     },
-    required: ['implementedEndpoints'],
-  };
+  },
+  required: ['implementedEndpoints'],
+};
 
-  const VIOLATION_SCHEMA = {
-    type: 'object',
-    properties: {
-      violations: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            endpoint: { type: 'string' },
-            severity: { type: 'string', enum: ['breaking', 'non-breaking', 'warning'] },
-            type: { type: 'string' },
-            specSays: { type: 'string' },
-            implDoes: { type: 'string' },
-            fix: { type: 'string' },
-          },
-          required: ['endpoint', 'severity', 'type', 'specSays', 'implDoes', 'fix'],
+const VIOLATION_SCHEMA = {
+  type: 'object',
+  properties: {
+    violations: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          endpoint: { type: 'string' },
+          severity: { type: 'string', enum: ['breaking', 'non-breaking', 'warning'] },
+          type: { type: 'string' },
+          specSays: { type: 'string' },
+          implDoes: { type: 'string' },
+          fix: { type: 'string' },
         },
+        required: ['endpoint', 'severity', 'type', 'specSays', 'implDoes', 'fix'],
       },
-      summary: { type: 'string' },
-      breakingCount: { type: 'number' },
-      compatible: { type: 'boolean' },
     },
-    required: ['violations', 'summary', 'breakingCount', 'compatible'],
-  };
+    summary: { type: 'string' },
+    breakingCount: { type: 'number' },
+    compatible: { type: 'boolean' },
+  },
+  required: ['violations', 'summary', 'breakingCount', 'compatible'],
+};
 
-  const target = args || 'current API (provide spec file path and implementation path as args)';
+const target = args || 'current API (provide spec file path and implementation path as args)';
 
-  phase('ReadSpec');
-  log(`Reading API spec from: ${target}`);
-  const spec = await agent(
-    `Read and extract the complete API contract from the spec file(s) in: "${target}". Look for OpenAPI/Swagger YAML, GraphQL schema files, Protobuf files, or API documentation. Extract every endpoint with its method, path, request/response schema, auth requirements, and error codes.`,
-    { schema: SPEC_SCHEMA, label: 'read-spec' }
-  );
-  if (!spec) { log('Warning: agent returned null for spec, skipping'); return { target, error: 'agent-null' }; }
-  log(`Spec: ${spec.apiName} — ${spec.endpoints.length} endpoints`);
+phase('ReadSpec');
+log(`Reading API spec from: ${target}`);
+const spec = await agent(
+  `Read and extract the complete API contract from the spec file(s) in: "${target}". Look for OpenAPI/Swagger YAML, GraphQL schema files, Protobuf files, or API documentation. Extract every endpoint with its method, path, request/response schema, auth requirements, and error codes.`,
+  { schema: SPEC_SCHEMA, label: 'read-spec' }
+);
+if (!spec) { log('Warning: agent returned null for spec, skipping'); return { target, error: 'agent-null' }; }
+log(`Spec: ${spec.apiName} — ${spec.endpoints.length} endpoints`);
 
-  phase('ReadImpl');
-  const impl = await agent(
-    `Read the actual API IMPLEMENTATION in: "${target}". Look for route handlers, controllers, resolvers, or gRPC handlers. For each endpoint extract the actual request handling logic, response shape being returned, and whether auth is checked. Do NOT read the spec — only the implementation code.`,
-    { schema: IMPL_SCHEMA, label: 'read-impl' }
-  );
-  if (!impl) { log('Warning: agent returned null for impl, skipping'); return { target, error: 'agent-null' }; }
-  log(`Implementation: ${impl.implementedEndpoints.length} endpoints found`);
+phase('ReadImpl');
+const impl = await agent(
+  `Read the actual API IMPLEMENTATION in: "${target}". Look for route handlers, controllers, resolvers, or gRPC handlers. For each endpoint extract the actual request handling logic, response shape being returned, and whether auth is checked. Do NOT read the spec — only the implementation code.`,
+  { schema: IMPL_SCHEMA, label: 'read-impl' }
+);
+if (!impl) { log('Warning: agent returned null for impl, skipping'); return { target, error: 'agent-null' }; }
+log(`Implementation: ${impl.implementedEndpoints.length} endpoints found`);
 
-  phase('Diff');
-  const specText = spec.endpoints.map(e => `${e.method} ${e.path}: response=${e.responseSchema}, auth=${e.authRequired}, errors=${(e.errorCodes || []).join(',')}`).join('\n');
-  const implText = impl.implementedEndpoints.map(e => `${e.method} ${e.path}: response=${e.actualResponseShape}, auth=${e.authImplemented}`).join('\n');
+phase('Diff');
+const specText = spec.endpoints.length
+  ? spec.endpoints.map(e => `${e.method} ${e.path}: response=${e.responseSchema}, auth=${e.authRequired}, errors=${(e.errorCodes || []).join(',')}`).join('\n')
+  : `(no endpoints extracted — spec agent's own summary: ${spec.apiName})`;
+const implText = impl.implementedEndpoints.length
+  ? impl.implementedEndpoints.map(e => `${e.method} ${e.path}: response=${e.actualResponseShape}, auth=${e.authImplemented}`).join('\n')
+  : '(no implemented endpoints found)';
 
-  phase('Report');
-  const report = await agent(
-    `Compare the API specification against the implementation and identify contract violations.\n\nSPEC:\n${specText}\n\nIMPLEMENTATION:\n${implText}\n\nFor each violation: classify as breaking (response shape/auth differs) or non-breaking (extra fields, missing optional), state what the spec says vs what the impl does, and provide the exact fix.`,
-    { schema: VIOLATION_SCHEMA, label: 'violations' }
-  );
-  if (!report) { return { target, spec, impl, error: 'report-agent-null' }; }
+phase('Report');
+const report = await agent(
+  `Compare the API specification against the implementation and identify contract violations.\n\nSPEC (apiName: ${spec.apiName}):\n${specText}\n\nIMPLEMENTATION:\n${implText}\n\nIf the target has no real endpoints to compare (e.g. it isn't an API at all — a plain library, a CLI, a single function), say so plainly using the spec agent's own summary above rather than reporting the sections as empty/unsupplied — the spec agent DID analyze the target, it just found no formal endpoint contract. For each real violation: classify as breaking (response shape/auth differs) or non-breaking (extra fields, missing optional), state what the spec says vs what the impl does, and provide the exact fix.`,
+  { schema: VIOLATION_SCHEMA, label: 'violations' }
+);
+if (!report) { return { target, spec, impl, error: 'report-agent-null' }; }
 
-  return { target, spec, impl, report };
-}
+return { target, spec, impl, report };