@goodandready/dsh-moa 0.2.40 → 0.2.42

package/lib/history.js

@@ -41,7 +41,6 @@ export function getDefaultHistoryFile() {
   return path.join(getDefaultHistoryDir(), 'moa-history.jsonl')
 }
 
-
 /** Max history file size before rotation (10 MB) */
 export const MAX_HISTORY_BYTES = 10 * 1024 * 1024
 
@@ -77,6 +76,7 @@ export function rotateHistoryFileIfNeeded(filePath = getDefaultHistoryFile(), ma
 
 /**
  * Prepares a normalized history record entry.
+ * Preserves candidate persona, temperature, fallback, testResult, and slot details (#169).
  */
 function normalizeRunRecord(record) {
   return {
@@ -86,19 +86,33 @@ function normalizeRunRecord(record) {
     preset: record.preset || 'default',
     isRefinement: Boolean(record.isRefinement),
     isFastMode: Boolean(record.isFastMode),
+    cwd: record.cwd ? path.resolve(record.cwd) : undefined,
     candidates: Array.isArray(record.candidates)
-      ? record.candidates.map((c) => ({
-          provider: c.provider || '',
-          model: c.model || '',
+      ? record.candidates.map((c, idx) => ({
+          index: typeof c.index === 'number' ? c.index : (idx + 1),
+          provider: c.provider || c.slot?.provider || '',
+          model: c.model || c.slot?.model || '',
+          slot: c.slot ? { provider: c.slot.provider, model: c.slot.model } : (c.provider && c.model ? { provider: c.provider, model: c.model } : undefined),
+          role: c.role || c.role_persona || 'general',
+          temperature: typeof c.temperature === 'number' ? c.temperature : undefined,
+          wasFallback: Boolean(c.wasFallback || c.was_fallback),
+          originalModel: c.originalModel || c.original_model || null,
           filesCount: Array.isArray(c.files) ? c.files.length : (c.filesCount || 0),
+          files: Array.isArray(c.files) ? c.files : undefined,
           usage: c.usage || { inputTokens: 0, outputTokens: 0 },
           costUsd: Number(c.costUsd || 0),
+          testResult: c.testResult ? {
+            passed: Boolean(c.testResult.passed),
+            exitCode: c.testResult.exitCode ?? 0,
+            summary: c.testResult.summary || '',
+            durationMs: c.testResult.durationMs ?? 0,
+          } : null,
         }))
       : [],
     aggregator: record.aggregator
       ? {
-          provider: record.aggregator.provider || '',
-          model: record.aggregator.model || '',
+          provider: record.aggregator.provider || record.aggregator.slot?.provider || '',
+          model: record.aggregator.model || record.aggregator.slot?.model || '',
           usage: record.aggregator.usage || { inputTokens: 0, outputTokens: 0 },
           costUsd: Number(record.aggregator.costUsd || 0),
         }
@@ -162,6 +176,7 @@ export async function recordMoaRunAsync(record, filePath = getDefaultHistoryFile
 /**
  * Reads lines from the end of a file in reverse order in chunks.
  * Avoids loading multi-megabyte JSONL files into V8 heap strings.
+ * Buffer-safe: never splits multi-byte UTF-8 sequences at chunk boundaries (#184).
  */
 export function readTailLinesSync(filePath, countNeeded = 50) {
   const CHUNK_SIZE = 64 * 1024
@@ -169,7 +184,7 @@ export function readTailLinesSync(filePath, countNeeded = 50) {
   try {
     const stat = fs.fstatSync(fd)
     let pos = stat.size
-    let remainder = ''
+    let remainderBuf = Buffer.alloc(0)
     const collectedLines = []
 
     while (pos > 0 && collectedLines.length < countNeeded) {
@@ -177,29 +192,107 @@ export function readTailLinesSync(filePath, countNeeded = 50) {
       pos -= bytesToRead
       const buf = Buffer.alloc(bytesToRead)
       fs.readSync(fd, buf, 0, bytesToRead, pos)
-      const chunkStr = buf.toString('utf8') + remainder
-      const lines = chunkStr.split('\n')
-      if (pos > 0) {
-        remainder = lines.shift()
-      } else {
-        remainder = ''
+      const totalBuf = remainderBuf.length > 0 ? Buffer.concat([buf, remainderBuf]) : buf
+
+      let endIdx = totalBuf.length
+      for (let i = totalBuf.length - 1; i >= 0; i--) {
+        if (totalBuf[i] === 0x0A) {
+          if (i + 1 < endIdx) {
+            const lineBuf = totalBuf.subarray(i + 1, endIdx)
+            const lineStr = lineBuf.toString('utf8').trim()
+            if (lineStr) {
+              collectedLines.push(lineStr)
+              if (collectedLines.length >= countNeeded) break
+            }
+          }
+          endIdx = i
+        }
+      }
+
+      if (collectedLines.length >= countNeeded) {
+        remainderBuf = Buffer.alloc(0)
+        break
       }
 
-      for (let i = lines.length - 1; i >= 0; i--) {
-        const trimmed = lines[i].trim()
-        if (trimmed) {
-          collectedLines.push(trimmed)
-          if (collectedLines.length >= countNeeded) break
+      if (pos > 0) {
+        remainderBuf = totalBuf.subarray(0, endIdx)
+      } else {
+        if (endIdx > 0) {
+          const firstLineStr = totalBuf.subarray(0, endIdx).toString('utf8').trim()
+          if (firstLineStr && collectedLines.length < countNeeded) {
+            collectedLines.push(firstLineStr)
+          }
         }
+        remainderBuf = Buffer.alloc(0)
       }
     }
-    if (remainder && remainder.trim() && collectedLines.length < countNeeded) {
-      collectedLines.push(remainder.trim())
+
+    if (remainderBuf.length > 0 && collectedLines.length < countNeeded) {
+      const lineStr = remainderBuf.toString('utf8').trim()
+      if (lineStr) collectedLines.push(lineStr)
     }
+
     return collectedLines
   } finally {
-    fs.closeSync(fd)
+    try { fs.closeSync(fd) } catch { /* best effort */ }
+  }
+}
+
+/**
+ * Counts lines in a file by scanning for 0x0A newline bytes in chunks.
+ * Fast, memory-efficient, and caches result in _historyCache (#183).
+ */
+export function countFileLinesSync(filePath, stat) {
+  if (
+    _historyCache &&
+    _historyCache.filePath === filePath &&
+    _historyCache.mtimeMs === stat.mtimeMs &&
+    _historyCache.size === stat.size &&
+    typeof _historyCache.totalCount === 'number'
+  ) {
+    return _historyCache.totalCount
+  }
+
+  let count = 0
+  const fd = fs.openSync(filePath, 'r')
+  try {
+    const CHUNK_SIZE = 64 * 1024
+    const buf = Buffer.alloc(CHUNK_SIZE)
+    let pos = 0
+    let lastByte = 0
+    while (pos < stat.size) {
+      const bytesToRead = Math.min(CHUNK_SIZE, stat.size - pos)
+      fs.readSync(fd, buf, 0, bytesToRead, pos)
+      for (let i = 0; i < bytesToRead; i++) {
+        if (buf[i] === 0x0A) count++
+      }
+      lastByte = buf[bytesToRead - 1]
+      pos += bytesToRead
+    }
+    if (stat.size > 0 && lastByte !== 0x0A) {
+      count++
+    }
+  } finally {
+    try { fs.closeSync(fd) } catch { /* best effort */ }
   }
+
+  if (
+    !_historyCache ||
+    _historyCache.filePath !== filePath ||
+    _historyCache.mtimeMs !== stat.mtimeMs ||
+    _historyCache.size !== stat.size
+  ) {
+    _historyCache = {
+      filePath,
+      mtimeMs: stat.mtimeMs,
+      size: stat.size,
+      leaderboards: new Map(),
+      totalCount: count,
+    }
+  } else {
+    _historyCache.totalCount = count
+  }
+  return count
 }
 
 /**
@@ -220,6 +313,23 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
       const lines = raw.trim().split('\n').filter(Boolean)
       const total = lines.length
 
+      if (
+        !_historyCache ||
+        _historyCache.filePath !== filePath ||
+        _historyCache.mtimeMs !== stat.mtimeMs ||
+        _historyCache.size !== stat.size
+      ) {
+        _historyCache = {
+          filePath,
+          mtimeMs: stat.mtimeMs,
+          size: stat.size,
+          leaderboards: new Map(),
+          totalCount: total,
+        }
+      } else {
+        _historyCache.totalCount = total
+      }
+
       const sliced = lines
         .slice(Math.max(0, total - offset - limit), total - offset)
         .reverse()
@@ -250,7 +360,7 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
 
     let total = _historyCache?.totalCount
     if (typeof total !== 'number') {
-      total = tailLines.length >= needed ? Math.max(tailLines.length, Math.round(stat.size / 250)) : tailLines.length
+      total = tailLines.length < needed ? tailLines.length : countFileLinesSync(filePath, stat)
     }
 
     return { total, runs }
@@ -263,6 +373,7 @@ export function getMoaHistory(limit = 20, offset = 0, filePath = getDefaultHisto
 /**
  * Calculates win-rate leaderboard and model performance statistics across history.
  * Employs in-memory caching keyed by file mtime and size for O(1) repeated queries.
+ * Robust matching for aliases, fallbacks, and winnerIndex (#185).
  */
 export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options = {}) {
   try {
@@ -307,10 +418,15 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
         if (presetFilter && presetFilter !== 'all' && item.preset !== presetFilter) continue
         filteredRuns++
 
-        const winner = item.winnerModel ? String(item.winnerModel).trim() : null
+        const rawWinner = item.winnerModel ? String(item.winnerModel).trim() : null
+        const cleanWinner = rawWinner ? rawWinner.replace(/\s*\[fallback for .*\]$/i, '').trim() : null
+        const normWinner = cleanWinner && cleanWinner !== 'none' && cleanWinner !== 'unknown'
+          ? cleanWinner.replace(/[\/:]/g, ':').toLowerCase()
+          : null
 
         if (Array.isArray(item.candidates)) {
-          for (const cand of item.candidates) {
+          for (let candIdx = 0; candIdx < item.candidates.length; candIdx++) {
+            const cand = item.candidates[candIdx]
             const key = cand.provider && cand.model ? `${cand.provider}:${cand.model}` : (cand.model || 'unknown')
             if (!modelStats.has(key)) {
               modelStats.set(key, {
@@ -326,12 +442,25 @@ export function getMoaLeaderboard(filePath = getDefaultHistoryFile(), options =
             const st = modelStats.get(key)
             st.runs += 1
 
-            const inTok = cand.usage?.inputTokens || 0
-            const outTok = cand.usage?.outputTokens || 0
+            const inTok = cand.usage?.inputTokens ?? cand.usage?.totalInputTokens ?? cand.usage?.prompt_tokens ?? 0
+            const outTok = cand.usage?.outputTokens ?? cand.usage?.totalOutputTokens ?? cand.usage?.completion_tokens ?? 0
             st.totalTokens += inTok + outTok
             st.totalCostUsd += Number(cand.costUsd || 0)
 
-            if (winner && cand.model && (winner === key || winner === cand.model)) {
+            let isWin = false
+            if (normWinner) {
+              const normKey = key.replace(/[\/:]/g, ':').toLowerCase()
+              const normModel = String(cand.model || '').replace(/[\/:]/g, ':').toLowerCase()
+              if (normWinner === normKey || normWinner === normModel || normWinner.endsWith(`:${normModel}`)) {
+                isWin = true
+              }
+            }
+            if (!isWin && typeof item.winnerIndex === 'number' && item.winnerIndex > 0) {
+              if (cand.index === item.winnerIndex || candIdx === item.winnerIndex - 1) {
+                isWin = true
+              }
+            }
+            if (isWin) {
               st.wins += 1
             }
           }
@@ -433,22 +562,27 @@ export function exportMoaHistory(filePath = getDefaultHistoryFile(), options = {
   }
 }
 
+/**
+ * Formats candidate outputs for history storage (#169).
+ */
 export function candidatesForHistory(referenceOutputs) {
-  return (referenceOutputs || []).map((r) => ({
-    provider: r.slot?.provider || "",
-    model: r.slot?.model || "",
+  return (referenceOutputs || []).map((r, i) => ({
+    index: r.index ?? (i + 1),
+    provider: r.slot?.provider || r.provider || "",
+    model: r.slot?.model || r.model || "",
+    slot: r.slot ? { provider: r.slot.provider, model: r.slot.model } : undefined,
     role: r.role_persona || r.slot?.role_persona || r.slot?.role || "general",
     temperature: r.temperature,
     wasFallback: Boolean(r.was_fallback),
     originalModel: r.original_model || null,
-    files: (r.files || []).map((f) => f.relativePath),
+    files: (r.files || []).map((f) => f.relativePath || f),
     usage: r.usage || { inputTokens: 0, outputTokens: 0 },
     costUsd: r.costUsd || 0,
     testResult: r.testResult ? {
-      passed: r.testResult.passed,
-      exitCode: r.testResult.exitCode,
-      summary: r.testResult.summary,
-      durationMs: r.testResult.durationMs,
+      passed: Boolean(r.testResult.passed),
+      exitCode: r.testResult.exitCode ?? 0,
+      summary: r.testResult.summary || '',
+      durationMs: r.testResult.durationMs ?? 0,
     } : null,
   }))
 }

package/lib/index.js

@@ -12,6 +12,7 @@ import { createLlmCaller } from './moa-llm.js'
 import {
   parseMoACommand,
   streamMoATurn,
+  streamPromoteTurn,
 } from './moa-runner.js'
 import { registerMoaRoutes } from './routes.js'
 import { resolvePresetForPrompt } from './moa-router.js'
@@ -174,6 +175,20 @@ export function apply(ctx, config) {
         if (cfg.enabled !== false) {
           const effectiveDefault = cfg.default_preset || 'default'
           const parsed = parseMoACommand(userText, cfg.presets || [], effectiveDefault) || { prompt: userText, presetName: effectiveDefault, isExplicit: false }
+          if (parsed.isPromote) {
+            const sessCwd = event.cwd || event.session?.cwd || (event.session?.path ? path.dirname(event.session.path) : undefined) || process.cwd()
+            const turnContext = {
+              isPromoteTurn: true,
+              runId: parsed.runId,
+              candidateIndex: parsed.candidateIndex,
+              cwd: sessCwd,
+              webServerPort: ctx.webServer?.port,
+              timeMachineEngine: ctx.reflect?.get?.('timeMachineEngine', false),
+            }
+            if (event.signal) moaPendingTurns.set(event.signal, turnContext)
+            if (event.session?.id) setSessionTurn(event.session.id, turnContext)
+            return next()
+          }
           const isExplicitPreset = Boolean(parsed.isExplicit || userText.includes('--preset') || userText.includes('-p '))
           if (!isExplicitPreset && (cfg.smart_routing_enabled || cfg.presets?.some((p) => p.smart_routing_enabled))) {
             try {
@@ -234,11 +249,11 @@ export function apply(ctx, config) {
       const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
         || (payload.session?.id ? getSessionTurn(payload.session.id) : null)
 
-      if (turnContext) {
+      if (turnContext && !turnContext.isPromoteTurn) {
         return {
           ...resolved,
-          provider: turnContext.aggregator.provider,
-          model: turnContext.aggregator.model,
+          provider: turnContext.aggregator?.provider || resolved.provider,
+          model: turnContext.aggregator?.model || resolved.model,
         }
       }
       return resolved
@@ -254,6 +269,9 @@ export function apply(ctx, config) {
         if (options.signal) moaPendingTurns.delete(options.signal)
         if (options.session?.id) consumeSessionTurn(options.session.id)
 
+        if (turnContext.isPromoteTurn) {
+          return streamPromoteTurn(turnContext, options)
+        }
         return streamMoATurn(turnContext, options)
       }
 

package/lib/live-canvas.js

@@ -1,17 +1,50 @@
 import path from "node:path"
+import fs from "node:fs/promises"
 
-export async function createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs) {
+export async function createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, options = {}) {
   if (!liveCanvas || typeof liveCanvas.createPreviewFromContent !== "function") return null
   const htmlRel = (promotedFiles || []).find((f) => f.endsWith(".html") || f.endsWith(".htm"))
   if (!htmlRel) return null
+
   let content = null
-  for (const r of referenceOutputs || []) {
-    const block = (r?.files || []).find((f) => f.relativePath === htmlRel)
-    if (block?.content) {
-      content = block.content
-      break
+
+  // 1. Try reading directly from disk in cwd (the promoted winner or curator synthesis)
+  if (cwd) {
+    try {
+      const fullPath = path.resolve(cwd, htmlRel)
+      content = await fs.readFile(fullPath, "utf8")
+    } catch {
+      content = null
+    }
+  }
+
+  // 2. Fallback to synthesized files / winning files
+  if (!content) {
+    const winningFiles = options.winningFiles || options.synthesizedFiles
+    if (Array.isArray(winningFiles)) {
+      const block = winningFiles.find((f) => f.relativePath === htmlRel)
+      if (block?.content) content = block.content
+    }
+  }
+
+  // 3. Fallback to winning candidate by index
+  if (!content && typeof options.winningIndex === 'number' && referenceOutputs) {
+    const winnerRef = referenceOutputs[options.winningIndex - 1]
+    const block = (winnerRef?.files || []).find((f) => f.relativePath === htmlRel)
+    if (block?.content) content = block.content
+  }
+
+  // 4. Fallback to searching referenceOutputs
+  if (!content) {
+    for (const r of referenceOutputs || []) {
+      const block = (r?.files || []).find((f) => f.relativePath === htmlRel)
+      if (block?.content) {
+        content = block.content
+        break
+      }
     }
   }
+
   if (!content) return null
   try {
     return await liveCanvas.createPreviewFromContent({ content, title: htmlRel, filePath: path.join(cwd, htmlRel) })