@goodandready/dsh-moa 0.2.3 → 0.2.5

package/lib/index.js

@@ -1,218 +1,236 @@
-import os from 'node:os'
-import path from 'node:path'
-import z from '@deepseek-ai/schemastery'
-import { runMoAPipeline, parseMoACommand, formatMoAResponse, MoaRunnerAdapter } from './moa-runner.js'
+import { refreshCatalogInBackground } from './pricing.js'
+/**
+ * DeepSeek Harness Mixture of Agents (MoA) Plugin
+ *
+ * Implements an intelligent ensemble pipeline:
+ * 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
+ * 5. Native cost tracking, history logging and leaderboard analytics
+ */
 
-export const name = '@goodandready/dsh-moa'
-export const inject = ['settings', 'webServer', 'llm', 'credentials', 'sessions', 'agents']
-
-export { parseMoACommand }
+import z from '@deepseek-ai/schemastery'
+import path from 'node:path'
+import os from 'node:os'
+import {
+  parseMoACommand,
+  runMoAPipeline,
+  MoaRunnerAdapter,
+} from './moa-runner.js'
+
+import {
+  getMoaHistory,
+  getMoaLeaderboard,
+  getMoaRunById,
+} from './history.js'
+
+export const name = 'dsh-moa'
+export const inject = ['webServer', 'llm', 'settings', 'sessions', 'tools']
+
+export const NS = 'dsh-moa'
+
+export const PriceRow = z.object({
+  input: z.number().default(0),
+  output: z.number().default(0),
+  cacheHit: z.number().default(0),
+})
 
 export const ModelSlotSchema = z.object({
-  provider: z.string().default(''),
-  model: z.string().default(''),
+  provider: z.string().default('opencode-go'),
+  model: z.string().default('deepseek-v4-flash'),
 })
 
 export const PresetSchema = z.object({
-  name: z.string().default('default'),
+  name: z.string(),
   enabled: z.boolean().default(true),
-  reference_models: z.array(ModelSlotSchema).default([
-    { provider: 'opencode-go', model: 'deepseek-v4-flash' },
-    { provider: 'codex', model: 'gpt-5.6-sol' },
-  ]),
-  aggregator: ModelSlotSchema.default({
-    provider: 'antigravity',
-    model: 'gemini-3-flash',
-  }),
-  reference_temperature: z.number().step(0.05).min(0).max(2).default(0.6),
-  aggregator_temperature: z.number().step(0.05).min(0).max(2).default(0.4),
-  max_tokens: z.number().min(256).max(65536).default(4096),
+  reference_models: z.array(ModelSlotSchema).default([]),
+  aggregator: ModelSlotSchema.default({ provider: 'codex', model: 'gpt-5.6-sol' }),
+  reference_temperature: z.number().default(0.6),
+  aggregator_temperature: z.number().default(0.4),
+  max_tokens: z.number().default(4096),
+  judge_criteria: z.string().default(''),
+  judge_mode: z.string().default('auto'),
 })
 
 export const Config = z.object({
   enabled: z.boolean().default(true),
   default_preset: z.string().default('default'),
+  prices: z.dict(PriceRow).default({}),
   presets: z.array(PresetSchema).default([
     {
       name: 'default',
       enabled: true,
       reference_models: [
         { provider: 'opencode-go', model: 'deepseek-v4-flash' },
-        { provider: 'codex', model: 'gpt-5.6-sol' },
+        { provider: 'grok', model: 'grok-build-0.1' },
       ],
-      aggregator: {
-        provider: 'antigravity',
-        model: 'gemini-3-flash',
-      },
+      aggregator: { provider: 'codex', model: 'gpt-5.6-sol' },
       reference_temperature: 0.6,
       aggregator_temperature: 0.4,
       max_tokens: 4096,
+      judge_criteria: '',
+      judge_mode: 'auto',
+    },
+    {
+      name: 'fast',
+      enabled: true,
+      reference_models: [
+        { provider: 'opencode-go', model: 'deepseek-v4-flash' },
+      ],
+      aggregator: { provider: 'opencode-go', model: 'deepseek-v4-flash' },
+      reference_temperature: 0.6,
+      aggregator_temperature: 0.2,
+      max_tokens: 4096,
+      judge_criteria: '',
+      judge_mode: 'auto',
     },
     {
       name: 'deep-reasoning',
       enabled: true,
       reference_models: [
-        { provider: 'grok', model: 'grok-4.20-0309-reasoning' },
-        { provider: 'codex', model: 'gpt-5.6-terra' },
+        { provider: 'grok', model: 'grok-build-0.1' },
+        { provider: 'commandcode', model: 'deepseek/deepseek-v4-flash' },
       ],
-      aggregator: {
-        provider: 'antigravity',
-        model: 'gemini-3-flash',
-      },
-      reference_temperature: 0.7,
+      aggregator: { provider: 'codex', model: 'gpt-5.6-sol' },
+      reference_temperature: 0.6,
       aggregator_temperature: 0.2,
       max_tokens: 8192,
+      judge_criteria: 'Приоритет: математическая строгость и отсутствие галлюцинаций',
+      judge_mode: 'auto',
     },
   ]),
 })
 
