mindforge-cc 11.8.2 → 11.9.0

package/.mindforge/dynamic-workflows/scripts/tdd-sprint.js

@@ -10,94 +10,92 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const SPEC_SCHEMA = {
-    type: 'object',
-    properties: {
-      behaviorName: { type: 'string' },
-      given: { type: 'string' },
-      when: { type: 'string' },
-      then: { type: 'string' },
-      acceptanceCriteria: { type: 'array', items: { type: 'string' } },
-      edgeCases: { type: 'array', items: { type: 'string' } },
-      outOfScope: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['behaviorName', 'given', 'when', 'then', 'acceptanceCriteria', 'edgeCases'],
-  };
+const SPEC_SCHEMA = {
+  type: 'object',
+  properties: {
+    behaviorName: { type: 'string' },
+    given: { type: 'string' },
+    when: { type: 'string' },
+    then: { type: 'string' },
+    acceptanceCriteria: { type: 'array', items: { type: 'string' } },
+    edgeCases: { type: 'array', items: { type: 'string' } },
+    outOfScope: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['behaviorName', 'given', 'when', 'then', 'acceptanceCriteria', 'edgeCases'],
+};
 
-  const TEST_SCHEMA = {
-    type: 'object',
-    properties: {
-      testDescription: { type: 'string' },
-      testCode: { type: 'string' },
-      whyItFails: { type: 'string' },
-      fileToCreate: { type: 'string' },
-    },
-    required: ['testDescription', 'testCode', 'whyItFails', 'fileToCreate'],
-  };
+const TEST_SCHEMA = {
+  type: 'object',
+  properties: {
+    testDescription: { type: 'string' },
+    testCode: { type: 'string' },
+    whyItFails: { type: 'string' },
+    fileToCreate: { type: 'string' },
+  },
+  required: ['testDescription', 'testCode', 'whyItFails', 'fileToCreate'],
+};
 
-  const IMPL_SCHEMA = {
-    type: 'object',
-    properties: {
-      approachExplanation: { type: 'string' },
-      implementationCode: { type: 'string' },
-      fileToCreate: { type: 'string' },
-      minimalityRationale: { type: 'string' },
-    },
-    required: ['approachExplanation', 'implementationCode', 'fileToCreate', 'minimalityRationale'],
-  };
+const IMPL_SCHEMA = {
+  type: 'object',
+  properties: {
+    approachExplanation: { type: 'string' },
+    implementationCode: { type: 'string' },
+    fileToCreate: { type: 'string' },
+    minimalityRationale: { type: 'string' },
+  },
+  required: ['approachExplanation', 'implementationCode', 'fileToCreate', 'minimalityRationale'],
+};
 
-  const REFACTOR_SCHEMA = {
-    type: 'object',
-    properties: {
-      improvements: { type: 'array', items: { type: 'string' } },
-      refactoredCode: { type: 'string' },
-      testsStillPass: { type: 'boolean' },
-      explanation: { type: 'string' },
-    },
-    required: ['improvements', 'refactoredCode', 'testsStillPass', 'explanation'],
-  };
+const REFACTOR_SCHEMA = {
+  type: 'object',
+  properties: {
+    improvements: { type: 'array', items: { type: 'string' } },
+    refactoredCode: { type: 'string' },
+    testsStillPass: { type: 'boolean' },
+    explanation: { type: 'string' },
+  },
+  required: ['improvements', 'refactoredCode', 'testsStillPass', 'explanation'],
+};
 
-  const requirement = args || 'No requirement specified — pass your feature/behavior description as args.';
+const requirement = args || 'No requirement specified — pass your feature/behavior description as args.';
 
-  phase('Spec');
-  log(`Requirement: ${requirement.slice(0, 80)}`);
-  const spec = await agent(
-    `Write a precise behavioral specification for: "${requirement}"\n\nUse Given-When-Then format. Be explicit about inputs, outputs, and edge cases. List what is OUT of scope to keep this focused.`,
-    { schema: SPEC_SCHEMA, label: 'spec' }
-  );
-  log(`Spec: ${spec.behaviorName} | ${spec.acceptanceCriteria.length} acceptance criteria, ${spec.edgeCases.length} edge cases`);
+phase('Spec');
+log(`Requirement: ${requirement.slice(0, 80)}`);
+const spec = await agent(
+  `Write a precise behavioral specification for: "${requirement}"\n\nUse Given-When-Then format. Be explicit about inputs, outputs, and edge cases. List what is OUT of scope to keep this focused.`,
+  { schema: SPEC_SCHEMA, label: 'spec' }
+);
+log(`Spec: ${spec.behaviorName} | ${spec.acceptanceCriteria.length} acceptance criteria, ${spec.edgeCases.length} edge cases`);
 
-  phase('Red');
-  const specText = `Given: ${spec.given}\nWhen: ${spec.when}\nThen: ${spec.then}\nCriteria: ${spec.acceptanceCriteria.join(', ')}`;
-  const test = await agent(
-    `Write a FAILING test for this behavior specification:\n${specText}\n\nWrite the minimal test that will fail because the implementation doesn't exist yet. Explain WHY it fails. Use the project's test framework (detect from file extensions or state Jest/Vitest/Node assert).`,
-    { schema: TEST_SCHEMA, label: 'red' }
-  );
-  log(`[RED] Test: "${test.testDescription}" — fails because: ${test.whyItFails}`);
+phase('Red');
+const specText = `Given: ${spec.given}\nWhen: ${spec.when}\nThen: ${spec.then}\nCriteria: ${spec.acceptanceCriteria.join(', ')}`;
+const test = await agent(
+  `Write a FAILING test for this behavior specification:\n${specText}\n\nWrite the minimal test that will fail because the implementation doesn't exist yet. Explain WHY it fails. Use the project's test framework (detect from file extensions or state Jest/Vitest/Node assert).`,
+  { schema: TEST_SCHEMA, label: 'red' }
+);
+log(`[RED] Test: "${test.testDescription}" — fails because: ${test.whyItFails}`);
 
-  phase('Green');
-  const testContext = `Test: ${test.testDescription}\n\nTest code:\n${test.testCode}\n\nFails because: ${test.whyItFails}`;
-  const impl = await agent(
-    `Write the MINIMUM implementation to make this test pass:\n${testContext}\n\nWrite ONLY what is needed to make the test go green. No extra features, no future-proofing. Explain why this is the minimal solution.`,
-    { schema: IMPL_SCHEMA, label: 'green' }
-  );
-  log(`[GREEN] Minimal implementation: ${impl.minimalityRationale}`);
+phase('Green');
+const testContext = `Test: ${test.testDescription}\n\nTest code:\n${test.testCode}\n\nFails because: ${test.whyItFails}`;
+const impl = await agent(
+  `Write the MINIMUM implementation to make this test pass:\n${testContext}\n\nWrite ONLY what is needed to make the test go green. No extra features, no future-proofing. Explain why this is the minimal solution.`,
+  { schema: IMPL_SCHEMA, label: 'green' }
+);
+log(`[GREEN] Minimal implementation: ${impl.minimalityRationale}`);
 
-  phase('Refactor');
-  const greenContext = `Test: ${test.testCode}\nImplementation: ${impl.implementationCode}`;
-  const refactored = await agent(
-    `Refactor this passing implementation for clarity and maintainability, keeping all tests green:\n${greenContext}\n\nList specific improvements made (naming, structure, extraction, simplification). The tests MUST still pass after refactoring.`,
-    { schema: REFACTOR_SCHEMA, label: 'refactor' }
-  );
-  log(`[REFACTOR] ${refactored.improvements.length} improvements, tests still pass: ${refactored.testsStillPass}`);
+phase('Refactor');
+const greenContext = `Test: ${test.testCode}\nImplementation: ${impl.implementationCode}`;
+const refactored = await agent(
+  `Refactor this passing implementation for clarity and maintainability, keeping all tests green:\n${greenContext}\n\nList specific improvements made (naming, structure, extraction, simplification). The tests MUST still pass after refactoring.`,
+  { schema: REFACTOR_SCHEMA, label: 'refactor' }
+);
+log(`[REFACTOR] ${refactored.improvements.length} improvements, tests still pass: ${refactored.testsStillPass}`);
 
-  return {
-    requirement,
-    spec,
-    test,
-    implementation: impl,
-    refactored,
-    cycle: { red: test.testDescription, green: impl.approachExplanation, refactor: refactored.explanation },
-  };
-}
+return {
+  requirement,
+  spec,
+  test,
+  implementation: impl,
+  refactored,
+  cycle: { red: test.testDescription, green: impl.approachExplanation, refactor: refactored.explanation },
+};

package/.mindforge/dynamic-workflows/scripts/tech-evaluation.js

@@ -10,63 +10,61 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const EVAL_SCHEMA = {
-    type: 'object',
-    properties: {
-      dimension: { type: 'string' },
-      score: { type: 'number', minimum: 1, maximum: 10 },
-      rationale: { type: 'string' },
-      pros: { type: 'array', items: { type: 'string' } },
-      cons: { type: 'array', items: { type: 'string' } },
-    },
-    required: ['dimension', 'score', 'rationale', 'pros', 'cons'],
-  };
+const EVAL_SCHEMA = {
+  type: 'object',
+  properties: {
+    dimension: { type: 'string' },
+    score: { type: 'number', minimum: 1, maximum: 10 },
+    rationale: { type: 'string' },
+    pros: { type: 'array', items: { type: 'string' } },
+    cons: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['dimension', 'score', 'rationale', 'pros', 'cons'],
+};
 
-  const RECOMMEND_SCHEMA = {
-    type: 'object',
-    properties: {
-      winner: { type: 'string' },
-      summary: { type: 'string' },
-      ranking: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, totalScore: { type: 'number' }, verdict: { type: 'string' } }, required: ['name', 'totalScore', 'verdict'] } },
-      tradeoffs: { type: 'array', items: { type: 'string' } },
-      recommendation: { type: 'string' },
-    },
-    required: ['winner', 'summary', 'ranking', 'tradeoffs', 'recommendation'],
-  };
+const RECOMMEND_SCHEMA = {
+  type: 'object',
+  properties: {
+    winner: { type: 'string' },
+    summary: { type: 'string' },
+    ranking: { type: 'array', items: { type: 'object', properties: { name: { type: 'string' }, totalScore: { type: 'number' }, verdict: { type: 'string' } }, required: ['name', 'totalScore', 'verdict'] } },
+    tradeoffs: { type: 'array', items: { type: 'string' } },
+    recommendation: { type: 'string' },
+  },
+  required: ['winner', 'summary', 'ranking', 'tradeoffs', 'recommendation'],
+};
 
