@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/template-validation/report-formatter.js

@@ -1,55 +1,49 @@
-const path = require('node:path');
-
-function formatEntry({ relativePath, result, changedFiles, lines, suppressed }) {
-  if (!result.valid) {
-    lines.push(`\n❌ ${relativePath}`);
-    for (const error of result.errors) {
-      lines.push(`   ERROR: ${error}`);
+"use strict";
+const path = require("node:path");
+function formatEntry({ relativePath, result, changedFiles, lines, suppressed, }) {
+    if (!result.valid) {
+        lines.push(`\n❌ ${relativePath}`);
+        for (const error of result.errors) {
+            lines.push(`   ERROR: ${error}`);
+        }
+        return true;
     }
-    return true;
-  }
-
-  if (result.warnings.length > 0) {
-    if (changedFiles === null || changedFiles.has(relativePath)) {
-      lines.push(`\n⚠️  ${relativePath}`);
-      for (const warning of result.warnings) {
-        lines.push(`   WARN: ${warning}`);
-      }
-    } else {
-      suppressed.count += result.warnings.length;
-      suppressed.fileCount += 1;
+    if (result.warnings.length > 0) {
+        if (changedFiles === null || changedFiles.has(relativePath)) {
+            lines.push(`\n⚠️  ${relativePath}`);
+            for (const warning of result.warnings) {
+                lines.push(`   WARN: ${warning}`);
+            }
+        }
+        else {
+            suppressed.count += result.warnings.length;
+            suppressed.fileCount += 1;
+        }
+        return false;
     }
+    lines.push(`✓ ${relativePath}`);
     return false;
-  }
-
-  lines.push(`✓ ${relativePath}`);
-  return false;
 }
-
 function formatValidationReport(report, { changedFiles = null, cwd = process.cwd() } = {}) {
-  const lines = [];
-  const suppressed = { count: 0, fileCount: 0 };
-  let hasErrors = false;
-
-  for (const { filePath, result } of report.results) {
-    const relativePath = path.relative(cwd, filePath);
-    if (formatEntry({ relativePath, result, changedFiles, lines, suppressed })) {
-      hasErrors = true;
+    const lines = [];
+    const suppressed = { count: 0, fileCount: 0 };
+    let hasErrors = false;
+    for (const { filePath, result } of report.results) {
+        const relativePath = path.relative(cwd, filePath);
+        if (formatEntry({ relativePath, result, changedFiles, lines, suppressed })) {
+            hasErrors = true;
+        }
     }
-  }
-
-  if (suppressed.count > 0) {
-    lines.push(
-      `\n${suppressed.count} pre-existing warning(s) across ${suppressed.fileCount} unrelated template(s) — run \`npm run validate:templates\` for detail`
-    );
-  }
-
-  lines.push(`\n${'='.repeat(60)}`);
-  lines.push(`Validated: ${report.validated} templates, Skipped: ${report.skipped} files`);
-
-  return { lines, hasErrors };
+    if (suppressed.count > 0) {
+        const summary = `\n${suppressed.count} pre-existing warning(s) across ` +
+            `${suppressed.fileCount} unrelated template(s) — ` +
+            'run `npm run validate:templates` for detail';
+        lines.push(summary);
+    }
+    lines.push(`\n${'='.repeat(60)}`);
+    lines.push(`Validated: ${report.validated} templates, Skipped: ${report.skipped} files`);
+    return { lines, hasErrors };
 }
-
 module.exports = {
-  formatValidationReport,
+    formatValidationReport,
 };

package/src/template-validation/report-formatter.ts

@@ -0,0 +1,101 @@
+import path = require('node:path');
+
+interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+interface ValidationReport {
+  results: Array<{ filePath: string; result: ValidationResult }>;
+  validated: number;
+  skipped: number;
+}
+
+interface ReportOptions {
+  changedFiles?: Set<string> | null;
+  cwd?: string;
+}
+
+interface SuppressedWarnings {
+  count: number;
+  fileCount: number;
+}
+
+interface FormatEntryOptions {
+  relativePath: string;
+  result: ValidationResult;
+  changedFiles: Set<string> | null;
+  lines: string[];
+  suppressed: SuppressedWarnings;
+}
+
+interface FormattedValidationReport {
+  lines: string[];
+  hasErrors: boolean;
+}
+
+function formatEntry({
+  relativePath,
+  result,
+  changedFiles,
+  lines,
+  suppressed,
+}: FormatEntryOptions): boolean {
+  if (!result.valid) {
+    lines.push(`\n❌ ${relativePath}`);
+    for (const error of result.errors) {
+      lines.push(`   ERROR: ${error}`);
+    }
+    return true;
+  }
+
+  if (result.warnings.length > 0) {
+    if (changedFiles === null || changedFiles.has(relativePath)) {
+      lines.push(`\n⚠️  ${relativePath}`);
+      for (const warning of result.warnings) {
+        lines.push(`   WARN: ${warning}`);
+      }
+    } else {
+      suppressed.count += result.warnings.length;
+      suppressed.fileCount += 1;
+    }
+    return false;
+  }
+
+  lines.push(`✓ ${relativePath}`);
+  return false;
+}
+
+function formatValidationReport(
+  report: ValidationReport,
+  { changedFiles = null, cwd = process.cwd() }: ReportOptions = {}
+): FormattedValidationReport {
+  const lines: string[] = [];
+  const suppressed = { count: 0, fileCount: 0 };
+  let hasErrors = false;
+
+  for (const { filePath, result } of report.results) {
+    const relativePath = path.relative(cwd, filePath);
+    if (formatEntry({ relativePath, result, changedFiles, lines, suppressed })) {
+      hasErrors = true;
+    }
+  }
+
+  if (suppressed.count > 0) {
+    const summary =
+      `\n${suppressed.count} pre-existing warning(s) across ` +
+      `${suppressed.fileCount} unrelated template(s) — ` +
+      'run `npm run validate:templates` for detail';
+    lines.push(summary);
+  }
+
+  lines.push(`\n${'='.repeat(60)}`);
+  lines.push(`Validated: ${report.validated} templates, Skipped: ${report.skipped} files`);
+
+  return { lines, hasErrors };
+}
+
+export = {
+  formatValidationReport,
+};

package/src/template-validation/simulate-consensus-gates.js

@@ -1,324 +1,133 @@
-const Ledger = require('../ledger');
-const MessageBus = require('../message-bus');
-const LogicEngine = require('../logic-engine');
-
-const STAGE_START_TOPICS = ['IMPLEMENTATION_READY', 'QUICK_VALIDATION_PASSED'];
-const EXTERNAL_STAGE_SENDERS = {
-  IMPLEMENTATION_READY: 'worker',
-  QUICK_VALIDATION_PASSED: 'consensus-coordinator',
-};
-
-function scriptReferencesTopic(logicScript, topic) {
-  return logicScript.includes(`topic: '${topic}'`) || logicScript.includes(`topic: "${topic}"`);
-}
-
-function getRequiredStageTopics(logicScript) {
-  return STAGE_START_TOPICS.filter((topic) => scriptReferencesTopic(logicScript, topic));
-}
-
-function publishStageStartMessages({
-  messageBus,
-  clusterId,
-  producersByTopic,
-  requiredStageTopics,
-  allowExternalTopics,
-}) {
-  let timestamp = Date.now();
-
-  for (const topic of requiredStageTopics) {
-    const producers = Array.from(producersByTopic.get(topic) || []);
-    const sender =
-      producers[0] || (allowExternalTopics.includes(topic) ? EXTERNAL_STAGE_SENDERS[topic] : null);
-    if (!sender) {
-      continue;
-    }
-
-    messageBus.publish({
-      cluster_id: clusterId,
-      topic,
-      sender,
-      timestamp: timestamp++,
-    });
-  }
-}
-
+"use strict";
+const consensus_gate_scenarios_1 = require("./consensus-gate-scenarios");
+const consensus_gate_stage_1 = require("./consensus-gate-stage");
 function collectTopicProducers(config) {
-  const producersByTopic = new Map();
-
-  for (const agent of config.agents || []) {
-    const topic = getPublishedTopic(agent);
-    if (!topic) continue;
-    if (!producersByTopic.has(topic)) {
-      producersByTopic.set(topic, new Set());
+    const producersByTopic = new Map();
+    for (const agent of config.agents || []) {
+        const topic = getPublishedTopic(agent);
+        if (!topic)
+            continue;
+        const producers = producersByTopic.get(topic) || new Set();
+        producers.add(agent.id);
+        producersByTopic.set(topic, producers);
     }
-    producersByTopic.get(topic).add(agent.id);
-  }
-
-  return producersByTopic;
+    return producersByTopic;
 }
-
 function getPublishedTopic(agent) {
-  const onComplete = agent?.hooks?.onComplete;
-  if (!onComplete) return null;
-  if (onComplete.action !== 'publish_message') return null;
-  if (!onComplete.config?.topic) return null;
-  return String(onComplete.config.topic);
-}
-
-function hasConsensusLikeId(agentId) {
-  return agentId.includes('consensus') || agentId.includes('coordinator');
+    const onComplete = agent.hooks?.onComplete;
+    if (!onComplete)
+        return null;
+    if (onComplete.action !== 'publish_message')
+        return null;
+    if (!onComplete.config?.topic)
+        return null;
+    return String(onComplete.config.topic);
 }
-
-function hasStopClusterTrigger(agent) {
-  return agent?.triggers?.some((trigger) => trigger.action === 'stop_cluster');
-}
-
 function isConsensusLikeAgent(agent) {
-  const agentId = String(agent?.id || '');
-  const explicitIds = ['git-pusher', 'completion-detector'];
-
-  return (
-    agent?.role === 'coordinator' ||
-    explicitIds.includes(agentId) ||
-    hasConsensusLikeId(agentId) ||
-    hasStopClusterTrigger(agent)
-  );
+    const agentId = String(agent.id || '');
+    const explicitIds = ['git-pusher', 'completion-detector'];
+    const hasConsensusLikeId = agentId.includes('consensus') || agentId.includes('coordinator');
+    const hasStopClusterTrigger = agent.triggers?.some((trigger) => trigger.action === 'stop_cluster') === true;
+    return (agent.role === 'coordinator' ||
+        explicitIds.includes(agentId) ||
+        hasConsensusLikeId ||
+        hasStopClusterTrigger);
 }
-
 function getMissingStageTopics(requiredStageTopics, producersByTopic, allowExternalTopics) {
-  return requiredStageTopics.filter((stageTopic) => {
-    const producers = producersByTopic.get(stageTopic);
-    return (!producers || producers.size === 0) && !allowExternalTopics.includes(stageTopic);
-  });
+    return requiredStageTopics.filter((stageTopic) => {
+        const producers = producersByTopic.get(stageTopic);
+        return (!producers || producers.size === 0) && !allowExternalTopics.includes(stageTopic);
+    });
 }
-
 function createSimulationContext(config, options = {}) {
-  const agents = Array.isArray(config.agents) ? config.agents : [];
-
-  return {
-    agents,
-    producersByTopic: collectTopicProducers(config),
-    allowExternalTopics: Array.isArray(options.allowExternalTopics)
-      ? options.allowExternalTopics
-      : [],
-    cluster: {
-      id: 'template-sim',
-      agents: agents.map((a) => ({
-        id: a.id,
-        role: a.role,
-        requiredQualityGates: a.requiredQualityGates || [],
-      })),
-    },
-  };
+    const agents = Array.isArray(config.agents) ? config.agents : [];
+    return {
+        agents,
+        producersByTopic: collectTopicProducers(config),
+        allowExternalTopics: Array.isArray(options.allowExternalTopics)
+            ? options.allowExternalTopics
+            : [],
+        cluster: {
+            id: 'template-sim',
+            agents: agents.map((agent) => ({
+                id: agent.id,
+                role: agent.role,
+                requiredQualityGates: agent.requiredQualityGates || [],
+            })),
+        },
+    };
 }
-
-function evaluateScenario({
-  agentId,
-  cluster,
-  topic,
-  script,
-  requiredQualityGates,
-  producers,
-  producersByTopic,
-  requiredStageTopics,
-  allowExternalTopics,
-  publishMessages,
-}) {
-  const ledger = new Ledger(':memory:');
-  const messageBus = new MessageBus(ledger);
-  const logicEngine = new LogicEngine(messageBus, cluster);
-
-  publishStageStartMessages({
-    messageBus,
-    clusterId: cluster.id,
-    producersByTopic,
-    requiredStageTopics,
-    allowExternalTopics,
-  });
-
-  publishMessages(messageBus, producers, cluster.id);
-
-  const result = logicEngine.evaluate(
-    script,
-    { id: agentId, cluster_id: cluster.id, requiredQualityGates },
-    { topic }
-  );
-  ledger.close();
-  return result;
-}
-
-function getPassingQualityGate(requiredGate) {
-  const scope = requiredGate.scope || 'template-sim';
-  return {
-    id: requiredGate.id,
-    status: 'PASS',
-    scope,
-    completedAt: Date.now(),
-    evidence: {
-      command: `quality-check --scope ${scope}`,
-      exitCode: 0,
-      output: 'template simulation quality pass',
-    },
-  };
-}
-
-function getApprovedResultData(context) {
-  const data = { approved: true };
-  const requiredQualityGates = Array.isArray(context.requiredQualityGates)
-    ? context.requiredQualityGates
-    : [];
-  if (
-    context.agentId === 'git-pusher' &&
-    context.topic === 'VALIDATION_RESULT' &&
-    requiredQualityGates.length > 0
-  ) {
-    data.qualityGates = requiredQualityGates.map(getPassingQualityGate);
-  }
-  return data;
-}
-
-function checkDuplicateProducerScenario(context) {
-  return evaluateScenario({
-    ...context,
-    publishMessages(messageBus, producers, clusterId) {
-      messageBus.publish({
-        cluster_id: clusterId,
-        topic: context.topic,
-        sender: producers[0],
-        content: { data: getApprovedResultData(context) },
-      });
-      messageBus.publish({
-        cluster_id: clusterId,
-        topic: context.topic,
-        sender: producers[0],
-        content: { data: getApprovedResultData(context) },
-      });
-    },
-  });
-}
-
-function checkDistinctProducerScenario(context) {
-  return evaluateScenario({
-    ...context,
-    publishMessages(messageBus, producers, clusterId) {
-      for (const producer of producers) {
-        messageBus.publish({
-          cluster_id: clusterId,
-          topic: context.topic,
-          sender: producer,
-          content: { data: getApprovedResultData(context) },
-        });
-      }
-    },
-  });
-}
-
 function getMissingStageFailure(agentId, topic, missingStageTopics) {
-  if (missingStageTopics.length === 0) {
-    return null;
-  }
-
-  return (
-    `Agent "${agentId}" trigger on "${topic}" depends on missing stage topic(s): ${missingStageTopics.join(', ')}. ` +
-    'Preflight must validate real producers, not synthesize stage-start messages.'
-  );
+    if (missingStageTopics.length === 0)
+        return null;
+    return (`Agent "${agentId}" trigger on "${topic}" depends on missing stage topic(s): ${missingStageTopics.join(', ')}. ` +
+        'Preflight must validate real producers, not synthesize stage-start messages.');
+}
+function hasAtLeastTwoProducers(producers) {
+    return producers.length >= 2;
 }
-
 function getConsensusScenarioContext(agent, trigger, simulation) {
-  const topic = trigger?.topic;
-  const script = trigger?.logic?.script;
-  if (!topic || !script) {
-    return null;
-  }
-
-  const requiredStageTopics = getRequiredStageTopics(script);
-  const missingStageTopics = getMissingStageTopics(
-    requiredStageTopics,
-    simulation.producersByTopic,
-    simulation.allowExternalTopics
-  );
-  const missingStageFailure = getMissingStageFailure(agent.id, topic, missingStageTopics);
-  if (missingStageFailure) {
-    return { failure: missingStageFailure };
-  }
-
-  const producers = Array.from(simulation.producersByTopic.get(topic) || []);
-  if (producers.length < 2) {
-    return { failure: null };
-  }
-
-  return {
-    context: {
-      agentId: agent.id,
-      cluster: simulation.cluster,
-      topic,
-      script,
-      requiredQualityGates: agent.requiredQualityGates || [],
-      producers,
-      producersByTopic: simulation.producersByTopic,
-      requiredStageTopics,
-      allowExternalTopics: simulation.allowExternalTopics,
-    },
-    failure: null,
-  };
+    const topic = trigger.topic;
+    const script = trigger.logic?.script;
+    if (!topic || !script)
+        return null;
+    const requiredStageTopics = (0, consensus_gate_stage_1.getRequiredStageTopics)(script);
+    const missingStageFailure = getMissingStageFailure(agent.id, topic, getMissingStageTopics(requiredStageTopics, simulation.producersByTopic, simulation.allowExternalTopics));
+    if (missingStageFailure)
+        return { failure: missingStageFailure };
+    const producers = Array.from(simulation.producersByTopic.get(topic) || []);
+    if (!hasAtLeastTwoProducers(producers))
+        return { failure: null };
+    return {
+        context: {
+            agentId: agent.id,
+            cluster: simulation.cluster,
+            topic,
+            script,
+            requiredQualityGates: agent.requiredQualityGates || [],
+            producers,
+            producersByTopic: simulation.producersByTopic,
+            requiredStageTopics,
+            allowExternalTopics: simulation.allowExternalTopics,
+        },
+        failure: null,
+    };
 }
-
 function validateConsensusTrigger(agent, trigger, simulation) {
-  const scenario = getConsensusScenarioContext(agent, trigger, simulation);
-  if (!scenario) {
-    return [];
-  }
-
-  if (scenario.failure) {
-    return [scenario.failure];
-  }
-
-  if (!scenario.context) {
-    return [];
-  }
-
-  const { context } = scenario;
-  const { producers, topic } = context;
-
-  const failures = [];
-  if (checkDuplicateProducerScenario(context)) {
-    failures.push(
-      `Agent "${agent.id}" trigger on "${topic}" fires early on duplicate sender (${producers[0]}). ` +
-        `Gate must require distinct producers: ${producers.join(', ')}`
-    );
-  }
-
-  if (!checkDistinctProducerScenario(context)) {
-    failures.push(
-      `Agent "${agent.id}" trigger on "${topic}" did not fire after all producers published. ` +
-        `Expected producers: ${producers.join(', ')}`
-    );
-  }
-
-  return failures;
+    const scenario = getConsensusScenarioContext(agent, trigger, simulation);
+    if (!scenario)
+        return [];
+    if (scenario.failure)
+        return [scenario.failure];
+    if (!('context' in scenario))
+        return [];
+    const { context } = scenario;
+    const { producers, topic } = context;
+    const failures = [];
+    if ((0, consensus_gate_scenarios_1.checkDuplicateProducerScenario)(context)) {
+        failures.push(`Agent "${agent.id}" trigger on "${topic}" fires early on duplicate sender (${producers[0]}). ` +
+            `Gate must require distinct producers: ${producers.join(', ')}`);
+    }
+    if (!(0, consensus_gate_scenarios_1.checkDistinctProducerScenario)(context)) {
+        failures.push(`Agent "${agent.id}" trigger on "${topic}" did not fire after all producers published. ` +
+            `Expected producers: ${producers.join(', ')}`);
+    }
+    return failures;
 }
-
-/**
- * Micro-sim: consensus-like trigger gates must not fire early due to duplicate publishes
- * from the same producer (common in retries / double-publish bugs).
- *
- * Returns an array of error strings.
- */
+/** Validate consensus-like trigger gates against duplicate and distinct producer scenarios. */
 function simulateConsensusGates(config, options = {}) {
-  const simulation = createSimulationContext(config, options);
-  const failures = [];
-
-  for (const agent of simulation.agents) {
-    if (!isConsensusLikeAgent(agent)) continue;
-    for (const trigger of agent.triggers || []) {
-      failures.push(...validateConsensusTrigger(agent, trigger, simulation));
+    const simulation = createSimulationContext(config, options);
+    const failures = [];
+    for (const agent of simulation.agents) {
+        if (!isConsensusLikeAgent(agent))
+            continue;
+        for (const trigger of agent.triggers || []) {
+            failures.push(...validateConsensusTrigger(agent, trigger, simulation));
+        }
     }
-  }
-
-  return failures;
+    return failures;
 }
-
 module.exports = {
-  collectTopicProducers,
-  simulateConsensusGates,
+    collectTopicProducers,
+    simulateConsensusGates,
 };