@goodandready/dsh-moa 0.2.26 → 0.2.27

package/lib/moa-context.js

@@ -0,0 +1,70 @@
+/**
+ * Multi-Turn Conversation Memory & Context Pruning
+ * Feature 8 (Multi-Turn Continuity)
+ */
+
+/**
+ * Extracts concise prior turn baseline from previous conversation messages.
+ */
+export function extractPriorTurnBaseline(messages = []) {
+  if (!Array.isArray(messages) || messages.length === 0) return null
+
+  // Find the last assistant message
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (msg?.role === 'assistant' && typeof msg?.content === 'string') {
+      const text = msg.content.trim()
+      if (text.length > 0) {
+        // Strip out noisy banners if present
+        const cleaned = text
+          .replace(/^#+\s*🏆[^\n]+\n/m, '')
+          .replace(/<!--\s*moa-metadata[\s\S]*?-->/g, '')
+          .trim()
+        return cleaned.slice(0, 3500)
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Prunes conversation history for candidate fan-out to prevent token ballooning
+ * while preserving multi-turn context continuity.
+ */
+export function pruneMultiTurnMessages(messages = [], maxHistoryTokens = 3000) {
+  if (!Array.isArray(messages) || messages.length <= 2) {
+    return messages || []
+  }
+
+  const pruned = []
+  const sysMsg = messages.find((m) => m && m.role === 'system')
+  if (sysMsg) {
+    pruned.push(sysMsg)
+  }
+
+  // Get conversation turns excluding system
+  const nonSys = messages.filter((m) => m && m.role !== 'system')
+  if (nonSys.length === 0) return pruned
+
+  // Always keep the final 2 turns (last user and prior assistant)
+  const recentTurns = nonSys.slice(-4)
+
+  for (let idx = 0; idx < recentTurns.length; idx++) {
+    const msg = recentTurns[idx]
+    const isLatest = idx === recentTurns.length - 1
+    const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
+
+    if (isLatest || content.length < 800) {
+      pruned.push(msg)
+    } else {
+      // Prune long prior assistant or user text to protect candidate context
+      const truncated = content.slice(0, 750) + '\n\n[...context pruned for token efficiency...]\n' + content.slice(-250)
+      pruned.push({
+        role: msg.role,
+        content: truncated,
+      })
+    }
+  }
+
+  return pruned
+}

package/lib/moa-multi-judge.js

@@ -0,0 +1,301 @@
+/**
+ * Multi-Judge Panel Consensus Voting & Composite Hybrid Synthesis
+ * Feature 2 (Multi-Judge Panel) & Feature 3 (Composite Block Synthesis)
+ */
+
+import { slotLabel } from './moa-prompts.js'
+
+/**
+ * Extracts code fences and block-level assets from markdown text.
+ */
+export function extractCodeBlocks(text = '') {
+  if (!text || typeof text !== 'string') return []
+  const blocks = []
+  const regex = /```([a-zA-Z0-9_\-\.\/:]+)?(?:\s+(?:file|path|filename)=([^\s\n]+))?\n([\s\S]*?)```/g
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    const rawTag = (match[1] || '').trim()
+    const explicitFile = (match[2] || '').trim()
+    let lang = rawTag
+    let filename = explicitFile
+
+    // Handle ```ts:src/app.ts or ```typescript:app.ts
+    if (rawTag.includes(':')) {
+      const parts = rawTag.split(':')
+      lang = parts[0]
+      filename = parts.slice(1).join(':')
+    } else if (rawTag.includes('/') || rawTag.includes('.')) {
+      filename = rawTag
+    }
+
+    blocks.push({
+      lang: lang || 'text',
+      filename: filename || null,
+      code: match[3],
+      fullBlock: match[0],
+    })
+  }
+  return blocks
+}
+
+/**
+ * Builds composite block directives highlighting complementary modules across candidates.
+ */
+export function buildCompositeBlockDirectives(candidates = []) {
+  const fileMap = new Map()
+
+  for (const c of candidates) {
+    if (!c.ok || !c.text) continue
+    const blocks = extractCodeBlocks(c.text)
+    for (const b of blocks) {
+      if (b.filename) {
+        if (!fileMap.has(b.filename)) {
+          fileMap.set(b.filename, [])
+        }
+        fileMap.get(b.filename).push(c.label || `Candidate ${c.index}`)
+      }
+    }
+  }
+
+  let fileOverview = ''
+  if (fileMap.size > 0) {
+    fileOverview = '\nDetected modular file contributions across candidates:\n' +
+      Array.from(fileMap.entries())
+        .map(([file, contributors]) => `- \`${file}\`: available in ${contributors.join(', ')}`)
+        .join('\n') + '\n'
+  }
+
+  return `
+=== COMPOSITE HYBRID SYNTHESIS DIRECTIVE ===
+You must synthesize a unified, best-of-all-worlds composite solution from all candidates.
+Do NOT simply copy one candidate. Instead:
+1. Extract the cleanest and most efficient core logic/algorithm (e.g. from the candidate with the highest reasoning score).
+2. Incorporate defensive error handling, input validation, and edge-case guards.
+3. Retain complete type annotations, utility helpers, and test coverage provided by any candidate.
+4. Ensure all merged modules, functions, and files fit together into a cohesive, non-conflicting solution.
+${fileOverview}============================================
+`
+}
+
+/**
+ * Parses judge output into structured scores and candidate choice.
+ */
+export function parseJudgeEvaluation(rawText = '', candidateCount = 2) {
+  const scores = {}
+  let bestCandidate = 1
+  let reasoning = ''
+
+  const scoreMatches = rawText.matchAll(/Candidate\s*(\d+)[:\s]+(?:Score\s*[:\s]*)?([0-9]+(?:\.[0-9]+)?)/gi)
+  for (const m of scoreMatches) {
+    const idx = parseInt(m[1], 10)
+    const val = parseFloat(m[2])
+    if (idx >= 1 && idx <= candidateCount && !Number.isNaN(val)) {
+      scores[idx] = Math.min(10, Math.max(0, val))
+    }
+  }
+
+  const bestMatch = rawText.match(/BEST_CANDIDATE\s*[:\s]+(?:Candidate\s*)?(\d+)/i)
+  if (bestMatch) {
+    const parsedBest = parseInt(bestMatch[1], 10)
+    if (parsedBest >= 1 && parsedBest <= candidateCount) {
+      bestCandidate = parsedBest
+    }
+  } else {
+    // Find candidate with max parsed score
+    let maxScore = -1
+    for (const [idxStr, s] of Object.entries(scores)) {
+      if (s > maxScore) {
+        maxScore = s
+        bestCandidate = parseInt(idxStr, 10)
+      }
+    }
+  }
+
+  const reasonMatch = rawText.match(/CONSENSUS_REASONING\s*[:\s]+([^\n\r]+)/i)
+  if (reasonMatch) {
+    reasoning = reasonMatch[1].trim()
+  } else {
+    reasoning = rawText.slice(0, 180).replace(/\n/g, ' ').trim()
+  }
+
+  return { scores, bestCandidate, reasoning }
+}
+
+/**
+ * Executes a panel of judges to reach consensus on candidate solutions.
+ */
+export async function executeMultiJudgePanel({
+  judges = [],
+  candidates = [],
+  userPrompt = '',
+  callLlm,
+  strategy = 'majority', // 'majority' | 'highest_score' | 'unanimous'
+  timeoutMs = 45000,
+  signal,
+  onProgress,
+}) {
+  const activeCandidates = (candidates || []).filter((c) => c && c.ok)
+  if (activeCandidates.length === 0) {
+    return {
+      consensus: false,
+      winningCandidateIndex: 1,
+      strategy,
+      reason: 'no_active_candidates',
+    }
+  }
+
+  if (activeCandidates.length === 1) {
+    return {
+      consensus: true,
+      winningCandidateIndex: activeCandidates[0].index,
+      winningCandidateLabel: activeCandidates[0].label,
+      strategy,
+      reason: 'single_active_candidate',
+    }
+  }
+
+  const judgeSlots = Array.isArray(judges) && judges.length > 0
+    ? judges
+    : [{ provider: 'default', model: 'aggregator-judge', label: 'Primary Judge' }]
+
+  const candidateSummary = activeCandidates.map((c) => {
+    return `### Candidate ${c.index} (${c.label}):\n${(c.text || '').slice(0, 4000)}`
+  }).join('\n\n---\n\n')
+
+  const judgePrompt = `You are an impartial Expert Code & Logic Judge evaluating multiple AI candidate solutions.
+User Prompt:
+${userPrompt.slice(0, 1000)}
+
+Candidate Solutions:
+${candidateSummary}
+
+Evaluate the solutions on correctness, architecture, edge cases, and maintainability.
+Rate each candidate on a scale of 1 to 10.
+Pick the single best candidate.
+
+Your response MUST follow this exact format:
+SCORES:
+${activeCandidates.map((c) => `Candidate ${c.index}: [1-10]`).join('\n')}
+BEST_CANDIDATE: [index number]
+CONSENSUS_REASONING: [one concise sentence explaining your pick]
+`
+
+  if (typeof onProgress === 'function') {
+    onProgress(`⚖️ *Convening Multi-Judge Panel (${judgeSlots.length} judges, strategy: ${strategy})...*\n`)
+  }
+
+  const judgePromises = judgeSlots.map(async (judge, jIdx) => {
+    const label = slotLabel(judge)
+    try {
+      const abortCtrl = new AbortController()
+      if (signal) {
+        signal.addEventListener('abort', () => abortCtrl.abort(), { once: true })
+      }
+      const timer = setTimeout(() => abortCtrl.abort(new Error('Judge evaluation timeout')), timeoutMs)
+      timer.unref?.()
+
+      const res = await callLlm({
+        provider: judge.provider,
+        model: judge.model,
+        messages: [
+          { role: 'system', content: 'You are an objective expert judge in an ensemble evaluation system.' },
+          { role: 'user', content: judgePrompt },
+        ],
+        temperature: 0.1,
+        maxTokens: 512,
+        signal: abortCtrl.signal,
+      })
+      clearTimeout(timer)
+
+      const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
+      const evalResult = parseJudgeEvaluation(text, candidates.length)
+
+      return {
+        judgeIndex: jIdx + 1,
+        judgeLabel: label,
+        ok: true,
+        ...evalResult,
+      }
+    } catch (err) {
+      return {
+        judgeIndex: jIdx + 1,
+        judgeLabel: label,
+        ok: false,
+        bestCandidate: 1,
+        scores: {},
+        reasoning: err?.message || String(err),
+      }
+    }
+  })
+
+  const results = await Promise.all(judgePromises)
+  const validResults = results.filter((r) => r.ok)
+
+  // Tally votes and compute average scores
+  const votes = {}
+  const totalScores = {}
+  const scoreCounts = {}
+
+  for (const r of validResults) {
+    votes[r.bestCandidate] = (votes[r.bestCandidate] || 0) + 1
+    for (const [cIdx, s] of Object.entries(r.scores || {})) {
+      totalScores[cIdx] = (totalScores[cIdx] || 0) + s
+      scoreCounts[cIdx] = (scoreCounts[cIdx] || 0) + 1
+    }
+  }
+
+  const averageScores = {}
+  for (const c of activeCandidates) {
+    const cnt = scoreCounts[c.index] || 0
+    averageScores[c.index] = cnt > 0 ? Number((totalScores[c.index] / cnt).toFixed(2)) : 5.0
+  }
+
+  let winner = activeCandidates[0].index
+  let isUnanimous = false
+
+  if (strategy === 'highest_score') {
+    let highestAvg = -1
+    for (const c of activeCandidates) {
+      const avg = averageScores[c.index] || 0
+      if (avg > highestAvg) {
+        highestAvg = avg
+        winner = c.index
+      }
+    }
+  } else {
+    // majority or unanimous
+    let maxVotes = -1
+    for (const c of activeCandidates) {
+      const v = votes[c.index] || 0
+      if (v > maxVotes) {
+        maxVotes = v
+        winner = c.index
+      } else if (v === maxVotes && (averageScores[c.index] || 0) > (averageScores[winner] || 0)) {
+        winner = c.index
+      }
+    }
+    isUnanimous = (votes[winner] || 0) === validResults.length && validResults.length > 0
+  }
+
+  const winningCand = activeCandidates.find((c) => c.index === winner) || activeCandidates[0]
+
+  const consensusReport = `Multi-Judge Consensus (${validResults.length}/${judgeSlots.length} judges): ` +
+    `Winner is Candidate ${winningCand.index} (${winningCand.label}) with ${votes[winner] || 0} votes, ` +
+    `avg score ${averageScores[winner] || 0}/10. Strategy: ${strategy}.`
+
+  if (typeof onProgress === 'function') {
+    onProgress(`🏁 *${consensusReport}*\n`)
+  }
+
+  return {
+    consensus: true,
+    winningCandidateIndex: winningCand.index,
+    winningCandidateLabel: winningCand.label,
+    strategy,
+    isUnanimous,
+    votes,
+    averageScores,
+    judgesResults: results,
+    consensusReport,
+  }
+}

package/lib/moa-prompts.js

@@ -343,6 +343,9 @@ ${ANTIPATTERNS_RUBRIC}
 ${LANGUAGE_MIRRORING_DIRECTIVE}
 ${referenceOutputs.some((r) => r.testResult) ? `\n${TEST_GATE_DIRECTIVE}\n` : ''}
 ${referenceOutputs.some((r) => r.syntaxWarning) ? `\n${SYNTAX_CORRECTION_DIRECTIVE}\n` : ''}
+${options.priorTurnBaseline ? `\n### 🔄 Prior Turn Context Baseline:\n${options.priorTurnBaseline}\n` : ''}
+${options.consensusReport ? `\n### ⚖️ Multi-Judge Consensus Advisory:\n${options.consensusReport}\n` : ''}
+${options.compositeMergeDirective ? `\n${options.compositeMergeDirective}\n` : ''}
 Instructions:
 Your response MUST be structured into three clear parts:
 

package/lib/moa-report.js

@@ -0,0 +1,124 @@
+/**
+ * Automated Benchmark & Post-Mortem PR Reports
+ * Feature 9 (Automated Benchmark & Post-Mortem PR Reports)
+ */
+
+export function generateMoABenchmarkReport({
+  runId = '',
+  timestamp = new Date().toISOString(),
+  preset = 'default',
+  prompt = '',
+  durationMs = 0,
+  usage = {},
+  costUsd = 0,
+  candidates = [],
+  winningIndex = 1,
+  winningLabel = '',
+  consensus = null,
+  testGate = null,
+  isComposite = false,
+}) {
+  const durationSec = (durationMs / 1000).toFixed(2)
+  const totalCost = typeof costUsd === 'number' ? costUsd.toFixed(4) : '0.0000'
+  const inTokens = usage?.inputTokens || 0
+  const outTokens = usage?.outputTokens || 0
+  const totalTokens = usage?.totalTokens || (inTokens + outTokens)
+
+  const candidateRows = (candidates || []).map((c) => {
+    const idx = c.index || '?'
+    const label = c.label || `${c.slot?.provider}:${c.slot?.model}`
+    const role = c.role_persona || 'general'
+    const status = c.ok ? '✅ OK' : '❌ Failed'
+    const candTokens = c.usage?.totalTokens || (c.usage?.inputTokens || 0) + (c.usage?.outputTokens || 0)
+    const candCost = c.costUsd ? `$${c.costUsd.toFixed(4)}` : '$0.0000'
+    const score = consensus?.averageScores?.[c.index] !== undefined
+      ? `${consensus.averageScores[c.index]}/10`
+      : 'N/A'
+    const isWin = c.index === winningIndex ? ' 🏆' : ''
+    return `| ${idx}${isWin} | \`${label}\` | ${role} | ${status} | ${candTokens} | ${candCost} | ${score} |`
+  }).join('\n')
+
+  let testGateSection = '### 🧪 Automated Test Gate\n- **Status**: Not Configured / Skipped'
+  if (testGate && testGate.enabled) {
+    const tgStatus = testGate.passed ? '✅ PASSED' : '❌ FAILED'
+    testGateSection = `### 🧪 Automated Test Gate
+- **Status**: ${tgStatus}
+- **Test Command**: \`${testGate.command || 'N/A'}\`
+- **Exit Code**: \`${testGate.exitCode ?? 0}\`
+- **Output Snippet**:
+\`\`\`
+${(testGate.output || 'No output recorded').slice(0, 500)}
+\`\`\``
+  }
+
+  let consensusSection = '### ⚖️ Multi-Judge Consensus\n- **Status**: Standard single-aggregator synthesis'
+  if (consensus && consensus.consensus) {
+    consensusSection = `### ⚖️ Multi-Judge Consensus
+- **Winning Candidate**: Candidate ${winningIndex} (${winningLabel})
+- **Strategy**: \`${consensus.strategy || 'majority'}\`
+- **Unanimous**: ${consensus.isUnanimous ? 'Yes ✅' : 'No (Majority)'}
+- **Summary**: ${consensus.consensusReport || 'Consensus reached'}
+`
+  }
+
+  const markdown = `# 🏆 Mixture of Agents (MoA) Benchmark & Post-Mortem Report
+
+> **Run ID**: \`${runId}\`  
+> **Timestamp**: \`${timestamp}\`  
+> **Preset**: \`${preset}\`  
+> **Total Latency**: \`${durationSec}s\` | **Total Cost**: \`$${totalCost}\` | **Tokens**: \`${totalTokens}\` (In: ${inTokens}, Out: ${outTokens})
+
+---
+
+## 🎯 Task Prompt
+\`\`\`text
+${prompt.slice(0, 500)}${prompt.length > 500 ? '...' : ''}
+\`\`\`
+
+---
+
+## 📊 Candidate Models Benchmark Matrix
+| # | Model / Provider | Role | Status | Tokens | Cost | Judge Score |
+|---|------------------|------|--------|--------|------|-------------|
+${candidateRows || '| - | No candidate data | - | - | - | - | - |'}
+
+---
+
+${consensusSection}
+
+---
+
+${testGateSection}
+
+---
+
+### 🧬 Synthesis Mode
+- **Mode**: ${isComposite ? 'Composite Hybrid AST/Block Merge (Multi-Candidate Synthesis)' : `Candidate Selection (Winning model: ${winningLabel || 'Aggregator'})`}
+`
+
+  const json = {
+    runId,
+    timestamp,
+    preset,
+    prompt,
+    durationMs,
+    usage: { inputTokens: inTokens, outputTokens: outTokens, totalTokens },
+    costUsd,
+    candidates: (candidates || []).map((c) => ({
+      index: c.index,
+      label: c.label,
+      role: c.role_persona,
+      ok: c.ok,
+      costUsd: c.costUsd || 0,
+      usage: c.usage,
+      score: consensus?.averageScores?.[c.index] ?? null,
+    })),
+    winningIndex,
+    winningLabel,
+    consensus,
+    testGate,
+    isComposite,
+  }
+
+  return { markdown, json }
+}

package/lib/moa-router.js

@@ -0,0 +1,102 @@
+/**
+ * Smart Preset Router for Mixture of Agents (MoA).
+ * Supports heuristic keyword classification and optional JEV/LLM zero-shot routing.
+ */
+
+const INTENT_RULES = [
+  { preset: 'security-audit', regex: /\b(security|vulnerability|exploit|cve|xss|injection|sanitize|threat|auth|permission|secret)\b/i },
+  { preset: 'bug-hunter', regex: /\b(bug|fix|error|crash|exception|regression|reproduce|broken|fail|issue)\b/i },
+  { preset: 'refactor-cleanup', regex: /\b(refactor|clean|simplify|ponytail|yagni|prune|dedup|modular|dead\s*code)\b/i },
+  { preset: 'code-review', regex: /\b(review|critique|audit|pr|pull\s*request|diff|inspect|check\s*code)\b/i },
+  { preset: 'frontend-ui', regex: /\b(frontend|ui|css|html|react|vue|tailwind|styling|styles?|stylesheet|component|button|layout|page|landing|modal)\b/i },
+  { preset: 'deep-architect', regex: /\b(architect|distributed|system|microservice|database|scalab|pipeline|infra|schema)\b/i },
+  { preset: 'math-logic', regex: /\b(math|algorithm|proof|matrix|calc|complexity|combinatorics|graph|tree|dynamic\s*programming)\b/i },
+  { preset: 'creative-brainstorm', regex: /\b(brainstorm|idea|concept|creative|alternative|options|feature\s*idea)\b/i },
+  { preset: 'fast-audit', regex: /\b(quick|fast|brief|summary|one-line|short|tldr)\b/i },
+]
+
+/**
+ * Fast keyword-based intent classification.
+ */
+export function classifyPromptIntent(prompt = '') {
+  if (!prompt || typeof prompt !== 'string') return null
+  const text = prompt.trim()
+  for (const rule of INTENT_RULES) {
+    if (rule.regex.test(text)) {
+      return rule.preset
+    }
+  }
+  return null
+}
+
+/**
+ * Resolves the optimal preset for a given user prompt.
+ */
+export async function resolvePresetForPrompt({
+  prompt = '',
+  presets = [],
+  defaultPreset = 'default',
+  routingModel = null,
+  callLlm = null,
+  enabled = false,
+  timeoutMs = 2000,
+}) {
+  const availableNames = (presets || []).map((p) => p.name).filter(Boolean)
+  const safeDefault = availableNames.includes(defaultPreset) ? defaultPreset : (availableNames[0] || 'default')
+
+  if (!enabled || !prompt || typeof prompt !== 'string') {
+    return { presetName: safeDefault, reason: 'default', isAutoRouted: false }
+  }
+
+  // 1. If LLM routing model (e.g. JEV) is configured and callable, run fast zero-shot classifier
+  if (routingModel?.provider && routingModel?.model && typeof callLlm === 'function') {
+    try {
+      const systemPrompt = `You are the MoA Preset Router. Given user prompt, classify which preset is best suited.
+Available presets: ${availableNames.join(', ')}
+Respond with ONLY the chosen preset name and nothing else.`
+
+      const abortCtrl = new AbortController()
+      const timer = setTimeout(() => abortCtrl.abort(), timeoutMs)
+      timer.unref?.()
+
+      const res = await callLlm({
+        provider: routingModel.provider,
+        model: routingModel.model,
+        messages: [
+          { role: 'system', content: systemPrompt },
+          { role: 'user', content: prompt.slice(0, 500) },
+        ],
+        temperature: 0.1,
+        maxTokens: 30,
+        signal: abortCtrl.signal,
+      })
+      clearTimeout(timer)
+
+      const rawChoice = typeof res === 'string' ? res : (res?.content || res?.text || '')
+      const match = availableNames.find((name) => new RegExp(`\\b${name}\\b`, 'i').test(rawChoice))
+      if (match) {
+        return {
+          presetName: match,
+          reason: 'llm_classifier',
+          routerModel: `${routingModel.provider}:${routingModel.model}`,
+          isAutoRouted: true,
+        }
+      }
+    } catch {
+      // Fallback silently to heuristic rules on timeout or network error
+    }
+  }
+
+  // 2. Keyword heuristic classifier
+  const heuristic = classifyPromptIntent(prompt)
+  if (heuristic && availableNames.includes(heuristic)) {
+    return {
+      presetName: heuristic,
+      reason: 'keyword_heuristic',
+      isAutoRouted: true,
+    }
+  }
+
+  // 3. Fallback to default
+  return { presetName: safeDefault, reason: 'default_fallback', isAutoRouted: false }
+}