-  const input = args || 'No candidates specified — pass "TechA vs TechB vs TechC for [use case]" as args.';
+const input = args || 'No candidates specified — pass "TechA vs TechB vs TechC for [use case]" as args.';
 
-  phase('Scope');
-  log(`Evaluating: ${input.slice(0, 80)}`);
+phase('Scope');
+log(`Evaluating: ${input.slice(0, 80)}`);
 
-  const DIMENSIONS = [
-    { label: 'dx', name: 'Developer Experience', prompt: `Evaluate the developer experience of: ${input}. Consider: API ergonomics, documentation quality, error messages, learning curve, tooling, IDE support, type safety, and community examples. Score 1-10.` },
-    { label: 'perf', name: 'Performance', prompt: `Evaluate the runtime performance of: ${input}. Consider: throughput, latency, memory footprint, scalability, benchmarks available, and known bottlenecks. Score 1-10.` },
-    { label: 'security', name: 'Security', prompt: `Evaluate the security posture of: ${input}. Consider: CVE history, security audit results, supply chain risk, default-secure configuration, auth/authz support, and maintenance cadence. Score 1-10.` },
-    { label: 'ecosystem', name: 'Ecosystem', prompt: `Evaluate the ecosystem of: ${input}. Consider: number of integrations, plugin quality, third-party packages, cloud provider support, and lock-in risk. Score 1-10.` },
-    { label: 'community', name: 'Community', prompt: `Evaluate the community health of: ${input}. Consider: GitHub stars, contributor count, issue response time, Discord/Slack activity, recent releases, and long-term viability. Score 1-10.` },
-  ];
+const DIMENSIONS = [
+  { label: 'dx', name: 'Developer Experience', prompt: `Evaluate the developer experience of: ${input}. Consider: API ergonomics, documentation quality, error messages, learning curve, tooling, IDE support, type safety, and community examples. Score 1-10.` },
+  { label: 'perf', name: 'Performance', prompt: `Evaluate the runtime performance of: ${input}. Consider: throughput, latency, memory footprint, scalability, benchmarks available, and known bottlenecks. Score 1-10.` },
+  { label: 'security', name: 'Security', prompt: `Evaluate the security posture of: ${input}. Consider: CVE history, security audit results, supply chain risk, default-secure configuration, auth/authz support, and maintenance cadence. Score 1-10.` },
+  { label: 'ecosystem', name: 'Ecosystem', prompt: `Evaluate the ecosystem of: ${input}. Consider: number of integrations, plugin quality, third-party packages, cloud provider support, and lock-in risk. Score 1-10.` },
+  { label: 'community', name: 'Community', prompt: `Evaluate the community health of: ${input}. Consider: GitHub stars, contributor count, issue response time, Discord/Slack activity, recent releases, and long-term viability. Score 1-10.` },
+];
 
