@polderlabs/bizar 8.1.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/distill.mjs

@@ -0,0 +1,129 @@
+/**
+ * src/server/routes/distill.mjs
+ *
+ * v6.4.0 — F-033 / ADR-174.
+ *
+ * REST surface for the ReasoningBank distillation pipeline.
+ *
+ *   POST /api/distill
+ *     Triggers a single RETRIEVE → JUDGE → DISTILL → CONSOLIDATE run
+ *     over the current vault. Optional JSON body:
+ *       { "since": "<iso8601>" }
+ *     Returns the consolidation result (same shape as the SDK
+ *     `memory_distill` MCP tool plus the in-file path).
+ *
+ *   GET /api/distill/patterns
+ *     Reads the most recent `.bizar/distilled-patterns.json` and
+ *     returns its `patterns` array (filtered by `?tier=` and
+ *     `?promoted=` query params). 404 if the file does not yet
+ *     exist (a distillation run hasn't happened).
+ *
+ *   GET /api/distill/status
+ *     Returns a small status object:
+ *       { file: "<path or null>", patternCount, promotedCount, byTier, generatedAt }
+ *
+ * Mounted at /api/distill/*. The route itself is `Router()`-style so
+ * it composes with the rest of the v3 dashboard API.
+ */
+
+import { Router } from 'express';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+const SERVER_ROOT = join(dirname(new URL(import.meta.url).pathname), '..');
+const memoryConsolidator = await import(`${SERVER_ROOT}/memory-consolidator.mjs`).then((m) => m);
+
+const { wrap } = await import('./_shared.mjs').then((m) => m);
+
+/**
+ * Build the distill router. `projectRoot` is the Bizar repo root — it
+ * defaults to `process.cwd()` so that `bizar dashboard --dev` "just
+ * works" when launched from inside a Bizar project.
+ */
+export function createDistillRouter({ projectRoot } = {}) {
+  const root = projectRoot ?? process.cwd();
+  const router = Router();
+
+  // ---------------------------------------------------------------------
+  // POST /api/distill — run the pipeline.
+  // ---------------------------------------------------------------------
+  router.post('/distill', wrap(async (req, res) => {
+    const since = typeof req.body?.since === 'string' ? req.body.since : undefined;
+    const result = memoryConsolidator.runConsolidation({ projectRoot: root, since });
+
+    // Side-effect: write the machine-readable log so the GET route
+    // can serve it without re-running the pipeline.
+    const filePath = memoryConsolidator.writeDistilledPatternsFile(result, {
+      projectRoot: root,
+    });
+
+    res.json({
+      distilled: result.distilled,
+      promoted: result.promoted,
+      patterns: result.patterns,
+      byTier: result.byTier,
+      written: result.written,
+      file: filePath,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/patterns — return the patterns.
+  // ---------------------------------------------------------------------
+  router.get('/distill/patterns', wrap(async (req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.status(404).json({ error: 'not_distilled_yet', file: fp });
+      return;
+    }
+    const raw = readFileSync(fp, 'utf-8');
+    let payload;
+    try { payload = JSON.parse(raw); }
+    catch (e) { res.status(500).json({ error: 'corrupt_distill_file', message: String(e) }); return; }
+
+    let patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+
+    const tier = typeof req.query.tier === 'string' ? req.query.tier : null;
+    if (tier) patterns = patterns.filter((p) => p.provenance_tier === tier);
+
+    const promoted = req.query.promoted === 'true'
+      ? true
+      : req.query.promoted === 'false'
+      ? false
+      : null;
+    if (promoted !== null) patterns = patterns.filter((p) => Boolean(p.promoted) === promoted);
+
+    res.json({
+      generatedAt: payload.generatedAt,
+      byTier: payload.byTier,
+      patterns,
+      count: patterns.length,
+    });
+  }));
+
+  // ---------------------------------------------------------------------
+  // GET /api/distill/status — small status object.
+  // ---------------------------------------------------------------------
+  router.get('/distill/status', wrap(async (_req, res) => {
+    const fp = join(root, memoryConsolidator.DISTILLED_PATTERNS_FILE);
+    if (!existsSync(fp)) {
+      res.json({ file: null, patternCount: 0, promotedCount: 0, byTier: null, generatedAt: null });
+      return;
+    }
+    try {
+      const payload = JSON.parse(readFileSync(fp, 'utf-8'));
+      const patterns = Array.isArray(payload.patterns) ? payload.patterns : [];
+      res.json({
+        file: fp,
+        patternCount: patterns.length,
+        promotedCount: patterns.filter((p) => Boolean(p.promoted)).length,
+        byTier: payload.byTier,
+        generatedAt: payload.generatedAt,
+      });
+    } catch (e) {
+      res.status(500).json({ error: 'corrupt_distill_file', message: String(e) });
+    }
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/doctor.mjs

@@ -0,0 +1,71 @@
+/**
+ * src/server/routes/doctor.mjs
+ *
+ * v6.0.0 — Doctor REST surface for the dashboard Doctor page.
+ *
+ *   GET  /api/doctor         — full system snapshot (collectDiagnostics)
+ *   GET  /api/doctor/health  — rolled-up status + per-group issues
+ *   POST /api/doctor/check   — run a single named check
+ *
+ * Mounted at /doctor by api.mjs. Existing /api/diagnostics/* routes
+ * (legacy v3) are untouched and keep using `diagnosticsStore.snapshot()`
+ * / `.health()`.
+ */
+import { Router } from 'express';
+import { wrap } from './_shared.mjs';
+import { collectDiagnostics, runCheck, health } from '../diagnostics-store.mjs';
+import { info } from '../logger.mjs';
+
+/**
+ * @returns {import('express').Router}
+ */
+export function createDoctorRouter() {
+  const router = Router();
+
+  // GET /api/doctor — full snapshot. Bounded by the underlying
+  // `collectDiagnostics()` (recentErrors is capped at 50, checks at
+  // ~12 entries, agent file list at directory size).
+  router.get('/', wrap(async (_req, res) => {
+    const snap = await collectDiagnostics();
+    info('doctor.snapshot', { status: snap.health.status, issues: snap.health.issues.length });
+    res.json(snap);
+  }));
+
+  // GET /api/doctor/health — rolled-up health. Cheap; the Doctor
+  // page polls this on every auto-refresh tick (30s) and only
+  // fetches the full snapshot when the user clicks "Refresh".
+  router.get('/health', wrap(async (_req, res) => {
+    const result = await health();
+    res.json(result);
+  }));
+
+  // POST /api/doctor/check — run a single named check.
+  //
+  // Body: `{ checkName: string }`.
+  //
+  // Returns the single check on success, or `{ status: 'fail',
+  // message: 'unknown check', error: '...' }` with HTTP 404 when
+  // the name doesn't match any registered check. The dashboard
+  // surfaces the message inline so the operator can fix the
+  // underlying issue without leaving the Doctor page.
+  router.post('/check', wrap(async (req, res) => {
+    const checkName = String(req.body?.checkName || '').trim();
+    if (!checkName) {
+      res.status(400).json({
+        status: 'fail',
+        name: '',
+        message: 'checkName required',
+        error: 'POST body must include { checkName: string }',
+      });
+      return;
+    }
+    const result = await runCheck(checkName);
+    if (result.status === 'fail' && result.message === 'unknown check') {
+      res.status(404).json(result);
+      return;
+    }
+    res.json(result);
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/env-vars.mjs

@@ -0,0 +1,231 @@
+/**
+ * src/server/routes/env-vars.mjs
+ *
+ * v2 — Bizar env vars stored in ~/.config/bizar/env.json (mode 0600).
+ *
+ * Endpoints:
+ *   GET    /api/env-vars           — list all (masked values)
+ *   POST   /api/env-vars           — create {name, value}
+ *   PUT    /api/env-vars/:name     — update {value}
+ *   DELETE /api/env-vars/:name     — remove + delete from process.env
+ *   POST   /api/env-vars/:name/test — {referenced, inProcessEnv}
+ *   POST   /api/env-vars/bulk-import — {ok, imported, skipped, errors[]}
+ *   GET    /api/env-vars/export    — text/plain .env format
+ *   GET    /api/env-vars/grouped   — { "BIZAR_*": [...], "PROVIDER_*": [...] }
+ *
+ * Name must match /^BIZAR_[A-Z0-9_]+$/.
+ * On startup, loadEnvJson() sets process.env[name] = value for every entry.
+ */
+import { Router } from 'express';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+import { wrap } from './_shared.mjs';
+
+const HOME = homedir();
+const BIZAR_DIR = join(HOME, '.config', 'bizar');
+const ENV_FILE = join(BIZAR_DIR, 'env.json');
+
+// Lazy-load store
+let _store = null;
+
+function readStore() {
+  if (_store !== null) return _store;
+  if (!existsSync(ENV_FILE)) {
+    _store = {};
+    return _store;
+  }
+  try {
+    _store = JSON.parse(readFileSync(ENV_FILE, 'utf8')) || {};
+  } catch {
+    _store = {};
+  }
+  return _store;
+}
+
+function writeStore(store) {
+  mkdirSync(BIZAR_DIR, { recursive: true });
+  const tmp = `${ENV_FILE}.tmp.${process.pid}`;
+  writeFileSync(tmp, JSON.stringify(store, null, 2) + '\n', { mode: 0o600 });
+  renameSync(tmp, ENV_FILE);
+  _store = store;
+}
+
+/**
+ * Load env.json into process.env at startup.
+ * Called once from server.mjs after createApiRouter().
+ */
+export function loadEnvJson() {
+  const store = readStore();
+  for (const [name, entry] of Object.entries(store)) {
+    if (name.startsWith('BIZAR_')) {
+      process.env[name] = entry.value;
+    }
+  }
+}
+
+/** Reset in-memory store — used by tests to ensure isolation between test cases. */
+export function resetStore() {
+  _store = null;
+}
+
+/** Mask a value — return last 4 chars, prefixed with ***. */
+function mask(value) {
+  if (!value || value.length <= 4) return '****';
+  return '*'.repeat(Math.max(0, value.length - 4)) + value.slice(-4);
+}
+
+const NAME_RE = /^BIZAR_[A-Z0-9_]+$/;
+
+export function createEnvVarsRouter() {
+  const router = Router();
+
+  // GET /api/env-vars — list all (masked)
+  router.get('/env-vars', wrap(async (_req, res) => {
+    const store = readStore();
+    const list = Object.entries(store).map(([name, entry]) => ({
+      name,
+      value: mask(entry.value),
+      createdAt: entry.createdAt,
+      source: entry.source,
+    }));
+    res.json(list);
+  }));
+
+  // POST /api/env-vars — create
+  router.post('/env-vars', wrap(async (req, res) => {
+    const { name, value } = req.body || {};
+    if (!name || typeof name !== 'string') {
+      res.status(400).json({ error: 'name_required', message: 'name is required' });
+      return;
+    }
+    if (!NAME_RE.test(name)) {
+      res.status(400).json({
+        error: 'invalid_name',
+        message: 'name must match /^BIZAR_[A-Z0-9_]+$/',
+      });
+      return;
+    }
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (store[name]) {
+      res.status(409).json({ error: 'already_exists', message: `${name} already exists` });
+      return;
+    }
+    const entry = { value, createdAt: new Date().toISOString(), source: 'dashboard' };
+    store[name] = entry;
+    writeStore(store);
+    process.env[name] = value;
+    res.status(201).json({ name, value: mask(value), createdAt: entry.createdAt, source: entry.source });
+  }));
+
+  // PUT /api/env-vars/:name — update
+  router.put('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const { value } = req.body || {};
+    if (!value || typeof value !== 'string') {
+      res.status(400).json({ error: 'value_required', message: 'value is required' });
+      return;
+    }
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    store[name] = { ...store[name], value };
+    writeStore(store);
+    process.env[name] = value;
+    res.json({ name, value: mask(value), createdAt: store[name].createdAt, source: store[name].source });
+  }));
+
+  // DELETE /api/env-vars/:name — remove
+  router.delete('/env-vars/:name', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    if (!store[name]) {
+      res.status(404).json({ error: 'not_found', message: `${name} not found` });
+      return;
+    }
+    delete store[name];
+    writeStore(store);
+    delete process.env[name];
+    res.json({ ok: true });
+  }));
+
+  // POST /api/env-vars/:name/test — check if referenced
+  router.post('/env-vars/:name/test', wrap(async (req, res) => {
+    const { name } = req.params;
+    const store = readStore();
+    const inProcessEnv = name in process.env;
+    // Conservative: we don't statically analyze code, so referenced = inProcessEnv for now
+    res.json({ referenced: inProcessEnv, inProcessEnv });
+  }));
+
+  // POST /api/env-vars/bulk-import — parse KEY=value lines
+  router.post('/env-vars/bulk-import', wrap(async (req, res) => {
+    const { envContent } = req.body || {};
+    if (typeof envContent !== 'string') {
+      res.status(400).json({ error: 'envContent_required', message: 'envContent string is required' });
+      return;
+    }
+    const lines = envContent.split('\n');
+    const store = readStore();
+    let imported = 0;
+    let skipped = 0;
+    const errors = [];
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#')) { skipped++; continue; }
+      const eqIdx = trimmed.indexOf('=');
+      if (eqIdx < 1) { errors.push(`Invalid line (no '='): ${trimmed.slice(0, 40)}`); skipped++; continue; }
+      const rawName = trimmed.slice(0, eqIdx).trim();
+      const value = trimmed.slice(eqIdx + 1);
+      if (!NAME_RE.test(rawName)) { errors.push(`Invalid name: ${rawName}`); skipped++; continue; }
+      const name = rawName.toUpperCase();
+      if (store[name]) { errors.push(`Already exists (skipping): ${name}`); skipped++; continue; }
+      const entry = { value, createdAt: new Date().toISOString(), source: 'bulk-import' };
+      store[name] = entry;
+      process.env[name] = value;
+      imported++;
+    }
+
+    if (imported > 0) writeStore(store);
+    res.json({ ok: true, imported, skipped, errors });
+  }));
+
+  // GET /api/env-vars/export — return .env format
+  router.get('/env-vars/export', wrap(async (_req, res) => {
+    const store = readStore();
+    const lines = [];
+    for (const [name, entry] of Object.entries(store)) {
+      lines.push(`${name}=${entry.value}`);
+    }
+    res.setHeader('Content-Type', 'text/plain');
+    res.setHeader('Content-Disposition', 'attachment; filename=".env"');
+    res.send(lines.join('\n'));
+  }));
+
+  // GET /api/env-vars/grouped — return vars grouped by prefix
+  router.get('/env-vars/grouped', wrap(async (_req, res) => {
+    const store = readStore();
+    const groups = {};
+    for (const [name, entry] of Object.entries(store)) {
+      // Extract second-level prefix: BIZAR_EXT_A -> EXT_, BIZAR_PROVIDER_KEY -> PROVIDER_
+      const m = name.match(/^BIZAR_([A-Z0-9]+_)/);
+      const prefix = m ? m[1] : name;
+      (groups[prefix] ??= []).push({
+        name,
+        value: mask(entry.value),
+        createdAt: entry.createdAt,
+        source: entry.source,
+      });
+    }
+    res.json(groups);
+  }));
+
+  return router;
+}

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/eval.mjs

@@ -0,0 +1,187 @@
+/**
+ * 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, toCSV } from '../eval.mjs';
+import { saveRun, listRuns, getRun, compareRuns, buildRunId, registerEvalSchedule, listEvalSchedules, deleteEvalSchedule } 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/runs/:id/export.csv — download run results as CSV
+  router.get('/eval/runs/:id/export.csv', 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;
+    }
+    const csv = toCSV(run.results || []);
+    res.set('Content-Type', 'text/csv; charset=utf-8');
+    res.set('Content-Disposition', `attachment; filename="eval-${req.params.id}.csv"`);
+    res.send(csv);
+  }));
+
+  // 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);
+  }));
+
+  // GET /api/eval/schedules — list all eval schedules
+  router.get('/eval/schedules', wrap(async (req, res) => {
+    const schedules = await listEvalSchedules();
+    res.json({ schedules });
+  }));
+
+  // POST /api/eval/schedules — create a new eval schedule
+  router.post('/eval/schedules', wrap(async (req, res) => {
+    const { name, suitePath, cron, agent } = req.body || {};
+    if (!name || !suitePath || !cron) {
+      res.status(400).json({ error: 'bad_request', message: 'name, suitePath, and cron are required' });
+      return;
+    }
+    const schedule = await registerEvalSchedule({ name, suitePath, cron, agent });
+    res.status(201).json(schedule);
+  }));
+
+  // DELETE /api/eval/schedules/:id — delete an eval schedule
+  router.delete('/eval/schedules/:id', wrap(async (req, res) => {
+    const result = await deleteEvalSchedule(req.params.id);
+    if (!result.ok) {
+      res.status(404).json({ error: 'not_found', message: `schedule ${req.params.id} not found` });
+      return;
+    }
+    res.json({ ok: true });
+  }));
+
+  return router;
+}