@polderlabs/bizar 4.8.0 → 5.0.0

package/bizar-dash/src/server/routes/eval.mjs

@@ -0,0 +1,147 @@
+/**
+ * src/server/routes/eval.mjs
+ *
+ * v5.0.0 — REST surface for the eval framework.
+ *
+ * Endpoints:
+ *   GET  /api/eval/runs                — list recent runs
+ *   GET  /api/eval/runs/:id           — get run details
+ *   POST /api/eval/run                — run a suite
+ *   GET  /api/eval/runs/:id/compare/:otherId — diff two runs
+ *   GET  /api/eval/fixtures           — list fixtures in a suite path
+ *
+ * The llmCall defaults to minimax.chatCompletion but can be overridden
+ * via the state for custom providers.
+ */
+import { Router } from 'express';
+import { loadFixtures, runFixture, runSuite } from '../eval.mjs';
+import { saveRun, listRuns, getRun, compareRuns, buildRunId } from '../eval-store.mjs';
+import { chatCompletion } from '../minimax.mjs';
+import { wrap } from './_shared.mjs';
+
+/**
+ * @param {object} deps
+ * @param {object} deps.state
+ * @param {Function} deps.broadcast
+ * @returns {import('express').Router}
+ */
+export function createEvalRouter({ state, broadcast }) {
+  const router = Router();
+
+  // GET /api/eval/runs — list recent runs
+  router.get('/eval/runs', wrap(async (req, res) => {
+    const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+    const runs = await listRuns({ limit });
+    res.json({ runs });
+  }));
+
+  // GET /api/eval/runs/:id — get run details
+  router.get('/eval/runs/:id', wrap(async (req, res) => {
+    const run = await getRun(req.params.id);
+    if (!run) {
+      res.status(404).json({ error: 'not_found', message: `run ${req.params.id} not found` });
+      return;
+    }
+    res.json(run);
+  }));
+
+  // GET /api/eval/fixtures — list fixtures in a suite path
+  router.get('/eval/fixtures', wrap(async (req, res) => {
+    const { path: suitePath } = req.query;
+    if (!suitePath || typeof suitePath !== 'string') {
+      res.status(400).json({ error: 'bad_request', message: 'query.path is required' });
+      return;
+    }
+    const fixtures = loadFixtures(suitePath);
+    res.json({ fixtures });
+  }));
+
+  // POST /api/eval/run — run a suite
+  router.post('/eval/run', wrap(async (req, res) => {
+    const { suitePath, fixtures: fixtureIds, concurrency = 5, agent = 'thor' } = req.body || {};
+
+    if (!suitePath || typeof suitePath !== 'string') {
+      res.status(400).json({ error: 'bad_request', message: 'suitePath is required' });
+      return;
+    }
+
+    // Build the llmCall — use minimax by default, allow state override
+    const llmCall = async (prompt, opts = {}) => {
+      // Check if state has a custom eval LLM provider
+      const customCall = state?.getSettings?.()?.eval?.llmCall;
+      if (customCall) {
+        return customCall(prompt, opts);
+      }
+      // Default: minimax chatCompletion
+      const result = await chatCompletion({ prompt, model: 'MiniMax-M3' });
+      if (!result.ok) {
+        throw new Error(result.message || 'llm call failed');
+      }
+      return {
+        content: result.content,
+        usage: {
+          inputTokens: result.usage?.prompt_tokens ?? 0,
+          outputTokens: result.usage?.completion_tokens ?? 0,
+          totalTokens: result.usage?.total_tokens ?? 0,
+        },
+      };
+    };
+
+    const runId = buildRunId();
+    const startedAt = new Date().toISOString();
+
+    // Load fixtures
+    let fixtures = loadFixtures(suitePath);
+    if (fixtureIds?.length) {
+      fixtures = fixtures.filter((f) => fixtureIds.includes(f.id));
+    }
+
+    if (fixtures.length === 0) {
+      res.status(400).json({ error: 'bad_request', message: 'no fixtures found in suite' });
+      return;
+    }
+
+    // Broadcast start
+    broadcast({ type: 'eval:run:start', runId, total: fixtures.length });
+
+    // Run the suite
+    const suiteResult = await runSuite(suitePath, {
+      llmCall,
+      concurrency,
+      timeoutMs: 120_000,
+    });
+
+    const finishedAt = new Date().toISOString();
+    const run = {
+      id: runId,
+      startedAt,
+      finishedAt,
+      suitePath,
+      total: suiteResult.total,
+      passed: suiteResult.passed,
+      failed: suiteResult.failed,
+      results: suiteResult.results,
+    };
+
+    // Persist
+    await saveRun(run);
+
+    // Broadcast complete
+    broadcast({ type: 'eval:run:complete', runId, passed: run.passed, failed: run.failed });
+
+    res.status(201).json(run);
+  }));
+
+  // GET /api/eval/runs/:id/compare/:otherId — diff two runs
+  router.get('/eval/runs/:id/compare/:otherId', wrap(async (req, res) => {
+    const { id, otherId } = req.params;
+    const diff = await compareRuns(id, otherId);
+    if (diff.error) {
+      res.status(404).json({ error: 'not_found', message: diff.error });
+      return;
+    }
+    res.json(diff);
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/memory.mjs

@@ -1149,6 +1149,52 @@ export function createMemoryRouter({ projectRoot }) {
     }
   }));
 
+  // GET /memory/graph — combined knowledge graph (LightRAG entities + Obsidian wikilinks).
+  // Query params: ?root=<noteId>&depth=2&limit=200
+  router.get('/memory/graph', wrap(async (req, res) => {
+    const root = req.query.root ? String(req.query.root) : null;
+    const depth = Math.min(parseInt(req.query.depth, 10) || 2, 3);
+    const limit = Math.min(parseInt(req.query.limit, 10) || 200, 500);
+
+    try {
+      const lightrag = await getMemoryLightrag();
+      const [lrGraph, obsidianGraph] = await Promise.all([
+        lightrag.getLightRAGGraph({ projectRoot, root, depth, limit }),
+        (async () => {
+          try {
+            const { getObsidianLinkGraph } = memoryStore;
+            return getObsidianLinkGraph({ projectRoot, limit });
+          } catch {
+            return { nodes: [], edges: [] };
+          }
+        })(),
+      ]);
+
+      // Dedupe nodes by id; prefer the lightrag node (has richer type/size).
+      const nodeMap = new Map();
+      for (const n of obsidianGraph.nodes) nodeMap.set(n.id, n);
+      for (const n of lrGraph.nodes) {
+        if (!nodeMap.has(n.id)) nodeMap.set(n.id, n);
+      }
+      const nodes = [...nodeMap.values()].slice(0, limit);
+
+      // Merge edges from both sources; deduplicate by source+target.
+      const edgeSet = new Set();
+      const edges = [];
+      for (const e of [...obsidianGraph.edges, ...lrGraph.edges]) {
+        const key = `${e.source}|${e.target}`;
+        if (!edgeSet.has(key)) {
+          edgeSet.add(key);
+          edges.push(e);
+        }
+      }
+
+      res.json({ nodes, edges, totalNodes: nodes.length, totalEdges: edges.length });
+    } catch (err) {
+      res.status(500).json({ error: 'graph_failed', message: err.message });
+    }
+  }));
+
   // POST /memory/lightrag/reindex — alias of /memory/reindex (the canonical
   // path lives there for backwards compat). Both return the same shape.
   router.post('/memory/lightrag/reindex', wrap(async (_req, res) => {

package/bizar-dash/src/server/routes/ocr.mjs

@@ -0,0 +1,182 @@
+/**
+ * src/server/routes/ocr.mjs
+ *
+ * v5.0.0 — Screenshot OCR endpoints.
+ *
+ * Accepts image uploads, extracts text via Tesseract.js, and saves
+ * the result as a markdown note in the vault.
+ */
+
+import { Router } from 'express';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync } from 'node:fs';
+
+let _wrap = null;
+let _extractText = null;
+async function getShared() {
+  if (!_wrap) {
+    const mod = await import('./_shared.mjs');
+    _wrap = mod.wrap;
+  }
+  return { wrap: _wrap };
+}
+
+async function getOcr() {
+  if (!_extractText) {
+    const mod = await import('../ocr.mjs');
+    _extractText = mod.extractText;
+  }
+  return { extractText: _extractText };
+}
+
+function getLogPath(projectRoot) {
+  return join(projectRoot, '.bizar', 'ocr-log.json');
+}
+
+function loadLog(projectRoot) {
+  try {
+    const p = getLogPath(projectRoot);
+    if (!existsSync(p)) return [];
+    return JSON.parse(readFileSync(p, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+function saveLog(projectRoot, log) {
+  const p = getLogPath(projectRoot);
+  mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+  writeFileSync(p, JSON.stringify(log, null, 2) + '\n', 'utf8');
+}
+
+function appendLog(projectRoot, entry) {
+  const log = loadLog(projectRoot);
+  log.unshift(entry);
+  if (log.length > 100) log.length = 100;
+  saveLog(projectRoot, log);
+}
+
+export async function createOcrRouter({ projectRoot }) {
+  const router = Router();
+  const { wrap } = await getShared();
+
+  /**
+   * POST /api/ocr/process
+   *
+   * Accepts a multipart image upload, runs OCR, saves the result
+   * as a markdown note under ocr/<slug>.md.
+   *
+   * Expects: multipart/form-data with field "image"
+   * Returns: { ok, text, notePath }
+   */
+  router.post('/ocr/process', wrap(async (req, res) => {
+    let extractText;
+    try {
+      ({ extractText } = await getOcr());
+    } catch (err) {
+      res.status(503).json({
+        error: 'ocr_unavailable',
+        message: 'OCR engine is not available. Install tesseract.js: npm install tesseract.js',
+      });
+      return;
+    }
+
+    // Read image from body (binary or base64) or multipart
+    let imageBuffer = null;
+
+    if (Buffer.isBuffer(req.body)) {
+      imageBuffer = req.body;
+    } else if (req.body && req.body.image) {
+      // Base64-encoded image
+      const raw = req.body.image;
+      const matches = raw.match(/^data:image\/(png|jpeg|jpg|gif|webp);base64,(.+)$/);
+      if (matches) {
+        imageBuffer = Buffer.from(matches[2], 'base64');
+      } else {
+        // Assume raw base64 without prefix
+        imageBuffer = Buffer.from(raw, 'base64');
+      }
+    }
+
+    if (!imageBuffer || imageBuffer.length === 0) {
+      res.status(400).json({
+        error: 'bad_request',
+        message: 'No image data provided. Send multipart/form-data with "image" field, or JSON with base64 "image" field.',
+      });
+      return;
+    }
+
+    // Validate size (max 20MB)
+    if (imageBuffer.length > 20 * 1024 * 1024) {
+      res.status(413).json({ error: 'too_large', message: 'Image exceeds 20MB limit' });
+      return;
+    }
+
+    // Run OCR
+    let text;
+    try {
+      text = await extractText(imageBuffer);
+    } catch (err) {
+      res.status(500).json({
+        error: 'ocr_error',
+        message: `OCR processing failed: ${err instanceof Error ? err.message : String(err)}`,
+      });
+      return;
+    }
+
+    // Build note
+    const lang = req.body?.lang || 'eng';
+    const timestamp = Date.now();
+    const slug = `screenshot_ocr_${timestamp}`;
+    const relPath = `ocr/${slug}.md`;
+    const savedAt = new Date().toISOString();
+
+    const fm = {
+      title: `OCR Screenshot — ${savedAt}`,
+      savedAt,
+      type: 'ocr',
+      lang,
+      tags: ['ocr', 'screenshot'],
+    };
+
+    const noteBody = [
+      '## Extracted Text',
+      '',
+      '```text',
+      text || '(no text found)',
+      '```',
+      '',
+    ].join('\n');
+
+    const vaultDir = join(projectRoot, '.obsidian');
+    mkdirSync(join(vaultDir, 'ocr'), { recursive: true });
+    const notePath = join(vaultDir, relPath);
+
+    const noteContent = [
+      '---',
+      ...Object.entries(fm).map(([k, v]) => `${k}: ${JSON.stringify(v)}`),
+      '---',
+      '',
+      noteBody,
+    ].join('\n');
+
+    writeFileSync(notePath, noteContent, 'utf8');
+
+    // Log
+    appendLog(projectRoot, { id: slug, notePath: relPath, savedAt, textLength: text.length });
+
+    res.status(201).json({ ok: true, text, notePath: relPath, id: slug });
+  }));
+
+  /**
+   * GET /api/ocr/list
+   *
+   * Returns recent OCR entries from the log.
+   */
+  router.get('/ocr/list', wrap(async (_req, res) => {
+    const entries = loadLog(projectRoot);
+    res.json({ entries });
+  }));
+
+  return router;
+}

package/bizar-dash/src/server/routes/opencode-sessions.mjs

@@ -26,10 +26,12 @@
  */
 
 import { Router } from 'express';
+import { SpanStatusCode } from '@opentelemetry/api';
 import Database from 'better-sqlite3';
 import { join } from 'node:path';
 import { homedir } from 'node:os';
 import { wrap } from './_shared.mjs';
+import { tracer } from '../otel.mjs';
 import {
   readServeInfo,
   listOpencodeSessions,
@@ -118,58 +120,90 @@ export function createOpencodeSessionsRouter() {
   // Returns 503 when the opencode plugin is offline.
   // ────────────────────────────────────────────────────────────────────
   router.post('/opencode-sessions/new', wrap(async (req, res) => {
-    const body = req.body && typeof req.body === 'object' ? req.body : {};
-    const title = typeof body.title === 'string' && body.title.trim().length > 0
-      ? body.title.trim().slice(0, TITLE_MAX)
-      : null;
-    const agent = typeof body.agent === 'string' ? body.agent.trim() : '';
-    if (!agent) {
-      res.status(400).json({ error: 'bad_request', message: '`agent` is required' });
-      return;
-    }
-    if (!AGENT_NAME_RE.test(agent)) {
-      res.status(400).json({ error: 'bad_request', message: '`agent` is invalid (allowed: [A-Za-z0-9_-]{1,64})' });
-      return;
-    }
-    if (title !== null && title.length > TITLE_MAX) {
-      res.status(400).json({ error: 'bad_request', message: `title too long (> ${TITLE_MAX} chars)` });
-      return;
-    }
+    return tracer.startActiveSpan('opencode.session.create', async (span) => {
+      let spanEnded = false;
+      const finishSpan = () => {
+        if (spanEnded) return;
+        spanEnded = true;
+        try {
+          const code = res.statusCode || 0;
+          if (code >= 400) {
+            span.setStatus({ code: SpanStatusCode.ERROR, message: `HTTP ${code}` });
+          } else {
+            span.setStatus({ code: SpanStatusCode.OK });
+          }
+        } finally {
+          span.end();
+        }
+      };
+      res.once('finish', finishSpan);
+      try {
+        const body = req.body && typeof req.body === 'object' ? req.body : {};
+        const title = typeof body.title === 'string' && body.title.trim().length > 0
+          ? body.title.trim().slice(0, TITLE_MAX)
+          : null;
+        const agent = typeof body.agent === 'string' ? body.agent.trim() : '';
+        span.setAttribute('opencode.session.agent', agent);
+        span.setAttribute('opencode.session.title_length', title === null ? 0 : title.length);
+        if (!agent) {
+          res.status(400).json({ error: 'bad_request', message: '`agent` is required' });
+          return;
+        }
+        if (!AGENT_NAME_RE.test(agent)) {
+          res.status(400).json({ error: 'bad_request', message: '`agent` is invalid (allowed: [A-Za-z0-9_-]{1,64})' });
+          return;
+        }
+        if (title !== null && title.length > TITLE_MAX) {
+          res.status(400).json({ error: 'bad_request', message: `title too long (> ${TITLE_MAX} chars)` });
+          return;
+        }
 
-    const info = readServeInfo();
-    if (!info) {
-      res.status(503).json({
-        error: 'plugin_offline',
-        message: 'opencode plugin is not running',
-      });
-      return;
-    }
+        const info = readServeInfo();
+        if (!info) {
+          res.status(503).json({
+            error: 'plugin_offline',
+            message: 'opencode plugin is not running',
+          });
+          return;
+        }
 
-    const directory = typeof body.directory === 'string' && body.directory.length > 0
-      ? body.directory
-      : (info.worktree || '');
+        const directory = typeof body.directory === 'string' && body.directory.length > 0
+          ? body.directory
+          : (info.worktree || '');
+        span.setAttribute('opencode.session.directory', directory);
 
-    const finalTitle = title || `Chat: ${agent}`;
-    const result = await createOpencodeSession(
-      info,
-      { title: finalTitle, agent },
-      directory,
-    );
-    if (!result.ok || !result.sessionId) {
-      const status = result.status === 404 ? 404 : 502;
-      res.status(status).json({
-        error: 'opencode_error',
-        message: result.error || 'failed to create opencode session',
-      });
-      return;
-    }
+        const finalTitle = title || `Chat: ${agent}`;
+        const result = await createOpencodeSession(
+          info,
+          { title: finalTitle, agent },
+          directory,
+        );
+        if (!result.ok || !result.sessionId) {
+          const status = result.status === 404 ? 404 : 502;
+          res.status(status).json({
+            error: 'opencode_error',
+            message: result.error || 'failed to create opencode session',
+          });
+          return;
+        }
 
-    res.status(201).json({
-      id: result.sessionId,
-      title: finalTitle,
-      agent,
-      directory,
-      createdAt: Date.now(),
+        span.setAttribute('opencode.session.id', result.sessionId);
+        res.status(201).json({
+          id: result.sessionId,
+          title: finalTitle,
+          agent,
+          directory,
+          createdAt: Date.now(),
+        });
+      } catch (err) {
+        if (!spanEnded) {
+          spanEnded = true;
+          span.recordException(err);
+          span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+          span.end();
+        }
+        throw err;
+      }
     });
   }));