-  phase('Evaluate');
-  const evaluations = await parallel(
-    DIMENSIONS.map(d => () => agent(d.prompt, { schema: EVAL_SCHEMA, label: `eval:${d.label}`, phase: 'Evaluate' }))
-  );
+phase('Evaluate');
+const evaluations = await parallel(
+  DIMENSIONS.map(d => () => agent(d.prompt, { schema: EVAL_SCHEMA, label: `eval:${d.label}`, phase: 'Evaluate' }))
+);
 
-  phase('Score');
-  const validEvals = evaluations.filter(Boolean);
-  const scoreMatrix = validEvals.map(e => `${e.dimension}: ${e.score}/10 — ${e.rationale}`).join('\n');
-  log(`Score matrix built from ${validEvals.length} dimensions`);
+phase('Score');
+const validEvals = evaluations.filter(Boolean);
+const scoreMatrix = validEvals.map(e => `${e.dimension}: ${e.score}/10 — ${e.rationale}`).join('\n');
+log(`Score matrix built from ${validEvals.length} dimensions`);
 
-  phase('Recommend');
-  const recommendation = await agent(
-    `Based on this technology evaluation for "${input}", produce a ranked recommendation:\n\nScores:\n${scoreMatrix}\n\nIdentify the winner, explain the trade-offs, and give a clear recommendation for when to choose each option.`,
-    { schema: RECOMMEND_SCHEMA, label: 'recommend' }
-  );
+phase('Recommend');
+const recommendation = await agent(
+  `Based on this technology evaluation for "${input}", produce a ranked recommendation:\n\nScores:\n${scoreMatrix}\n\nIdentify the winner, explain the trade-offs, and give a clear recommendation for when to choose each option.`,
+  { schema: RECOMMEND_SCHEMA, label: 'recommend' }
+);
 
