@goodandready/dsh-moa 0.2.25 → 0.2.27

package/lib/moa-stream.js

@@ -0,0 +1,117 @@
+/**
+ * Zero-latency Live Streaming Generator for MoA Turns
+ */
+
+import { cleanMoaWorkspaces } from './file-workspace.js'
+import { formatMoAResponse } from './moa-parser.js'
+import { runMoAPipeline } from './moa-runner.js'
+
+/**
+ * Streams a full MoA turn into chat with live aggregator tokens and progress feedback.
+ */
+export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd, prices, historyFilePath, liveCanvas }, options = {}) {
+  const signal = options?.signal
+  if (signal?.aborted) return
+
+  yield { type: 'block-start', index: 0, blockType: 'text' }
+  yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents started...*\n\n' }
+
+  // Async push-queue for zero-latency live delta streaming
+  const queue = []
+  let notify = null
+
+  const pushUpdate = (text) => {
+    queue.push({ type: 'text-delta', index: 0, text })
+    if (notify) {
+      notify()
+      notify = null
+    }
+  }
+
+  let done = false
+  const pipelinePromise = runMoAPipeline({
+    userPrompt,
+    messages,
+    preset: targetPreset,
+    callLlm,
+    cwd,
+    onProgress: pushUpdate,
+    onStreamDelta: (delta) => pushUpdate(delta),
+    prices,
+    historyFilePath,
+    liveCanvas,
+    signal,
+  })
+    .catch((err) => ({ error: err }))
+    .finally(() => {
+      done = true
+      if (notify) {
+        notify()
+        notify = null
+      }
+    })
+
+  const startTime = Date.now()
+  let lastYieldTime = Date.now()
+
+  try {
+    while (!done || queue.length > 0) {
+      if (signal?.aborted) {
+        await cleanMoaWorkspaces(cwd)
+        return
+      }
+
+      while (queue.length > 0) {
+        const item = queue.shift()
+        yield item
+        lastYieldTime = Date.now()
+      }
+
+      if (done) break
+
+      // Wait for next push item or max 2.5s heartbeat
+      await Promise.race([
+        new Promise((resolve) => { notify = resolve }),
+        new Promise((resolve) => { const t = setTimeout(resolve, 2500); t.unref?.(); }),
+      ])
+
+      const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
+      if (!done && Date.now() - lastYieldTime >= 3000) {
+        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}s] Still processing...*\n` }
+        lastYieldTime = Date.now()
+      }
+    }
+
+    const result = await pipelinePromise
+    if (signal?.aborted) {
+      await cleanMoaWorkspaces(cwd)
+      return
+    }
+
+    if (result?.error) {
+      const errText = '\n\n⚠️ **Mixture of Agents error**: ' + (result.error?.message || String(result.error))
+      yield { type: 'text-delta', index: 0, text: errText }
+      yield { type: 'block-end', index: 0, block: { type: 'text', text: errText } }
+      yield { type: 'finish', reason: { kind: 'stop' } }
+      return
+    }
+
+    const formatted = formatMoAResponse({
+      moaResult: result,
+      presetName: targetPreset?.name || 'default',
+    })
+
+    yield { type: 'text-delta', index: 0, text: '\n---\n\n' + formatted }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text: formatted } }
+    yield {
+      type: 'usage',
+      usage: {
+        inputTokens: result?.usage?.totalTokens || 0,
+        outputTokens: Math.round((formatted.length || 0) / 4),
+      },
+    }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  } finally {
+    // cleanup
+  }
+}

package/lib/moa-test-gate.js

@@ -0,0 +1,236 @@
+import os from 'node:os'
+import fs from 'node:fs/promises'
+import fsSync from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { assertPathContained } from './file-workspace.js'
+
+/**
+ * Resolves the directory for candidate sandbox.
+ */
+export function resolveCandidateDir(baseDir, candidateIndex) {
+  if (!baseDir || candidateIndex === null || candidateIndex === undefined) return null
+  const targetStr = String(candidateIndex).trim()
+  const sanitizedTarget = targetStr.replace(/[^a-zA-Z0-9_-]/g, '')
+  const sub = /^\d+$/.test(sanitizedTarget) ? `candidate-${sanitizedTarget}` : (sanitizedTarget || 'candidate-1')
+  const moaRoot = path.join(baseDir, '.moa')
+  return assertPathContained(moaRoot, sub)
+}
+
+/**
+ * Executes a test command in a candidate sandbox or ephemeral test staging directory.
+ *
+ * @param {object} params
+ * @param {string} params.cwd - Project root workspace directory
+ * @param {number|string} params.candidateIndex - Index of candidate (1, 2, ...)
+ * @param {string} params.testCommand - Shell command to execute (e.g. "npm test", "node --test")
+ * @param {number} [params.timeoutMs=15000] - Execution timeout in ms
+ * @param {number} [params.maxOutputChars=2000] - Maximum captured output chars
+ * @param {function} [params.execFn] - Optional mock/test runner function
+ * @returns {Promise<object|null>} Test result object or null if skipped
+ */
+export async function runCandidateTestGate({
+  cwd,
+  candidateIndex,
+  testCommand,
+  timeoutMs = 15000,
+  maxOutputChars = 2000,
+  execFn = null,
+}) {
+  if (!cwd || !testCommand || typeof testCommand !== 'string') {
+    return null
+  }
+
+  const trimmedCmd = testCommand.trim()
+  if (!trimmedCmd) return null
+
+  const candidateDir = resolveCandidateDir(cwd, candidateIndex)
+  if (!candidateDir || !fsSync.existsSync(candidateDir)) {
+    return null
+  }
+
+  const startTime = Date.now()
+  let stageDir = null
+  let executionDir = candidateDir
+
+  try {
+    const basePkg = path.join(cwd, 'package.json')
+    const candPkg = path.join(candidateDir, 'package.json')
+    if (fsSync.existsSync(basePkg) && !fsSync.existsSync(candPkg)) {
+      stageDir = await fs.mkdtemp(path.join(os.tmpdir(), `moa-test-stage-${candidateIndex}-`))
+
+      await fs.cp(cwd, stageDir, {
+        recursive: true,
+        filter: (src) => {
+          const rel = path.relative(cwd, src)
+          if (!rel) return true
+          const parts = rel.split(path.sep)
+          if (parts[0] === 'node_modules' || parts[0] === '.git' || parts[0] === '.moa') {
+            return false
+          }
+          return true
+        },
+      })
+
+      await fs.cp(candidateDir, stageDir, { recursive: true })
+      executionDir = stageDir
+    }
+
+    const resolvedCmd = trimmedCmd
+      .replaceAll('{candidateDir}', candidateDir)
+      .replaceAll('{baseDir}', cwd)
+      .replaceAll('{stageDir}', executionDir)
+
+    let exitCode = 0
+    let stdout = ''
+    let stderr = ''
+
+    if (typeof execFn === 'function') {
+      const customRes = await execFn({
+        cwd: executionDir,
+        candidateDir,
+        command: resolvedCmd,
+        timeoutMs,
+      })
+      exitCode = customRes?.exitCode ?? (customRes?.passed ? 0 : 1)
+      stdout = customRes?.stdout || ''
+      stderr = customRes?.stderr || ''
+    } else {
+      const nodePath = path.join(cwd, 'node_modules')
+      const env = {
+        ...process.env,
+        MOA_CANDIDATE_INDEX: String(candidateIndex),
+        MOA_CANDIDATE_DIR: candidateDir,
+        MOA_BASE_DIR: cwd,
+        NODE_PATH: process.env.NODE_PATH ? `${nodePath}:${process.env.NODE_PATH}` : nodePath,
+      }
+
+      const runPromise = new Promise((resolve) => {
+        let child
+        try {
+          child = spawn(resolvedCmd, {
+            cwd: executionDir,
+            shell: true,
+            env,
+            timeout: timeoutMs,
+          })
+        } catch (spawnErr) {
+          resolve({ exitCode: 1, stdout: '', stderr: spawnErr.message || String(spawnErr) })
+          return
+        }
+
+        const outChunks = []
+        const errChunks = []
+
+        child.stdout?.on('data', (d) => outChunks.push(d))
+        child.stderr?.on('data', (d) => errChunks.push(d))
+
+        child.on('error', (err) => {
+          resolve({ exitCode: 1, stdout: Buffer.concat(outChunks).toString('utf8'), stderr: err.message || String(err) })
+        })
+
+        child.on('close', (code, sig) => {
+          const combinedErr = Buffer.concat(errChunks).toString('utf8')
+          const finalErr = sig ? `${combinedErr}\nProcess terminated by signal ${sig}`.trim() : combinedErr
+          resolve({
+            exitCode: code ?? (sig ? 128 : 1),
+            stdout: Buffer.concat(outChunks).toString('utf8'),
+            stderr: finalErr,
+          })
+        })
+      })
+
+      const execResult = await runPromise
+      exitCode = execResult.exitCode
+      stdout = execResult.stdout
+      stderr = execResult.stderr
+    }
+
+    const durationMs = Date.now() - startTime
+    const combinedOutput = [stdout, stderr].filter(Boolean).join('\n').trim()
+    const truncatedOutput = combinedOutput.length > maxOutputChars
+      ? `${combinedOutput.slice(0, maxOutputChars)}\n...[output truncated by Test Gate]`
+      : combinedOutput
+
+    const passed = exitCode === 0
+    const summary = passed
+      ? `PASS (${durationMs}ms)`
+      : `FAIL (code ${exitCode}, ${durationMs}ms)`
+
+    return {
+      candidateIndex,
+      passed,
+      exitCode,
+      durationMs,
+      command: resolvedCmd,
+      output: truncatedOutput,
+      summary,
+    }
+  } catch (err) {
+    const durationMs = Date.now() - startTime
+    return {
+      candidateIndex,
+      passed: false,
+      exitCode: 1,
+      durationMs,
+      command: trimmedCmd,
+      output: `Test Gate Error: ${err.message || String(err)}`,
+      summary: `ERROR (${err.message || 'unknown'})`,
+    }
+  } finally {
+    if (stageDir) {
+      try {
+        await fs.rm(stageDir, { recursive: true, force: true })
+      } catch {}
+    }
+  }
+}
+
+/**
+ * Runs Test Execution Gate across all successful candidates with generated files.
+ */
+export async function executeTestGateForCandidates({
+  cwd,
+  referenceOutputs = [],
+  preset = {},
+  options = {},
+  onProgress = null,
+}) {
+  const isEnabled = Boolean(options.testGateEnabled ?? preset.test_gate_enabled)
+  const testCmd = options.testCommand || preset.test_command
+  if (!isEnabled || !testCmd || !cwd) {
+    return []
+  }
+
+  const timeoutMs = (preset.test_gate_timeout_sec || 15) * 1000
+  const maxOutputChars = preset.test_gate_max_output_chars || 2000
+
+  if (typeof onProgress === 'function') {
+    onProgress('🧪 *Test Execution Gate: Running test suite against candidate sandboxes...*\n')
+  }
+
+  const results = []
+  for (const ref of referenceOutputs) {
+    if (!ref.ok || !ref.files || ref.files.length === 0) continue
+
+    const res = await runCandidateTestGate({
+      cwd,
+      candidateIndex: ref.index,
+      testCommand: testCmd,
+      timeoutMs,
+      maxOutputChars,
+      execFn: options.execFn,
+    })
+
+    if (res) {
+      ref.testResult = res
+      results.push(res)
+      if (typeof onProgress === 'function') {
+        const icon = res.passed ? '✅' : '❌'
+        onProgress(`🧪 *Candidate ${ref.index}: ${icon} ${res.summary}*\n`)
+      }
+    }
+  }
+
+  return results
+}

package/lib/routes.js

@@ -11,6 +11,8 @@ import {
 import { promoteCandidateWorkspace, readCandidateFiles, computeLineDiff, isSafeRelativePath } from './file-workspace.js'
 import { isSafeWriteRequest } from './updater.js'
 import { runMoAPipeline } from './moa-runner.js'
+import { generateMoABenchmarkReport } from './moa-report.js'
+import { resolvePresetForPrompt } from './moa-router.js'
 
 let _modelsCache = { timestamp: 0, models: [] }
 const MODELS_CACHE_TTL = 60 * 1000
@@ -423,16 +425,72 @@ ctx.effect(() => {
         const urlPath = req.url.split('?')[0]
         const parts = urlPath.split('/').filter(Boolean)
         const runId = parts[2] || ''
+        const isReport = parts[3] === 'report'
         const run = runId ? getMoaRunById(runId) : null
         if (!run) {
           writeJson(res, 404, { ok: false, error: 'Run not found' })
           return
         }
+        if (isReport) {
+          const u = new URL(req.url, 'http://127.0.0.1')
+          const format = u.searchParams.get('format') || 'md'
+          const report = run.benchmarkReport || generateMoABenchmarkReport({
+            runId: run.id,
+            timestamp: run.timestamp,
+            preset: run.preset,
+            prompt: run.prompt,
+            durationMs: run.durationMs,
+            usage: { totalTokens: run.totalTokens },
+            costUsd: run.totalCostUsd,
+            candidates: run.candidates,
+            winningIndex: run.winnerIndex,
+            winningLabel: run.winnerModel,
+          })
+          if (format === 'json') {
+            writeJson(res, 200, { ok: true, report: typeof report === 'object' ? (report.json || report) : report })
+            return
+          }
+          const mdText = typeof report === 'string' ? report : (report.markdown || JSON.stringify(report, null, 2))
+          res.writeHead(200, { 'Content-Type': 'text/markdown; charset=utf-8' })
+          res.end(mdText)
+          return
+        }
         writeJson(res, 200, { ok: true, run })
       },
     })
   }, 'dsh-moa: run by id route')
 
+  // Route: /dsh-moa/route-preset
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/route-preset',
+      handler: async (req, res) => {
+        if (req.method !== 'POST') {
+          writeJson(res, 405, { ok: false, error: 'POST required' })
+          return
+        }
+        try {
+          const raw = await readBody(req)
+          const body = JSON.parse(raw || '{}')
+          const prompt = body?.prompt || ''
+          const cfg = live()
+          const result = await resolvePresetForPrompt({
+            prompt,
+            presets: cfg.presets || [],
+            defaultPreset: cfg.default_preset || 'default',
+            routingModel: cfg.smart_routing_model,
+            callLlm,
+            enabled: true,
+          })
+          writeJson(res, 200, { ok: true, ...result })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
+        }
+      },
+    })
+  }, 'dsh-moa: route preset endpoint')
+
   // Route: /dsh-moa/run
   ctx.effect(() => {
     return ctx.webServer.register({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.25",
+  "version": "0.2.27",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",