@polderlabs/bizar 9.0.0 → 10.0.7

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

@@ -1,173 +0,0 @@
-/**
- * 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/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/routes/config.mjs

@@ -1,180 +0,0 @@
-/**
- * src/server/routes/config.mjs
- *
- * /api/config                           — read ~/.config/cline/cline.json
- * /api/config (PUT)                     — write cline.json
- * /api/config/reload (POST)             — re-read
- * /api/config/providers                 — list providers
- * /api/config/providers (POST)          — add
- * /api/config/providers/:id (PUT)       — update
- * /api/config/providers/:id (DELETE)    — remove
- * /api/config/providers/auto (POST)     — add with key, auto-discover models
- *                                          + apply systemLlm config
- * /api/config/mcps                      — list MCP servers
- * /api/config/mcps (POST)               — add
- * /api/config/mcps/:id (PUT)            — update
- * /api/config/mcps/:id (DELETE)         — remove
- *
- * Two stores are involved: the on-disk cline.json (read+write)
- * and the providersStore/mcpsStore in-memory registries. /api/config
- * is the former; /api/config/providers and /api/config/mcps are
- * the latter. /api/providers (without the config/ prefix) is the
- * dashboard's aggregated provider list and lives in providers.mjs.
- */
-import { Router } from 'express';
-import { existsSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import {
-  providersStore,
-  mcpsStore,
-  loadConfig,
-  saveConfig,
-} from '../providers-store.mjs';
-import { CLINE_JSON, atomicWriteJson, safeReadJSON, wrap } from './_shared.mjs';
-
-/**
- * @param {object} deps
- * @param {object} deps.state
- * @param {object} deps.watcher
- * @returns {import('express').Router}
- */
-export function createConfigRouter({ state, watcher }) {
-  const router = Router();
-
-  router.get('/config', wrap(async (_req, res) => {
-    const data = safeReadJSON(CLINE_JSON, null);
-    res.json({
-      path: CLINE_JSON,
-      data,
-      raw: data === null ? '' : JSON.stringify(data, null, 2),
-      exists: existsSync(CLINE_JSON),
-    });
-  }));
-
-  router.put('/config', wrap(async (req, res) => {
-    const body = req.body;
-    let parsed;
-    if (typeof body === 'string') {
-      try {
-        parsed = JSON.parse(body);
-      } catch (err) {
-        res.status(400).json({ error: 'invalid_json', message: err.message });
-        return;
-      }
-    } else if (body && typeof body === 'object') {
-      parsed = body;
-    } else {
-      res.status(400).json({ error: 'bad_request', message: 'body must be JSON' });
-      return;
-    }
-    mkdirSync(dirname(CLINE_JSON), { recursive: true });
-    atomicWriteJson(CLINE_JSON, parsed);
-    state.appendActivity({ kind: 'config.update' });
-    watcher.poke('change', CLINE_JSON);
-    res.json({ path: CLINE_JSON, data: parsed, exists: true, raw: JSON.stringify(parsed, null, 2) });
-  }));
-
-  router.post('/config/reload', wrap(async (_req, res) => {
-    const data = safeReadJSON(CLINE_JSON, null);
-    res.json({
-      path: CLINE_JSON,
-      data,
-      raw: data === null ? '' : JSON.stringify(data, null, 2),
-      exists: existsSync(CLINE_JSON),
-    });
-  }));
-
-  // ── /api/config/providers ─────────────────────────────────────────────
-  router.get('/config/providers', wrap(async (_req, res) => {
-    res.json({ providers: providersStore.list() });
-  }));
-
-  router.post('/config/providers', wrap(async (req, res) => {
-    const provider = providersStore.add(req.body || {});
-    res.status(201).json(provider);
-  }));
-
-  router.put('/config/providers/:id', wrap(async (req, res) => {
-    const provider = providersStore.update(req.params.id, req.body || {});
-    res.json(provider);
-  }));
-
-  router.delete('/config/providers/:id', wrap(async (req, res) => {
-    const ok = providersStore.remove(req.params.id);
-    if (!ok) {
-      res.status(404).json({ error: 'not_found' });
-      return;
-    }
-    res.status(204).end();
-  }));
-
-  // v4.4.14 — "Add with key" — the user pastes a key, we figure out the
-  // rest. Auto-discovers the live model list (probes /v1/models), writes
-  // the full provider block, and (if requested) applies the system LLM
-  // config so the rest of the dashboard's /api/llm/* calls hit this
-  // provider+model.
-  router.post('/config/providers/auto', wrap(async (req, res) => {
-    const body = req.body || {};
-    const result = await providersStore.addWithAuto({
-      id: typeof body.id === 'string' ? body.id.trim() : undefined,
-      name: typeof body.name === 'string' ? body.name.trim() : undefined,
-      apiKey: typeof body.apiKey === 'string' ? body.apiKey : '',
-      groupId: typeof body.groupId === 'string' ? body.groupId : 'default',
-      setAsSystemLlm: body.setAsSystemLlm !== false,
-      preferredModel: typeof body.preferredModel === 'string' ? body.preferredModel : undefined,
-      systemLlmModel: typeof body.systemLlmModel === 'string' ? body.systemLlmModel : undefined,
-    });
-    if (!result.ok) {
-      res.status(result.error === 'unknown_provider' ? 400 : 400).json(result);
-      return;
-    }
-    res.status(201).json(result);
-  }));
-
-  // ── /api/config/mcps ───────────────────────────────────────────────────
-  router.get('/config/mcps', wrap(async (_req, res) => {
-    res.json({ mcps: mcpsStore.list() });
-  }));
-
-  // v4.4.14 — System LLM settings. The dashboard reads / writes the
-  // cline.json#systemLlm block via this thin surface. The block
-  // controls which provider+model is used for the dashboard's own
-  // /api/llm/* calls (auto-title, enhance-prompt, summarization).
-  router.get('/llm/system-llm', wrap(async (_req, res) => {
-    const cfg = loadConfig();
-    res.json(cfg.systemLlm || { enabled: false, provider: null, model: null });
-  }));
-
-  router.put('/llm/system-llm', wrap(async (req, res) => {
-    const cfg = loadConfig();
-    const body = req.body || {};
-    cfg.systemLlm = {
-      enabled: body.enabled !== false,
-      provider: typeof body.provider === 'string' ? body.provider : (cfg.systemLlm?.provider || null),
-      model: typeof body.model === 'string' ? body.model : (cfg.systemLlm?.model || null),
-    };
-    saveConfig(cfg);
-    res.json(cfg.systemLlm);
-  }));
-
-  router.post('/config/mcps', wrap(async (req, res) => {
-    const mcp = mcpsStore.add(req.body || {});
-    res.status(201).json(mcp);
-  }));
-
-  router.put('/config/mcps/:id', wrap(async (req, res) => {
-    const mcp = mcpsStore.update(req.params.id, req.body || {});
-    res.json(mcp);
-  }));
-
-  router.delete('/config/mcps/:id', wrap(async (req, res) => {
-    const ok = mcpsStore.remove(req.params.id);
-    if (!ok) {
-      res.status(404).json({ error: 'not_found' });
-      return;
-    }
-    res.status(204).end();
-  }));
-
-  return router;
-}

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

@@ -1,50 +0,0 @@
-/**
- * src/server/routes/diagnostics.mjs
- *
- * /api/diagnostics                       — full snapshot
- * /api/diagnostics/health                — health check
- * /api/diagnostics/logs                  — tail of the active log file
- */
-import { Router } from 'express';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { diagnosticsStore } from '../diagnostics-store.mjs';
-import { BIZAR_HOME, wrap } from './_shared.mjs';
-
-/**
- * @returns {import('express').Router}
- */
-export function createDiagnosticsRouter() {
-  const router = Router();
-
-  router.get('/diagnostics', wrap(async (_req, res) => {
-    res.json(diagnosticsStore.snapshot());
-  }));
-
-  router.get('/diagnostics/health', wrap(async (_req, res) => {
-    res.json(diagnosticsStore.health());
-  }));
-
-  router.get('/diagnostics/logs', wrap(async (req, res) => {
-    const requestedTail = parseInt(String(req.query.tail || '100'), 10);
-    const tail = Math.min(5000, Math.max(1, Number.isFinite(requestedTail) ? requestedTail : 100));
-    const serviceLog = join(BIZAR_HOME, 'service.log');
-    const dashboardLog = join(BIZAR_HOME, 'dashboard.log');
-    // Prefer service.log, fall back to dashboard.log
-    const logFile = existsSync(serviceLog) ? serviceLog : existsSync(dashboardLog) ? dashboardLog : null;
-    if (!logFile) {
-      res.json({ lines: [], file: null, total: 0 });
-      return;
-    }
-    try {
-      const text = readFileSync(logFile, 'utf8');
-      const allLines = text.split(/\r?\n/).filter(Boolean);
-      const lines = allLines.slice(-tail);
-      res.json({ lines, file: logFile, total: allLines.length });
-    } catch (err) {
-      res.status(500).json({ error: 'read_failed', message: err.message });
-    }
-  }));
-
-  return router;
-}

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

@@ -1,86 +0,0 @@
-/**
- * src/server/routes/dialogs.mjs
- *
- * v3.9.0 — Dialog-request HTTP routes.
- *
- *   GET    /api/dialogs            — list recent dialog history (debug)
- *   GET    /api/dialogs/queue      — list currently-queued (undelivered) dialogs
- *   POST   /api/dialogs            — enqueue a dialog (used by the slash-command plugin)
- *   DELETE /api/dialogs/:id        — remove a dialog from the queue
- *
- * WIRING (REQUIRED — read carefully):
- *
- *   This router is OWNED BY THE DIALOG SCOPE (Tyr). The route is
- *   MOUNTED BY THE SLASH-COMMAND SIBLING SCOPE (Thor). Thor owns
- *   `server.mjs`; I do NOT modify that file.
- *
- *   When Thor lands, they need to add the following to `server.mjs`:
- *
- *     import { createDialogsRouter } from './routes/dialogs.mjs';
- *     import { startDialogPoller } from './dialog-poller.mjs';
- *
- *     // …inside createServer or whatever the bootstrap is…
- *     app.use(createDialogsRouter({ broadcast }));
- *     startDialogPoller();
- *
- *   Until that's done, the router is wired but unreachable and the
- *   poller never starts. This is intentional — sibling separation
- *   prevents both of us from racing on the same file.
- *
- *   Service-mode gap: `cli/service.mjs` also does NOT start the dialog
- *   poller. If you want slash-command dialogs to flow in a service-only
- *   deployment (no dashboard), add `startDialogPoller()` to
- *   `cli/service.mjs`. Out of scope for this PR.
- */
-import { Router } from 'express';
-import { dialogStore } from '../dialog-store.mjs';
-import { wrap } from './_shared.mjs';
-
-/**
- * @param {object} deps
- * @param {Function} deps.broadcast
- * @returns {import('express').Router}
- */
-export function createDialogsRouter({ broadcast }) {
-  const router = Router();
-
-  // Debug / introspection — what dialogs are currently queued?
-  router.get('/dialogs/queue', wrap(async (_req, res) => {
-    const queue = dialogStore.list();
-    res.json({ count: queue.length, queue });
-  }));
-
-  // Debug / history — what's been delivered recently? Since dialogs
-  // are one-shot and removed after broadcast, this endpoint returns
-  // the *currently queued* set as well; a true history view would
-  // need a separate append-only log (out of scope here).
-  router.get('/dialogs', wrap(async (_req, res) => {
-    const queue = dialogStore.list();
-    res.json({ dialogs: queue, dir: dialogStore.DIALOG_DIR });
-  }));
-
-  // Used by the slash-command plugin (Thor owns that, I just provide
-  // the route). The plugin POSTs the dialog descriptor and the route
-  // persists it; the poller picks it up on the next tick.
-  router.post('/dialogs', wrap(async (req, res) => {
-    const dialog = dialogStore.add(req.body || {});
-    // Best-effort immediate broadcast — the poller will re-broadcast on
-    // the next tick if this fails, but a successful immediate broadcast
-    // cuts latency to ~ms for already-connected dashboards.
-    try {
-      broadcast({ type: 'dialog:show', dialog });
-    } catch { /* best-effort */ }
-    res.status(201).json(dialog);
-  }));
-
-  router.delete('/dialogs/:id', wrap(async (req, res) => {
-    const ok = dialogStore.remove(req.params.id);
-    if (!ok) {
-      res.status(404).json({ error: 'not_found' });
-      return;
-    }
-    res.status(204).end();
-  }));
-
-  return router;
-}

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

@@ -1,82 +0,0 @@
-/**
- * src/server/routes/digests.mjs
- *
- * /api/digests                          — list digests
- * /api/digests/generate (POST)          — generate a digest
- * /api/digests/:path (GET)              — get a specific digest
- * /api/digests/:path (DELETE)           — delete a digest
- *
- * The `:path` parameter is URL-encoded so it survives Express routing.
- */
-import { Router } from 'express';
-import {
-  generateAndSave,
-  listDigests,
-  getDigest,
-  deleteDigest,
-} from '../digest-store.mjs';
-import { readActiveProjectId, wrap } from './_shared.mjs';
-
-/**
- * @param {object} deps
- * @param {object} [deps.projectRoot]
- * @returns {import('express').Router}
- */
-export function createDigestsRouter({ projectRoot } = {}) {
-  const router = Router();
-
-  // GET /api/digests — list all digests
-  router.get('/digests', wrap(async (req, res) => {
-    const limit = parseInt(req.query.limit, 10) || 20;
-    const digests = await listDigests({ limit });
-    res.json({ digests });
-  }));
-
-  // GET /api/digests/:path — get a single digest by path
-  // The path is double-encoded: first by the client, then by Express.
-  router.get('/digests/*', wrap(async (req, res) => {
-    // Reconstruct the path from the wildcard
-    const rawPath = req.params[0];
-    if (!rawPath) {
-      // This catches /api/digests with no trailing path (should be handled
-      // by the /digests route above, but Express may match this first if the
-      // wildcard is greedy — we handle the list case explicitly).
-      const digests = await listDigests({ limit: 20 });
-      res.json({ digests });
-      return;
-    }
-    const filePath = decodeURIComponent(rawPath);
-    const digest = await getDigest(filePath);
-    if (!digest) {
-      res.status(404).json({ error: 'not_found', message: 'Digest not found' });
-      return;
-    }
-    res.json(digest);
-  }));
-
-  // POST /api/digests/generate — generate a new digest
-  router.post('/digests/generate', wrap(async (req, res) => {
-    const { weekStart, weekEnd, dryRun } = req.body || {};
-    const root = req.body?.projectRoot || projectRoot || process.cwd();
-    const result = await generateAndSave({ weekStart, weekEnd, projectRoot: root, dryRun });
-    res.status(dryRun ? 200 : 201).json(result);
-  }));
-
-  // DELETE /api/digests/* — delete a digest by path
-  router.delete('/digests/*', wrap(async (req, res) => {
-    const rawPath = req.params[0];
-    if (!rawPath) {
-      res.status(400).json({ error: 'bad_request', message: 'Digest path required' });
-      return;
-    }
-    const filePath = decodeURIComponent(rawPath);
-    const result = await deleteDigest(filePath);
-    if (!result.ok) {
-      res.status(404).json({ error: 'not_found', message: result.error || 'Digest not found' });
-      return;
-    }
-    res.status(204).end();
-  }));
-
-  return router;
-}