-  return {
-    input,
-    evaluations: validEvals,
-    recommendation,
-  };
-}
+return {
+  input,
+  evaluations: validEvals,
+  recommendation,
+};

package/.mindforge/dynamic-workflows/scripts/test-coverage-gap.js

@@ -10,86 +10,84 @@ export const meta = {
   ],
 };
 
-export default async function run({ agent, parallel, pipeline, phase, log, args, budget }) {
-  const MODULE_SCHEMA = {
-    type: 'object',
-    properties: {
-      modules: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: { name: { type: 'string' }, path: { type: 'string' }, risk: { type: 'string', enum: ['high', 'medium', 'low'] } },
-          required: ['name', 'path', 'risk'],
-        },
+const MODULE_SCHEMA = {
+  type: 'object',
+  properties: {
+    modules: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: { name: { type: 'string' }, path: { type: 'string' }, risk: { type: 'string', enum: ['high', 'medium', 'low'] } },
+        required: ['name', 'path', 'risk'],
       },
     },
-    required: ['modules'],
-  };
+  },
+  required: ['modules'],
+};
 
-  const COVERAGE_SCHEMA = {
-    type: 'object',
-    properties: {
-      module: { type: 'string' },
-      testedBehaviors: { type: 'array', items: { type: 'string' } },
-      untestedBehaviors: { type: 'array', items: { type: 'string' } },
-      missingEdgeCases: { type: 'array', items: { type: 'string' } },
-      estimatedCoverage: { type: 'number' },
-    },
-    required: ['module', 'testedBehaviors', 'untestedBehaviors', 'missingEdgeCases', 'estimatedCoverage'],
-  };
+const COVERAGE_SCHEMA = {
+  type: 'object',
+  properties: {
+    module: { type: 'string' },
+    testedBehaviors: { type: 'array', items: { type: 'string' } },
+    untestedBehaviors: { type: 'array', items: { type: 'string' } },
+    missingEdgeCases: { type: 'array', items: { type: 'string' } },
+    estimatedCoverage: { type: 'number' },
+  },
+  required: ['module', 'testedBehaviors', 'untestedBehaviors', 'missingEdgeCases', 'estimatedCoverage'],
+};
 
