@polderlabs/bizar 4.9.0 → 5.0.0

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

@@ -0,0 +1,173 @@
+/**
+ * src/server/routes/clipboard.mjs
+ *
+ * v5.0.0 — Web Clipper endpoints.
+ *
+ * Accepts content pasted from the browser extension or bookmarklet,
+ * saves it as a markdown note in the vault with YAML frontmatter.
+ */
+
+import { Router } from 'express';
+import { join } from 'node:path';
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, existsSync, rmSync } from 'node:fs';
+
+let _wrap = null;
+async function getShared() {
+  if (!_wrap) {
+    const mod = await import('./_shared.mjs');
+    _wrap = mod.wrap;
+  }
+  return { wrap: _wrap };
+}
+
+/**
+ * In-memory logs for recent clips. Persisted to a JSON file for reboot survival.
+ */
+function getLogPath(projectRoot) {
+  return join(projectRoot, '.bizar', 'clipboard-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; // keep last 100
+  saveLog(projectRoot, log);
+}
+
+function deleteLogEntry(projectRoot, id) {
+  const log = loadLog(projectRoot);
+  const idx = log.findIndex((e) => e.id === id);
+  if (idx === -1) return false;
+  log.splice(idx, 1);
+  saveLog(projectRoot, log);
+  return true;
+}
+
+export async function createClipboardRouter({ projectRoot }) {
+  const router = Router();
+  const { wrap } = await getShared();
+
+  /**
+   * POST /api/clipboard/save
+   *
+   * Accepts { url, title, content, selection?, savedAt? }
+   * Saves a markdown note to the vault at clips/<slug>.md
+   */
+  router.post('/clipboard/save', wrap(async (req, res) => {
+    const { url, title, content, selection, savedAt } = req.body || {};
+    if (!url && !content) {
+      res.status(400).json({ error: 'bad_request', message: 'url or content is required' });
+      return;
+    }
+
+    // Build a safe slug from the title or URL
+    const slugBase = (title || url || 'clip')
+      .replace(/^https?:\/\//, '')
+      .replace(/[^a-zA-Z0-9_\- ]/g, '')
+      .trim()
+      .substring(0, 60)
+      .replace(/\s+/g, '_')
+      .toLowerCase() || 'clip';
+
+    const timestamp = Date.now();
+    const slug = `${slugBase}_${timestamp}`;
+    const relPath = `clips/${slug}.md`;
+
+    // Build frontmatter
+    const noteTitle = title || 'Web Clip';
+    const fm = {
+      title: noteTitle,
+      url: url || '',
+      savedAt: savedAt || new Date().toISOString(),
+      type: 'webclip',
+      tags: ['webclip'],
+    };
+
+    // Build body
+    const body = [
+      selection ? `> ${selection.replace(/\n/g, '\n> ')}` : '',
+      '',
+      '## Source',
+      '',
+      `- **URL**: ${url || '(no URL)'}`,
+      `- **Date**: ${fm.savedAt}`,
+      '',
+      '## Content',
+      '',
+      '```html',
+      (content || '').substring(0, 50000),
+      '```',
+      '',
+    ].join('\n');
+
+    // Write to vault
+    const vaultDir = join(projectRoot, '.obsidian');
+    mkdirSync(join(vaultDir, 'clips'), { recursive: true });
+    const notePath = join(vaultDir, relPath);
+
+    const noteContent = [
+      '---',
+      ...Object.entries(fm).map(([k, v]) => `${k}: ${JSON.stringify(v)}`),
+      '---',
+      '',
+      body,
+    ].join('\n');
+
+    writeFileSync(notePath, noteContent, 'utf8');
+
+    // Log for recent-clips listing
+    const entry = {
+      id: slug,
+      title: noteTitle,
+      url,
+      notePath: relPath,
+      savedAt: fm.savedAt,
+    };
+    appendLog(projectRoot, entry);
+
+    res.status(201).json({ ok: true, notePath: relPath, id: slug });
+  }));
+
+  /**
+   * GET /api/clipboard/list
+   *
+   * Returns recent clips from the log.
+   */
+  router.get('/clipboard/list', wrap(async (_req, res) => {
+    const clips = loadLog(projectRoot);
+    res.json({ clips });
+  }));
+
+  /**
+   * DELETE /api/clipboard/:id
+   *
+   * Remove a clip from the log (does not delete the note file).
+   */
+  router.delete('/clipboard/:id', wrap(async (req, res) => {
+    const { id } = req.params;
+    const ok = deleteLogEntry(projectRoot, id);
+    if (!ok) {
+      res.status(404).json({ error: 'not_found', message: `clip ${id} not found` });
+      return;
+    }
+    res.json({ ok: true });
+  }));
+
+  return router;
+}

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/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;
+}