-const NS = 'dsh-moa'
-
-function writeJson(res, code, data) {
-  try {
-    res.writeHead(code, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
-    res.end(JSON.stringify(data))
-  } catch {
-    /* socket closed */
-  }
+function writeJson(res, status, body) {
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store',
+  })
+  res.end(JSON.stringify(body))
 }
 
 function readBody(req) {
   return new Promise((resolve, reject) => {
-    const chunks = []
-    req.on('data', (c) => chunks.push(c))
-    req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')))
+    let acc = ''
+    req.on('data', (chunk) => {
+      acc += chunk
+      if (acc.length > 5 * 1024 * 1024) {
+        req.destroy()
+        reject(new Error('Payload Too Large'))
+      }
+    })
+    req.on('end', () => resolve(acc))
     req.on('error', reject)
   })
 }
 
-
 export function apply(ctx, config) {
-  let settingsApi = null
-  let currentConfig = structuredClone(config)
-
-  // Try reading persisted config from ~/.dsh/settings.yaml on load
-  try {
-    const fs = require('node:fs')
-    const yaml = require('yaml')
-    const p = path.join(os.homedir(), '.dsh', 'settings.yaml')
-    if (fs.existsSync(p)) {
-      const parsed = yaml.parse(fs.readFileSync(p, 'utf8'))
-      if (parsed && parsed[NS]) {
-        currentConfig = Config(parsed[NS])
-      }
-    }
-  } catch {}
+  refreshCatalogInBackground()
+
+  let settingsScope = null
+  let getConfig = () => config
+  const live = () => Config(structuredClone(getConfig() ?? {})) ?? config
 
   ctx.inject(['settings'], (sctx) => {
-    const scope = sctx.settings.register(NS, Config, { base: currentConfig })
-    settingsApi = scope
-    const val = scope.get()
-    if (val && Object.keys(val).length > 0) {
-      currentConfig = val
+    try {
+      const scope = sctx.settings.register(NS, Config, { base: config })
+      settingsScope = scope
+      getConfig = () => scope.get() ?? config
+      sctx.effect(() => () => {
+        settingsScope = null
+        getConfig = () => config
+      }, 'dsh-moa: settings')
+    } catch (e) {
+      console.warn('[dsh-moa] Settings registration warning:', e)
     }
-    sctx.effect(() => () => {
-      settingsApi = null
-    })
   })
 
-  const getConfig = () => {
-    if (settingsApi) {
-      const live = settingsApi.get()
-      if (live && live.presets && live.presets.length) return live
+  /**
+   * Unified LLM dispatch function using ctx.llm.prepareCall / stream
+   */
+  const callLlm = async ({ provider, model, messages, temperature = 0.6, maxTokens = 4096 }) => {
+    if (!ctx.llm) {
+      throw new Error('ctx.llm is not available in cordis context')
     }
-    return currentConfig || config
-  }
 
-  // Canonical collector for ctx.llm.stream chunk streams
-  const collectStreamText = async (iterable) => {
-    let out = ''
-    let sawDelta = false
-    for await (const chunk of iterable) {
-      if (chunk && chunk.type === 'text-delta' && typeof chunk.text === 'string') {
-        out += chunk.text
-        sawDelta = true
-      } else if (
-        !sawDelta && chunk && chunk.type === 'block-end' &&
-        chunk.block && chunk.block.type === 'text' && typeof chunk.block.text === 'string'
-      ) {
-        out += chunk.block.text
-      } else if (chunk && chunk.type === 'finish' && chunk.reason && chunk.reason.kind === 'error') {
-        throw new Error(chunk.reason.failure?.message || 'LLM stream failed')
+    let prep
+    try {
+      // DSH 0.1.2-rc.1 API expects { provider, model } object
+      prep = await ctx.llm.prepareCall({ provider, model })
+    } catch (err) {
+      if (typeof ctx.llm.prepareCall === 'function') {
+        try {
+          prep = await ctx.llm.prepareCall(provider, model)
+        } catch {
+          throw err
+        }
+      } else {
+        throw err
       }
     }
-    return out.trim()
-  }
-
-  // Adapter to ctx.llm.stream
-  const callLlm = async (params) => {
-    if (!ctx.llm || typeof ctx.llm.stream !== 'function') {
-      throw new Error('ctx.llm.stream service is not available')
+    if (!prep || typeof prep.stream !== 'function') {
+      throw new Error(`LLM provider/model ${provider}:${model} could not be prepared`)
     }
 
-    const { provider, model, messages, temperature, maxTokens, signal } = params
+    const abortCtrl = new AbortController()
+    const timeoutId = setTimeout(() => abortCtrl.abort(new Error('LLM call timeout')), 120000)
+    timeoutId.unref?.()
 
-    // Convert string/simple role messages to format expected by ctx.llm.stream
-    // Each message must have role, content (array of blocks or string), and source
-    const formattedMessages = (messages || []).map((m) => {
-      let content = m.content
-      if (typeof content === 'string') {
-        content = [{ type: 'text', text: content }]
-      } else if (Array.isArray(content)) {
-        content = content.map((b) => (typeof b === 'string' ? { type: 'text', text: b } : b))
-      } else {
-        content = [{ type: 'text', text: String(content || '') }]
-      }
+    try {
+      const stream = prep.stream({
+        messages,
+        temperature,
+        maxTokens,
+        signal: abortCtrl.signal,
+      })
 
-      const role = m.role || 'user'
-      const source = m.source || (role === 'assistant' ? { kind: 'model', provider, model } : { kind: 'user' })
+      let fullText = ''
+      let usageInfo = null
 
-      return {
-        role,
-        content,
-        source,
+      for await (const chunk of stream) {
+        if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
+          fullText += chunk.text
+        } else if (chunk.type === 'block-end' && chunk.block?.text) {
+          if (!fullText) fullText = chunk.block.text
+        } else if (chunk.type === 'usage' && chunk.usage) {
+          usageInfo = chunk.usage
+        }
       }
-    })
 
-    // Provider-specific parameter cleansing (Codex / reasoning models reject temperature, max_output_tokens, etc.)
-    const isCodexOrReasoning = provider === 'codex' || String(model).includes('sol') || String(model).includes('reasoner')
-    const streamOpts = {
-      provider,
-      model,
-      messages: formattedMessages,
-      ...(signal ? { signal } : {}),
-    }
-
-    if (!isCodexOrReasoning) {
-      if (temperature !== undefined) streamOpts.temperature = temperature
-      if (maxTokens !== undefined) streamOpts.maxTokens = maxTokens
+      clearTimeout(timeoutId)
+      return {
+        content: fullText,
+        text: fullText,
+        usage: usageInfo || {
+          inputTokens: Math.round(JSON.stringify(messages).length / 4),
+          outputTokens: Math.round(fullText.length / 4),
+        },
+      }
+    } catch (err) {
+      clearTimeout(timeoutId)
+      throw err
     }
-
-    const chunks = ctx.llm.stream(streamOpts)
-
-    return await collectStreamText(chunks)
   }
 
-  // HTTP endpoints
+  // Route: /dsh-moa/status
   ctx.effect(() => {
     return ctx.webServer.register({
       kind: 'exact',
       path: '/dsh-moa/status',
       handler: (_req, res) => {
-        const cfg = getConfig()
+        const cfg = live()
         writeJson(res, 200, {
           ok: true,
           enabled: cfg.enabled !== false,
           defaultPreset: cfg.default_preset || 'default',
-          hasCtxLlm: Boolean(ctx.llm),
-          llmKeys: ctx.llm ? Object.keys(ctx.llm) : [],
-          llmProto: ctx.llm ? Object.getOwnPropertyNames(Object.getPrototypeOf(ctx.llm)) : [],
           presetsCount: (cfg.presets || []).length,
         })
       },
     })
   }, 'dsh-moa: status route')
 
+  // Route: /dsh-moa/models
   ctx.effect(() => {
     return ctx.webServer.register({
       kind: 'exact',
@@ -221,43 +239,25 @@ export function apply(ctx, config) {
         const result = []
         const seen = new Set()
 
-        const add = (prov, mod, label) => {
-          if (!prov || !mod) return
-          const p = String(prov).trim()
-          const m = String(mod).trim()
+        const add = (p, m) => {
           if (!p || !m) return
           const key = `${p}:${m}`
-          if (seen.has(key)) return
-          seen.add(key)
-          result.push({ provider: p, model: m, label: label || key })
+          if (!seen.has(key)) {
+            seen.add(key)
+            result.push({ provider: p, model: m, label: key })
+          }
         }
 
-        // ONLY query REAL models from runtime adapters & settings. NO hardcoded fallbacks!
         if (ctx.llm) {
           try {
-            if (typeof ctx.llm.listProviders === 'function') {
-              const provList = ctx.llm.listProviders() || []
-              for (const p of provList) {
-                const pId = typeof p === 'string' ? p : (p.id || p.provider || p.name)
-                if (!pId) continue
-                if (typeof ctx.llm.listModels === 'function') {
-                  try {
-                    const mList = await ctx.llm.listModels(pId)
-                    for (const m of (mList || [])) {
-                      const mId = typeof m === 'string' ? m : (m.id || m.model || m.name)
-                      const mLabel = m.displayName || m.name || mId
-                      if (mId) add(pId, mId, `${pId}: ${mLabel}`)
-                    }
-                  } catch {}
-                }
-                for (const m of (p.models || [])) {
-                  const mId = typeof m === 'string' ? m : (m.id || m.model || m.name)
-                  if (mId) add(pId, mId)
-                }
+            if (typeof ctx.llm.listAvailableModels === 'function') {
+              const list = await ctx.llm.listAvailableModels()
+              for (const item of (list || [])) {
+                if (item?.provider && item?.id) add(item.provider, item.id)
               }
             }
           } catch (e) {
-            console.warn('[dsh-moa] ctx.llm.listProviders error:', e)
+            console.warn('[dsh-moa] ctx.llm.listAvailableModels error:', e)
           }
 
           try {
@@ -317,12 +317,13 @@ export function apply(ctx, config) {
     })
   }, 'dsh-moa: models route')
 
+  // Route: /dsh-moa/presets
   ctx.effect(() => {
     return ctx.webServer.register({
       kind: 'exact',
       path: '/dsh-moa/presets',
       handler: async (req, res) => {
-        const cfg = getConfig()
+        const cfg = live()
         if (req.method === 'GET') {
           writeJson(res, 200, {
             ok: true,
@@ -342,24 +343,12 @@ export function apply(ctx, config) {
               presets: Array.isArray(payload.presets) ? payload.presets : (cfg.presets || []),
             }
 
-            // 1. Persist via Cordis Settings API
-            if (settingsApi && typeof settingsApi.replace === 'function') {
-              await settingsApi.replace(newConfig)
-            }
-            currentConfig = newConfig
-
-            // 2. Direct persistence to ~/.dsh/settings.yaml
-            try {
-              const fs = await import('node:fs')
-              const yaml = await import('yaml')
-              const p = path.join(os.homedir(), '.dsh', 'settings.yaml')
-              if (fs.existsSync(p)) {
-                const curYaml = yaml.parse(fs.readFileSync(p, 'utf8')) || {}
-                curYaml[NS] = newConfig
-                fs.writeFileSync(p, yaml.stringify(curYaml), 'utf8')
-              }
-            } catch (fsErr) {
-              console.warn('[dsh-moa] direct file write error:', fsErr)
+            // Persist via Cordis Settings API
+            if (settingsScope && typeof settingsScope.replace === 'function') {
+              await settingsScope.replace(newConfig)
+            } else {
+              // In-memory fallback if settings service is unavailable
+              getConfig = () => newConfig
             }
 
             writeJson(res, 200, {
@@ -378,6 +367,50 @@ export function apply(ctx, config) {
     })
   }, 'dsh-moa: presets route')
 
+  // Route: /dsh-moa/history (#9)
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/history',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') {
+          writeJson(res, 405, { ok: false, error: 'GET required' })
+          return
+        }
+        try {
+          const u = new URL(req.url, 'http://localhost')
+          const limit = parseInt(u.searchParams.get('limit') || '20', 10)
+          const offset = parseInt(u.searchParams.get('offset') || '0', 10)
+          const data = getMoaHistory(limit, offset)
+          writeJson(res, 200, { ok: true, ...data })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
+        }
+      },
+    })
+  }, 'dsh-moa: history route')
+
+  // Route: /dsh-moa/leaderboard (#11)
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/leaderboard',
+      handler: async (req, res) => {
+        if (req.method !== 'GET') {
+          writeJson(res, 405, { ok: false, error: 'GET required' })
+          return
+        }
+        try {
+          const data = getMoaLeaderboard()
+          writeJson(res, 200, { ok: true, ...data })
+        } catch (err) {
+          writeJson(res, 500, { ok: false, error: err?.message || String(err) })
+        }
+      },
+    })
+  }, 'dsh-moa: leaderboard route')
+
+  // Route: /dsh-moa/run
   ctx.effect(() => {
     return ctx.webServer.register({
       kind: 'exact',
@@ -397,7 +430,7 @@ export function apply(ctx, config) {
             return
           }
 
-          const cfg = getConfig()
+          const cfg = live()
           const presetName = payload.preset || cfg.default_preset || 'default'
           const preset = (cfg.presets || []).find((p) => p.name === presetName) || cfg.presets?.[0]
 
@@ -429,7 +462,7 @@ export function apply(ctx, config) {
               ? lastUser.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n')
               : '')
 
-        const cfg = getConfig()
+        const cfg = live()
         const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: 'default' }
         const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
 
@@ -466,7 +499,7 @@ export function apply(ctx, config) {
           : '')
 
     if (userText.startsWith('/moa')) {
-      const cfg = getConfig()
+      const cfg = live()
       if (cfg.enabled !== false) {
         if (event.signal) {
           moaPendingSignals.add(event.signal)