-  const PLAN_SCHEMA = {
-    type: 'object',
-    properties: {
-      summary: { type: 'string' },
-      prioritizedTests: {
-        type: 'array',
-        items: {
-          type: 'object',
-          properties: {
-            module: { type: 'string' },
-            behavior: { type: 'string' },
-            priority: { type: 'string', enum: ['p0', 'p1', 'p2'] },
-            testDescription: { type: 'string' },
-            skeletonCode: { type: 'string' },
-          },
-          required: ['module', 'behavior', 'priority', 'testDescription', 'skeletonCode'],
+const PLAN_SCHEMA = {
+  type: 'object',
+  properties: {
+    summary: { type: 'string' },
+    prioritizedTests: {
+      type: 'array',
+      items: {
+        type: 'object',
+        properties: {
+          module: { type: 'string' },
+          behavior: { type: 'string' },
+          priority: { type: 'string', enum: ['p0', 'p1', 'p2'] },
+          testDescription: { type: 'string' },
+          skeletonCode: { type: 'string' },
         },
+        required: ['module', 'behavior', 'priority', 'testDescription', 'skeletonCode'],
       },
     },
-    required: ['summary', 'prioritizedTests'],
-  };
+  },
+  required: ['summary', 'prioritizedTests'],
+};
 
-  const target = args || 'current codebase (run from repo root)';
+const target = args || 'current codebase (run from repo root)';
 
-  phase('Discover');
-  log(`Discovering testable modules in: ${target}`);
-  const discovery = await agent(
-    `Discover and list all testable modules in: "${target}". For each module identify its path and risk level (high=core business logic/auth/payment, medium=data processing, low=utilities/helpers). Focus on source files that should have tests.`,
-    { schema: MODULE_SCHEMA, label: 'discover' }
-  );
-  const modules = ((discovery || {}).modules || []).slice(0, 12);
-  log(`Found ${modules.length} modules to analyze`);
+phase('Discover');
+log(`Discovering testable modules in: ${target}`);
+const discovery = await agent(
+  `Discover and list all testable modules in: "${target}". For each module identify its path and risk level (high=core business logic/auth/payment, medium=data processing, low=utilities/helpers). Focus on source files that should have tests.`,
+  { schema: MODULE_SCHEMA, label: 'discover' }
+);
+const modules = ((discovery || {}).modules || []).slice(0, 12);
+log(`Found ${modules.length} modules to analyze`);
 
-  phase('Analyze');
-  const coverageResults = await parallel(
-    modules.map(m => () => agent(
-      `Analyze test coverage for module: "${m.name}" at path: "${m.path}" in codebase: "${target}". List: (1) behaviors currently tested, (2) behaviors NOT tested that should be, (3) missing edge cases. Estimate current coverage % (0-100).`,
-      { schema: COVERAGE_SCHEMA, label: `cov:${m.name.slice(0, 20)}`, phase: 'Analyze' }
-    ))
-  );
+phase('Analyze');
+const coverageResults = await parallel(
+  modules.map(m => () => agent(
+    `Analyze test coverage for module: "${m.name}" at path: "${m.path}" in codebase: "${target}". List: (1) behaviors currently tested, (2) behaviors NOT tested that should be, (3) missing edge cases. Estimate current coverage % (0-100).`,
+    { schema: COVERAGE_SCHEMA, label: `cov:${m.name.slice(0, 20)}`, phase: 'Analyze' }
+  ))
+);
 
-  phase('GapMap');
-  const gaps = coverageResults.filter(Boolean);
-  const gapSummary = gaps.map(g => `${g.module} (~${g.estimatedCoverage}% covered): untested=[${g.untestedBehaviors.slice(0, 3).join(', ')}]`).join('\n');
-  log(`Coverage gaps identified across ${gaps.length} modules`);
+phase('GapMap');
+const gaps = coverageResults.filter(Boolean);
+const gapSummary = gaps.map(g => `${g.module} (~${g.estimatedCoverage}% covered): untested=[${g.untestedBehaviors.slice(0, 3).join(', ')}]`).join('\n');
+log(`Coverage gaps identified across ${gaps.length} modules`);
 
-  phase('Plan');
-  const plan = await agent(
-    `Create a prioritized test-writing plan for: "${target}"\n\nCoverage gaps:\n${gapSummary}\n\nFor each gap, write a concrete test description and skeleton code. Prioritize: P0=high-risk untested, P1=medium-risk gaps, P2=edge cases. Include the actual test skeleton (describe/it or test() blocks) for each.`,
-    { schema: PLAN_SCHEMA, label: 'plan' }
-  );
-  if (!plan) { return { target, modules, gaps, error: 'plan-agent-null' }; }
+phase('Plan');
+const plan = await agent(
+  `Create a prioritized test-writing plan for: "${target}"\n\nCoverage gaps:\n${gapSummary}\n\nFor each gap, write a concrete test description and skeleton code. Prioritize: P0=high-risk untested, P1=medium-risk gaps, P2=edge cases. Include the actual test skeleton (describe/it or test() blocks) for each.`,
+  { schema: PLAN_SCHEMA, label: 'plan' }
+);
+if (!plan) { return { target, modules, gaps, error: 'plan-agent-null' }; }
 
-  return { target, modules, gaps, plan };
-}
+return { target, modules, gaps, plan };