@goodandready/dsh-moa 0.2.9 → 0.2.11

package/lib/history.js

@@ -1,7 +1,7 @@
 /**
  * MoA Run History & Analytics Module
  * Records every MoA pipeline execution, tracks model win rates and costs,
- * and provides history search and run replay capabilities.
+ * and provides history search, file rotation, and non-blocking I/O.
  */
 
 import fs from 'node:fs'
@@ -12,6 +12,9 @@ import crypto from 'node:crypto'
 const DEFAULT_HISTORY_DIR = path.join(os.homedir(), '.dsh')
 const DEFAULT_HISTORY_FILE = path.join(DEFAULT_HISTORY_DIR, 'moa-history.jsonl')
 
+/** Max history file size before rotation (10 MB) */
+export const MAX_HISTORY_BYTES = 10 * 1024 * 1024
+
 export function getHistoryFilePath(customDir) {
   if (customDir) {
     return path.join(customDir, '.moa-history.jsonl')
@@ -20,7 +23,67 @@ export function getHistoryFilePath(customDir) {
 }
 
 /**
- * Appends a completed MoA run record to the history file.
+ * Checks if the history file exceeds the size threshold and rotates it.
+ * Moves current file to `${filePath}.1`, removing any older `.1` backup.
+ */
+export function rotateHistoryFileIfNeeded(filePath = DEFAULT_HISTORY_FILE, maxBytes = MAX_HISTORY_BYTES) {
+  try {
+    if (!fs.existsSync(filePath)) return false
+    const stat = fs.statSync(filePath)
+    if (stat.size >= maxBytes) {
+      const backupPath = `${filePath}.1`
+      if (fs.existsSync(backupPath)) {
+        try { fs.unlinkSync(backupPath) } catch {}
+      }
+      fs.renameSync(filePath, backupPath)
+      return true
+    }
+  } catch (err) {
+    console.warn('[dsh-moa] History rotation warning:', err?.message || err)
+  }
+  return false
+}
+
+/**
+ * Prepares a normalized history record entry.
+ */
+function normalizeRunRecord(record) {
+  return {
+    id: record.id || crypto.randomUUID(),
+    timestamp: record.timestamp || new Date().toISOString(),
+    prompt: record.prompt || '',
+    preset: record.preset || 'default',
+    isRefinement: Boolean(record.isRefinement),
+    isFastMode: Boolean(record.isFastMode),
+    candidates: Array.isArray(record.candidates)
+      ? record.candidates.map((c) => ({
+          provider: c.provider || '',
+          model: c.model || '',
+          filesCount: Array.isArray(c.files) ? c.files.length : (c.filesCount || 0),
+          usage: c.usage || { inputTokens: 0, outputTokens: 0 },
+          costUsd: Number(c.costUsd || 0),
+        }))
+      : [],
+    aggregator: record.aggregator
+      ? {
+          provider: record.aggregator.provider || '',
+          model: record.aggregator.model || '',
+          usage: record.aggregator.usage || { inputTokens: 0, outputTokens: 0 },
+          costUsd: Number(record.aggregator.costUsd || 0),
+        }
+      : null,
+    winnerIndex: typeof record.winnerIndex === 'number' ? record.winnerIndex : -1,
+    winnerModel: record.winnerModel || '',
+    promotedFiles: Array.isArray(record.promotedFiles) ? record.promotedFiles : [],
+    totalTokens: Number(record.totalTokens || 0),
+    totalCostUsd: Number(record.totalCostUsd || 0),
+    durationMs: Number(record.durationMs || 0),
+  }
+}
+
+/**
+ * Appends a completed MoA run record to the history file synchronously (preserves sync API).
+ * Performs automatic size-based rotation.
  */
 export function recordMoaRun(record, filePath = DEFAULT_HISTORY_FILE) {
   try {
@@ -29,37 +92,9 @@ export function recordMoaRun(record, filePath = DEFAULT_HISTORY_FILE) {
       fs.mkdirSync(dir, { recursive: true })
     }
 
-    const entry = {
-      id: record.id || crypto.randomUUID(),
-      timestamp: record.timestamp || new Date().toISOString(),
-      prompt: record.prompt || '',
-      preset: record.preset || 'default',
-      isRefinement: Boolean(record.isRefinement),
-      candidates: Array.isArray(record.candidates)
-        ? record.candidates.map((c) => ({
-            provider: c.provider || '',
-            model: c.model || '',
-            filesCount: Array.isArray(c.files) ? c.files.length : (c.filesCount || 0),
-            usage: c.usage || { inputTokens: 0, outputTokens: 0 },
-            costUsd: Number(c.costUsd || 0),
-          }))
-        : [],
-      aggregator: record.aggregator
-        ? {
-            provider: record.aggregator.provider || '',
-            model: record.aggregator.model || '',
-            usage: record.aggregator.usage || { inputTokens: 0, outputTokens: 0 },
-            costUsd: Number(record.aggregator.costUsd || 0),
-          }
-        : null,
-      winnerIndex: typeof record.winnerIndex === 'number' ? record.winnerIndex : -1,
-      winnerModel: record.winnerModel || '',
-      promotedFiles: Array.isArray(record.promotedFiles) ? record.promotedFiles : [],
-      totalTokens: Number(record.totalTokens || 0),
-      totalCostUsd: Number(record.totalCostUsd || 0),
-      durationMs: Number(record.durationMs || 0),
-    }
+    rotateHistoryFileIfNeeded(filePath)
 
+    const entry = normalizeRunRecord(record)
     const line = JSON.stringify(entry) + '\n'
     fs.appendFileSync(filePath, line, 'utf8')
     return entry
@@ -69,6 +104,26 @@ export function recordMoaRun(record, filePath = DEFAULT_HISTORY_FILE) {
   }
 }
 
+/**
+ * Asynchronously appends a completed MoA run record without blocking the event loop.
+ */
+export async function recordMoaRunAsync(record, filePath = DEFAULT_HISTORY_FILE) {
+  try {
+    const dir = path.dirname(filePath)
+    await fs.promises.mkdir(dir, { recursive: true }).catch(() => {})
+
+    rotateHistoryFileIfNeeded(filePath)
+
+    const entry = normalizeRunRecord(record)
+    const line = JSON.stringify(entry) + '\n'
+    await fs.promises.appendFile(filePath, line, 'utf8')
+    return entry
+  } catch (err) {
+    console.warn('[dsh-moa] Failed to async-record run to history:', err)
+    return null
+  }
+}
+
 /**
  * Reads history runs with pagination (latest first).
  */
@@ -144,7 +199,7 @@ export function getMoaLeaderboard(filePath = DEFAULT_HISTORY_FILE) {
             st.totalTokens += inTok + outTok
             st.totalCostUsd += Number(cand.costUsd || 0)
 
-            if (winner && (winner === key || winner === cand.model || winner.includes(cand.model))) {
+            if (winner && cand.model && (winner === key || winner === cand.model)) {
               st.wins += 1
             }
           }

package/lib/index.js

@@ -6,7 +6,7 @@ import { refreshCatalogInBackground } from './pricing.js'
  * 1. User issues /moa <prompt>
  * 2. Parallel candidate proposers write to isolated workspaces (.moa/candidate-X/)
  * 3. Aggregator evaluates and synthesizes the optimal solution
- * 4. Winner candidate files are promoted to the project root and previewed in Live Canvas
+ * 4. Winner candidate files are promoted to the project root
  * 5. Native cost tracking, history logging and leaderboard analytics
  */
 
@@ -25,6 +25,8 @@ import {
   getMoaRunById,
 } from './history.js'
 
+import { createLiveCanvasClient } from './live-canvas.js'
+
 export const name = 'dsh-moa'
 export const inject = ['webServer', 'llm', 'settings', 'sessions', 'tools']
 
@@ -45,13 +47,19 @@ export const PresetSchema = z.object({
   name: z.string(),
   enabled: z.boolean().default(true),
   ask_clarifying_questions: z.boolean().default(true),
+  curator_synthesis: z.boolean().default(false),
+  stream_aggregator: z.boolean().default(true),
+  quorum_enabled: z.boolean().default(false),
+  grace_period_sec: z.number().default(10),
   reference_models: z.array(ModelSlotSchema).default([]),
   aggregator: ModelSlotSchema.default({ provider: 'codex', model: 'gpt-5.6-sol' }),
+  aggregator_fallbacks: z.array(ModelSlotSchema).default([]),
   reference_temperature: z.number().default(0.6),
   aggregator_temperature: z.number().default(0.4),
+  reference_timeout_sec: z.number().default(60),
+  aggregator_timeout_sec: z.number().default(180),
   max_tokens: z.number().default(4096),
   judge_criteria: z.string().default(''),
-  judge_mode: z.string().default('auto'),
 })
 
 export const Config = z.object({
@@ -72,7 +80,6 @@ export const Config = z.object({
       aggregator_temperature: 0.4,
       max_tokens: 4096,
       judge_criteria: '',
-      judge_mode: 'auto',
     },
     {
       name: 'fast',
@@ -86,7 +93,6 @@ export const Config = z.object({
       aggregator_temperature: 0.2,
       max_tokens: 4096,
       judge_criteria: '',
-      judge_mode: 'auto',
     },
     {
       name: 'deep-reasoning',
@@ -100,8 +106,7 @@ export const Config = z.object({
       reference_temperature: 0.6,
       aggregator_temperature: 0.2,
       max_tokens: 8192,
-      judge_criteria: 'Приоритет: математическая строгость и отсутствие галлюцинаций',
-      judge_mode: 'auto',
+      judge_criteria: '',
     },
   ]),
 })
@@ -153,7 +158,7 @@ export function apply(ctx, config) {
   /**
    * Unified LLM dispatch function using ctx.llm.prepareCall / stream
    */
-  const callLlm = async ({ provider, model, messages, temperature = 0.6, maxTokens = 4096 }) => {
+  const callLlm = async ({ provider, model, messages, temperature = 0.6, maxTokens = 4096, timeoutMs, onStreamDelta }) => {
     if (!ctx.llm) {
       throw new Error('ctx.llm is not available in cordis context')
     }
@@ -177,8 +182,9 @@ export function apply(ctx, config) {
       throw new Error(`LLM provider/model ${provider}:${model} could not be prepared`)
     }
 
+    const effectiveTimeoutMs = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : 120000
     const abortCtrl = new AbortController()
-    const timeoutId = setTimeout(() => abortCtrl.abort(new Error('LLM call timeout')), 120000)
+    const timeoutId = setTimeout(() => abortCtrl.abort(new Error(`LLM call timeout after ${Math.round(effectiveTimeoutMs / 1000)}s`)), effectiveTimeoutMs)
     timeoutId.unref?.()
 
     try {
@@ -195,6 +201,9 @@ export function apply(ctx, config) {
       for await (const chunk of stream) {
         if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
           fullText += chunk.text
+          if (typeof onStreamDelta === 'function') {
+            onStreamDelta(chunk.text)
+          }
         } else if (chunk.type === 'block-end' && chunk.block?.text) {
           if (!fullText) fullText = chunk.block.text
         } else if (chunk.type === 'usage' && chunk.usage) {
@@ -217,6 +226,11 @@ export function apply(ctx, config) {
     }
   }
 
+  // Optional Live Canvas preview client: the harness port is resolved per
+  // call and any failure degrades to "no preview link" (live-canvas is not
+  // required to be installed).
+  const liveCanvas = createLiveCanvasClient({ getPort: () => ctx.webServer?.port })
+
   // Route: /dsh-moa/status
   ctx.effect(() => {
     return ctx.webServer.register({
@@ -342,23 +356,35 @@ export function apply(ctx, config) {
             const raw = await readBody(req)
             const payload = JSON.parse(raw)
             const newConfig = {
-              enabled: cfg.enabled !== false,
+              enabled: typeof payload.enabled === 'boolean' ? payload.enabled : cfg.enabled !== false,
               default_preset: payload.default_preset || cfg.default_preset || 'default',
               presets: Array.isArray(payload.presets) ? payload.presets : (cfg.presets || []),
             }
 
+            // Validate the merged payload through the plugin schema before it
+            // reaches the settings storage: malformed payloads must be
+            // rejected with 400 instead of being persisted.
+            let validated
+            try {
+              validated = Config(structuredClone(newConfig))
+            } catch (verr) {
+              writeJson(res, 400, { ok: false, error: 'Invalid presets payload: ' + (verr?.message || String(verr)) })
+              return
+            }
+
             // Persist via Cordis Settings API
             if (settingsScope && typeof settingsScope.replace === 'function') {
-              await settingsScope.replace(newConfig)
+              await settingsScope.replace(validated)
             } else {
               // In-memory fallback if settings service is unavailable
-              getConfig = () => newConfig
+              getConfig = () => validated
             }
 
             writeJson(res, 200, {
               ok: true,
-              defaultPreset: newConfig.default_preset,
-              presets: newConfig.presets,
+              enabled: validated.enabled !== false,
+              defaultPreset: validated.default_preset,
+              presets: validated.presets,
             })
           } catch (err) {
             writeJson(res, 400, { ok: false, error: err?.message || String(err) })
@@ -414,6 +440,29 @@ export function apply(ctx, config) {
     })
   }, 'dsh-moa: leaderboard route')
 
+  // Route: /dsh-moa/runs/<id> (run replay by id)
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'prefix',
+      path: '/dsh-moa/runs/',
+      handler: (req, res) => {
+        if (req.method !== 'GET') {
+          writeJson(res, 405, { ok: false, error: 'GET required' })
+          return
+        }
+        const urlPath = req.url.split('?')[0]
+        const parts = urlPath.split('/').filter(Boolean)
+        const runId = parts[2] || ''
+        const run = runId ? getMoaRunById(runId) : null
+        if (!run) {
+          writeJson(res, 404, { ok: false, error: 'Run not found' })
+          return
+        }
+        writeJson(res, 200, { ok: true, run })
+      },
+    })
+  }, 'dsh-moa: run by id route')
+
   // Route: /dsh-moa/run
   ctx.effect(() => {
     return ctx.webServer.register({
@@ -435,6 +484,10 @@ export function apply(ctx, config) {
           }
 
           const cfg = live()
+          if (cfg.enabled === false) {
+            writeJson(res, 400, { ok: false, error: 'MoA is disabled in settings' })
+            return
+          }
           const presetName = payload.preset || cfg.default_preset || 'default'
           const preset = (cfg.presets || []).find((p) => p.name === presetName) || cfg.presets?.[0]
 
@@ -444,6 +497,8 @@ export function apply(ctx, config) {
             preset,
             callLlm,
             cwd: payload.cwd || process.cwd(),
+            prices: cfg.prices || {},
+            liveCanvas,
           })
 
           writeJson(res, 200, { ok: true, ...result })
@@ -511,6 +566,8 @@ export function apply(ctx, config) {
           cwd: sessCwd,
           aggregator: { provider: aggProvider, model: aggModel },
           callLlm,
+          prices: cfg.prices || {},
+          liveCanvas,
         }
 
         if (event.signal) {

package/lib/live-canvas.js

@@ -0,0 +1,34 @@
+/**
+ * Optional Live Canvas preview client (@goodandready/dsh-live-canvas).
+ *
+ * The plugin posts the promoted HTML to live-canvas's own REST contract
+ * (POST /dsh-live-canvas/api/preview, served by the same harness webServer),
+ * so no cross-plugin service coupling or module imports are needed. Any
+ * failure — live-canvas not installed, endpoint missing, timeout, malformed
+ * response — degrades to null and the MoA answer simply carries no preview
+ * link, without errors in the harness log.
+ */
+export function createLiveCanvasClient({ getPort, fetchImpl = globalThis.fetch, timeoutMs = 3000 } = {}) {
+  if (typeof fetchImpl !== 'function') return null
+  return {
+    async createPreviewFromContent({ content, title, filePath } = {}) {
+      if (!content || typeof content !== 'string') return null
+      const port = typeof getPort === 'function' ? getPort() : getPort
+      if (!port) return null
+      try {
+        const res = await fetchImpl(`http://127.0.0.1:${port}/dsh-live-canvas/api/preview`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ content, title, filePath }),
+          signal: AbortSignal.timeout(timeoutMs),
+        })
+        if (!res.ok) return null
+        const data = await res.json()
+        if (!data || data.success !== true || !data.canvasId || !data.previewUrl) return null
+        return { canvasId: data.canvasId, previewUrl: data.previewUrl, title: title || 'Live Preview' }
+      } catch {
+        return null
+      }
+    },
+  }
+}

package/lib/moa-parser.js

@@ -0,0 +1,181 @@
+// lib/moa-parser.js
+// Parsers for model outputs, winner selection, commands, and code blocks for @goodandready/dsh-moa.
+
+/**
+ * Extracts candidate winner index from judge output.
+ * Looks for machine marker WINNER_CANDIDATE_INDEX: N first, then conversational fallbacks.
+ */
+export function parseWinnerIndex(judgeText, defaultIndex = 1, candidateCount = Infinity) {
+  if (!judgeText || typeof judgeText !== 'string') return defaultIndex
+  const inRange = (idx) => !isNaN(idx) && idx >= 1 && idx <= candidateCount
+  const match = /WINNER_CANDIDATE_INDEX:\s*(\d+)/i.exec(judgeText)
+  if (match) {
+    const idx = parseInt(match[1], 10)
+    if (inRange(idx)) return idx
+  }
+  const candMatch = /(?:Кандидат|Candidate|Reference)\s*(\d+)\b/i.exec(judgeText)
+  if (candMatch) {
+    const idx = parseInt(candMatch[1], 10)
+    if (inRange(idx)) return idx
+  }
+  return defaultIndex
+}
+
+/**
+ * Parses the recommended assembler model index and label from curator output.
+ */
+export function parseRecommendedAssembler(judgeText, defaultIndex = 1, candidateCount = Infinity) {
+  if (!judgeText || typeof judgeText !== 'string') return { index: defaultIndex, label: '' }
+  const inRange = (idx) => !isNaN(idx) && idx >= 1 && idx <= candidateCount
+  const match = /RECOMMENDED_ASSEMBLER:\s*(\d+)(?:\s*\(([^)]+)\))?/i.exec(judgeText)
+  if (match) {
+    const idx = parseInt(match[1], 10)
+    if (inRange(idx)) {
+      return { index: idx, label: match[2]?.trim() || '' }
+    }
+  }
+  return { index: defaultIndex, label: '' }
+}
+
+/**
+ * Parses a `/moa [preset] <prompt>` command invocation.
+ */
+export function parseMoACommand(text, presets = []) {
+  if (typeof text !== 'string' || !text.startsWith('/moa')) {
+    return null
+  }
+
+  const remainder = text.slice(4).trim()
+  if (!remainder) {
+    return {
+      presetName: 'default',
+      prompt: '',
+    }
+  }
+
+  const matchPreset = /^--preset(?:=|\s+)([a-zA-Z0-9_-]+)\s*(.*)/s.exec(remainder)
+  if (matchPreset) {
+    return {
+      presetName: matchPreset[1],
+      prompt: matchPreset[2] || '',
+    }
+  }
+
+  const parts = remainder.split(/\s+/)
+  const firstWord = parts[0]
+  if (Array.isArray(presets)) {
+    const matched = presets.find((p) => p.name === firstWord)
+    if (matched) {
+      return {
+        presetName: matched.name,
+        prompt: parts.slice(1).join(' ').trim(),
+      }
+    }
+  }
+
+  return {
+    presetName: 'default',
+    prompt: remainder,
+  }
+}
+
+/**
+ * Replaces large code blocks with concise file/code summaries to avoid token waste and huge chat dumps.
+ */
+export function stripOrSummarizeCode(text) {
+  if (!text || typeof text !== 'string') return ''
+  return text.replace(/```([a-zA-Z0-9_\-\.\/]*)\s*([\w\.\/\-]+\.[a-zA-Z0-9]+)?\n([\s\S]*?)```/g, (match, lang, fileTag, code) => {
+    const lines = code.trim().split('\n')
+    if (lines.length <= 3 && !/html|jsx|tsx|vue|svelte|css|js|ts/i.test(lang)) {
+      return match
+    }
+    const fileHint = fileTag || (code.match(/^\s*(?:\/\/|#|<!--|\/\*)\s*(?:file|filepath|path):\s*([^\s*]+)/im)?.[1])
+    const label = fileHint ? `file \`${fileHint}\`` : (lang ? `code \`${lang}\`` : 'code')
+    return `\n> 📄 *[${label} - ${lines.length} lines saved to disk]*\n`
+  })
+}
+
+/**
+ * Formats user-facing markdown response for synthesis, questions, and failure kinds.
+ */
+export function formatMoAResponse({ moaResult, presetName }) {
+  const parts = []
+  const pName = presetName || moaResult?.presetName || 'default'
+  const judge = moaResult?.aggregator || 'unknown'
+  const refs = moaResult?.references || []
+
+  if (moaResult?.kind === 'questions') {
+    parts.push('## 🧠 Mixture of Agents — Requirements Clarification')
+    parts.push(`*Judge (${judge}) and the advisors analyzed the task:*\n`)
+    parts.push(moaResult.content)
+    return parts.join('\n')
+  }
+
+  if (moaResult?.kind === 'failure') {
+    parts.push('## ⚠️ Mixture of Agents — Execution Failed')
+    parts.push(moaResult.content)
+    return parts.join('\n')
+  }
+
+  const modeBadge = moaResult?.isFastMode
+    ? '⚡ Fast Mode'
+    : (moaResult?.isCuratorSynthesis ? `🧠 Curator: ${judge}` : `Judge: ${judge}`)
+  parts.push(`## 🧠 Mixture of Agents (Preset: ${pName} | ${modeBadge})`)
+  parts.push('')
+
+  if (moaResult?.isRefinement) {
+    parts.push('> 🔄 **Mode**: Iterative project refinement (Refinement)')
+  }
+
+  const hasPromoted = moaResult?.promotedFiles && moaResult.promotedFiles.length > 0
+  if (hasPromoted) {
+    parts.push(`> 📦 **Files created in the project**: \`${moaResult.promotedFiles.join('`, `')}\``)
+  }
+
+  if (moaResult?.recommendedAssembler?.label) {
+    parts.push(`> 🎯 **Recommended Master Assembler**: Candidate ${moaResult.recommendedAssembler.index} (\`${moaResult.recommendedAssembler.label}\`)`)
+  }
+
+  if (moaResult?.liveCanvas?.previewUrl) {
+    parts.push(`> 🎨 **Live Canvas**: [🚀 Открыть ${moaResult.liveCanvas.title || 'превью'} в Live Canvas](${moaResult.liveCanvas.previewUrl}) | [↗ Открыть в новой вкладке](${moaResult.liveCanvas.previewUrl})`)
+  }
+
+  // Cost tracking card
+  if (moaResult?.usage) {
+    const u = moaResult.usage
+    const costStr = u.totalCostUsd > 0 ? `~\$${u.totalCostUsd.toFixed(4)}` : 'Free'
+    const tokStr = u.totalTokens >= 1000 ? `${(u.totalTokens / 1000).toFixed(1)}k` : `${u.totalTokens}`
+    parts.push(`> 💰 **Run cost**: ${costStr} (${tokStr} tokens total)`)
+  }
+
+  parts.push('')
+
+  if (!moaResult?.isFastMode) {
+    parts.push(`### ⚖️ Judge verdict and final synthesis (Synthesis: ${judge})`)
+    parts.push('')
+    const cleanJudgeContent = hasPromoted
+      ? stripOrSummarizeCode(moaResult?.content || '')
+      : (moaResult?.content || '(нет ответа)')
+    parts.push(cleanJudgeContent)
+    parts.push('')
+  }
+
+  if (Array.isArray(refs) && refs.length > 0) {
+    const title = moaResult?.isFastMode ? '### 🚀 Candidate generation result:' : `### 👥 Advisor responses (${refs.length}):`
+    parts.push(title)
+    parts.push('')
+    refs.forEach((ref, i) => {
+      const statusIcon = ref.ok ? '✅' : '⚠️'
+      const fileBadge = ref.files?.length ? ` (${ref.files.length} файл(ов))` : ''
+      const costBadge = ref.costUsd > 0 ? ` [~\$${ref.costUsd.toFixed(4)}]` : ''
+      parts.push(`#### ${statusIcon} Model ${i + 1}: ${ref.label}${fileBadge}${costBadge}`)
+      parts.push('')
+      parts.push(stripOrSummarizeCode(ref.text))
+      parts.push('')
+      parts.push('---')
+      parts.push('')
+    })
+  }
+
+  return parts.join('\n')
+}