@polderlabs/bizar 4.5.0 → 4.5.2

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

@@ -523,6 +523,157 @@ export function validateAll(projectRoot) {
   return results;
 }
 
+// ── v4.7.0 — Memory tab helpers ─────────────────────────────────────────────
+//
+// Lightweight helpers used by the dedicated Memory view: backlinks (wikilink
+// reverse index) and a vault-stats summary for the overview card.
+
+/**
+ * Find every note in the vault that links TO `targetRelPath` via a wikilink.
+ *
+ * A wikilink matches one of:
+ *   - `[[target]]`
+ *   - `[[target|alias]]`
+ *   - `[[target#heading]]`
+ *   - `[[target#heading|alias]]`
+ *
+ * The match is by basename without extension (Obsidian's wikilink semantics)
+ * AND by full relPath-without-extension, so `[[notes/foo]]` matches
+ * `notes/foo.md` and `[[foo]]` matches `foo.md` anywhere in the vault.
+ *
+ * @param {string} projectRoot
+ * @param {string} targetRelPath — the note we want backlinks for
+ * @returns {Array<{ fromRelPath: string, fromTitle: string, snippet: string, mtime: number }>}
+ */
+export function findBacklinks(projectRoot, targetRelPath) {
+  if (!targetRelPath) return [];
+  const targetBase = basenameOf(targetRelPath).replace(/\.md$/i, '');
+  const targetStripped = targetRelPath.replace(/\.md$/i, '');
+  if (!targetBase && !targetStripped) return [];
+
+  const out = [];
+  const WIKILINK_RE = /\[\[([^\]\n|]+?)(?:\|[^\]\n]+?)?(?:#[^\]\n]+?)?\]\]/g;
+
+  for (const note of listNotes(projectRoot)) {
+    if (note.relPath === targetRelPath) continue; // skip self
+    const body = note.body || '';
+    const matches = [];
+    let m;
+    WIKILINK_RE.lastIndex = 0;
+    while ((m = WIKILINK_RE.exec(body)) !== null) {
+      const raw = (m[1] || '').trim();
+      if (!raw) continue;
+      const stripped = raw.split('#')[0].trim();
+      if (!stripped) continue;
+      const baseOnly = stripped.split('/').pop() || stripped;
+      if (baseOnly === targetBase || stripped === targetStripped) {
+        matches.push({ raw, idx: m.index });
+      }
+    }
+    if (matches.length === 0) continue;
+
+    // Build a snippet around the FIRST match — 80 chars each side.
+    const first = matches[0];
+    const start = Math.max(0, first.idx - 80);
+    const end = Math.min(body.length, first.idx + first.raw.length + 80);
+    const snippet = (start > 0 ? '…' : '') +
+      body.slice(start, end).replace(/\s+/g, ' ').trim() +
+      (end < body.length ? '…' : '');
+
+    out.push({
+      fromRelPath: note.relPath,
+      fromTitle: note.frontmatter?.title || basenameOf(note.relPath).replace(/\.md$/i, ''),
+      snippet,
+      mtime: note.mtime,
+    });
+  }
+
+  return out.sort((a, b) => b.mtime - a.mtime);
+}
+
+/** Minimal basename helper — avoids pulling `path.basename` into the bundle. */
+function basenameOf(p) {
+  if (!p) return '';
+  const idx = Math.max(p.lastIndexOf('/'), p.lastIndexOf('\\'));
+  return idx >= 0 ? p.slice(idx + 1) : p;
+}
+
+/**
+ * High-level stats used by the Memory tab and Overview status card.
+ *
+ * @param {string} projectRoot
+ * @returns {{ exists: boolean, vaultRoot: string, mode: string, noteCount: number, totalSize: number, folderCount: number, folders: string[], lastModified: number|null, gitClean: boolean|null, gitBranch: string|null }}
+ */
+export function vaultStats(projectRoot) {
+  const { exists, config } = loadConfig(projectRoot);
+  if (!exists) {
+    return {
+      exists: false,
+      vaultRoot: '',
+      mode: 'local-only',
+      noteCount: 0,
+      totalSize: 0,
+      folderCount: 0,
+      folders: [],
+      lastModified: null,
+      gitClean: null,
+      gitBranch: null,
+    };
+  }
+
+  const { vaultRoot, mode, branch } = resolveVault(projectRoot);
+  if (!vaultRoot || !existsSync(vaultRoot)) {
+    return {
+      exists: true,
+      vaultRoot: vaultRoot || '',
+      mode,
+      noteCount: 0,
+      totalSize: 0,
+      folderCount: 0,
+      folders: [],
+      lastModified: null,
+      gitClean: null,
+      gitBranch: branch || config?.branch || 'main',
+    };
+  }
+
+  const notes = listNotes(projectRoot);
+  const totalSize = notes.reduce((acc, n) => acc + (n.size || 0), 0);
+  const folders = new Set();
+  for (const n of notes) {
+    const seg = n.relPath.split('/');
+    if (seg.length > 1) folders.add(seg[0]);
+  }
+
+  let gitClean = null;
+  let gitBranch = null;
+  if (mode === 'managed' || mode === 'linked') {
+    try {
+      const { isGitInstalled, status: gitStatus } = memoryGit;
+      if (isGitInstalled()) {
+        const gs = gitStatus(vaultRoot);
+        gitClean = gs.clean;
+        gitBranch = gs.branch;
+      }
+    } catch {
+      // ignore — git is optional
+    }
+  }
+
+  return {
+    exists: true,
+    vaultRoot,
+    mode,
+    noteCount: notes.length,
+    totalSize,
+    folderCount: folders.size,
+    folders: [...folders].sort(),
+    lastModified: notes[0]?.mtime || null,
+    gitClean,
+    gitBranch: gitBranch || branch || config?.branch || 'main',
+  };
+}
+
 // ── LightRAG integration (v4.1.0) ──────────────────────────────────────────
 //
 // Re-export the LightRAG orchestrator from the memory-store module so the

package/bizar-dash/src/server/mods-loader.mjs

@@ -596,7 +596,8 @@ export const modsLoader = {
       const res = await fetch(modJsonUrl);
       if (!res.ok) return null;
       modJson = await res.json();
-    } catch {
+    } catch (err) {
+      console.warn('swallowed in fetchModMetadata:', err.message);
       return null;
     }
     const id = modJson.id;
@@ -674,7 +675,8 @@ export const modsLoader = {
       let entries;
       try {
         entries = readdirSync(p, { withFileTypes: true });
-      } catch {
+      } catch (err) {
+        console.warn('swallowed in mod walk:', err.message);
         return;
       }
       for (const e of entries) {
@@ -913,20 +915,26 @@ export const modsLoader = {
       try {
         out.agents = readdirSync(OPENCODE_AGENTS_DIR)
           .filter((f) => f.startsWith(prefix));
-      } catch { /* ignore */ }
+      } catch (err) {
+        console.warn('swallowed in agents readdir:', err.message);
+      }
     }
     if (existsSync(OPENCODE_COMMANDS_DIR)) {
       try {
         out.commands = readdirSync(OPENCODE_COMMANDS_DIR)
           .filter((f) => f.startsWith(prefix));
-      } catch { /* ignore */ }
+      } catch (err) {
+        console.warn('swallowed in commands readdir:', err.message);
+      }
     }
     if (existsSync(OPENCODE_SKILLS_DIR)) {
       try {
         out.skills = readdirSync(OPENCODE_SKILLS_DIR, { withFileTypes: true })
           .filter((e) => e.isDirectory() && e.name.startsWith(skillPrefix))
           .map((e) => e.name);
-      } catch { /* ignore */ }
+      } catch (err) {
+        console.warn('swallowed in skills readdir:', err.message);
+      }
     }
     return out;
   },

package/bizar-dash/src/server/providers-store.mjs

@@ -38,6 +38,7 @@ import {
   renameSync,
   mkdirSync,
   readdirSync,
+  statSync,
 } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
@@ -66,13 +67,80 @@ function atomicWriteJson(filePath, data) {
   renameSync(tmp, filePath);
 }
 
+// v5.0.0 — Bug S1: 1-second debounced cache for opencode.json reads.
+// `list()`/`listAll()` and other consumers call `loadConfig()` on every
+// WS poll (every ~5s per client) and on every route hit. With N clients
+// that becomes O(N) reads per minute. The cache collapses all reads
+// within a 1-second window to a single read. Writes invalidate so
+// subsequent reads see the new state.
+//
+// The cache lives on `globalThis` so it is shared across all module
+// instances of providers-store.mjs — tests and code that re-imports
+// the module (e.g. via `?cb=` cache-bust) must see the same cache,
+// otherwise a write on one instance becomes invisible to another.
+//
+// The cache also tracks the file's mtime+size and invalidates if the
+// on-disk file has been modified externally (e.g. an editor saving
+// opencode.json, or a test setup writing a fresh file). This prevents
+// stale reads when the file changes outside our write paths.
+const OPENCODE_JSON_CACHE_GLOBAL_KEY = '__bizar_opencode_json_cache__';
+function _opencodeCacheSlot() {
+  if (!globalThis[OPENCODE_JSON_CACHE_GLOBAL_KEY]) {
+    globalThis[OPENCODE_JSON_CACHE_GLOBAL_KEY] = { entry: null, at: 0 };
+  }
+  return globalThis[OPENCODE_JSON_CACHE_GLOBAL_KEY];
+}
+
+const OPENCODE_JSON_CACHE_TTL_MS = 1000;
+
+function _fileStamp(filePath) {
+  // Best-effort stat — if stat fails (file missing, etc.), the caller
+  // will re-read and re-populate the cache.
+  try {
+    const st = statSync(filePath);
+    return `${st.size}:${st.mtimeMs}`;
+  } catch {
+    return null;
+  }
+}
+
+function readOpencodeJsonCached(filePath = OPENCODE_JSON) {
+  const slot = _opencodeCacheSlot();
+  const now = Date.now();
+  if (slot.entry && slot.entry.filePath === filePath) {
+    const age = now - slot.at;
+    if (age < OPENCODE_JSON_CACHE_TTL_MS) {
+      // Fast path: still within TTL. Verify the file hasn't been
+      // modified externally (e.g. another process, an editor, or a
+      // test that writes the file directly). The stamp check is cheap
+      // and protects correctness when the file is touched outside
+      // our write paths.
+      const stamp = _fileStamp(filePath);
+      if (stamp === null || stamp === slot.entry.stamp) {
+        return slot.entry.data;
+      }
+    }
+  }
+  const data = safeReadJSON(filePath, {});
+  slot.entry = { filePath, data, stamp: _fileStamp(filePath) };
+  slot.at = now;
+  return data;
+}
+
+function invalidateOpencodeJsonCache() {
+  const slot = _opencodeCacheSlot();
+  slot.entry = null;
+  slot.at = 0;
+}
+
 function loadConfig() {
-  return safeReadJSON(OPENCODE_JSON, {});
+  return readOpencodeJsonCached(OPENCODE_JSON);
 }
 
 function saveConfig(data) {
   mkdirSync(dirname(OPENCODE_JSON), { recursive: true });
   atomicWriteJson(OPENCODE_JSON, data);
+  invalidateOpencodeJsonCache();
 }
 
 // v4.6.0 — expose the on-disk load/save helpers so route modules can
@@ -81,6 +149,10 @@ function saveConfig(data) {
 // were not exported and config.mjs referenced them implicitly.
 export { loadConfig, saveConfig };
 
+// v5.0.0 — expose cache helpers for tests and other consumers that need
+// to force a re-read (e.g. settings-store after a write).
+export { readOpencodeJsonCached, invalidateOpencodeJsonCache, OPENCODE_JSON_CACHE_TTL_MS };
+
 // ── v4.6.0 Backup-key rotation constants ────────────────────────────────────
 //
 // ERROR_COOLDOWN_THRESHOLD: after this many recorded errors on the same

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

@@ -148,6 +148,22 @@ export const DEFAULT_SETTINGS = {
     baseUrl: 'https://www.minimax.io',
     chatBaseUrl: 'https://api.minimax.io/v1',
   },
+  // v5.0.0 — Headroom context compression integration.
+  // Headroom sits between opencode and LLM providers, compressing tool
+  // outputs, logs, RAG chunks, and conversation history by 60–95%.
+  headroom: {
+    enabled: true,
+    autoInstall: true,
+    port: 8787,
+    host: '127.0.0.1',
+    outputShaper: false,
+    telemetry: false,
+    budget: 0,
+    backend: 'anthropic',
+    autoStart: true,
+    autoWrap: true,
+    routeAllProviders: true,
+  },
 };
 
 /**
@@ -174,6 +190,7 @@ export function mergeSettings(existing) {
   merged.agents = { ...DEFAULT_SETTINGS.agents, ...(existing.agents || {}) };
   merged.systemLlm = { ...DEFAULT_SETTINGS.systemLlm, ...(existing.systemLlm || {}) };
   merged.minimax = { ...DEFAULT_SETTINGS.minimax, ...(existing.minimax || {}) };
+  merged.headroom = { ...DEFAULT_SETTINGS.headroom, ...(existing.headroom || {}) };
   // Always use the package version — never let user settings override it
   merged.about.version = DEFAULT_SETTINGS.about.version;
   return merged;

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

@@ -53,6 +53,36 @@ const SESSION_ID_RE = /^[A-Za-z0-9_-]{1,120}$/;
 const MAX_CHAT_SUBSCRIPTIONS = 50;
 let activeChatSubscriptions = 0;
 
+/**
+ * v5.0.0 — Bug S3: per-chat-session backpressure cap on the SSE→WS
+ * forwarding pipeline. The upstream SSE can pump deltas faster than
+ * the WS broadcast can flush them if a connected WS client is slow.
+ * `safeSend()` in server.mjs already terminates slow WS clients based
+ * on the byte-level `bufferedAmount`, but we also need a defensive
+ * message-count cap so a single chat session can't accumulate an
+ * unbounded number of queued deltas in this process. When a session
+ * exceeds CHAT_DELTA_BUFFER_CAP, additional deltas are dropped with
+ * a warning log so operators see the issue.
+ */
+const CHAT_DELTA_BUFFER_CAP = 1000;
+const chatDeltaCounts = new Map(); // chatSessionId -> count since idle
+
+function noteChatDelta(chatSessionId) {
+  const cur = chatDeltaCounts.get(chatSessionId) || 0;
+  if (cur >= CHAT_DELTA_BUFFER_CAP) {
+    console.warn(
+      `[chat] dropped delta for session ${chatSessionId}: per-session cap (${CHAT_DELTA_BUFFER_CAP}) exceeded; client is too slow`,
+    );
+    return false;
+  }
+  chatDeltaCounts.set(chatSessionId, cur + 1);
+  return true;
+}
+
+function resetChatDeltaCount(chatSessionId) {
+  chatDeltaCounts.delete(chatSessionId);
+}
+
 /**
  * @param {object} deps
  * @param {object} deps.state
@@ -489,6 +519,11 @@ async function streamOpencodeSession({
           // Forward text part deltas as chat:delta
           const textDelta = extractTextDelta(envelope);
           if (textDelta) {
+            // Bug S3 — drop the delta (with warning) if this session
+            // has hit the per-connection cap. The upstream SSE pump
+            // continues, but we stop forwarding to WS to avoid
+            // unbounded buffering here.
+            if (!noteChatDelta(chatSessionId)) return;
             broadcast({
               type: 'chat:delta',
               sessionId: chatSessionId,
@@ -501,6 +536,9 @@ async function streamOpencodeSession({
         onIdle(envelope) {
           if (done) return;
           done = true;
+          // Bug S3 — release the per-session delta counter on idle so
+          // the next prompt starts with a fresh budget.
+          resetChatDeltaCount(chatSessionId);
           // Fetch the final message list and extract the assistant reply.
           void (async () => {
             try {

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

@@ -0,0 +1,126 @@
+/**
+ * src/server/routes/headroom.mjs
+ *
+ * v1.0.0 — REST endpoints for Headroom management.
+ *
+ * Mounted at /api/headroom/* by api.mjs.
+ */
+import { Router } from 'express';
+import {
+  getHeadroomStatus,
+  getHeadroomStats,
+  installHeadroom,
+  wrapOpencode,
+  unwrapOpencode,
+  startProxy,
+  stopProxy,
+  getOpencodeConfig,
+  headroomStartupHook,
+} from '../headroom.mjs';
+import { wrap } from './_shared.mjs';
+
+export function createHeadroomRouter() {
+  const router = Router();
+
+  // GET /api/headroom/status
+  router.get('/status', wrap(async (_req, res) => {
+    const status = await getHeadroomStatus();
+    res.json(status);
+  }));
+
+  // GET /api/headroom/stats?hours=24
+  router.get('/stats', wrap(async (req, res) => {
+    const hours = Math.max(1, Math.min(parseInt(req.query.hours, 10) || 24, 720));
+    const stats = await getHeadroomStats({ hours });
+    res.json(stats);
+  }));
+
+  // POST /api/headroom/install
+  router.post('/install', wrap(async (req, res) => {
+    const { force = false } = req.body || {};
+    const result = await installHeadroom({ force: Boolean(force) });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/wrap
+  router.post('/wrap', wrap(async (req, res) => {
+    const { port } = req.body || {};
+    const result = await wrapOpencode({
+      port: port ? Math.max(1, Math.min(parseInt(port, 10), 65535)) : 8787,
+    });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/unwrap
+  router.post('/unwrap', wrap(async (_req, res) => {
+    const result = await unwrapOpencode();
+    res.json(result);
+  }));
+
+  // POST /api/headroom/proxy/start
+  router.post('/proxy/start', wrap(async (req, res) => {
+    const { port, host } = req.body || {};
+    const result = await startProxy({
+      port: port ? Math.max(1, Math.min(parseInt(port, 10), 65535)) : 8787,
+      host: typeof host === 'string' && host ? host : '127.0.0.1',
+    });
+    res.json(result);
+  }));
+
+  // POST /api/headroom/proxy/stop
+  router.post('/proxy/stop', wrap(async (_req, res) => {
+    const result = await stopProxy();
+    res.json(result);
+  }));
+
+  // GET /api/headroom/opencode-config
+  router.get('/opencode-config', wrap(async (_req, res) => {
+    const config = await getOpencodeConfig();
+    res.json(config);
+  }));
+
+  // POST /api/headroom/auto-route — configure all providers to route through Headroom
+  router.post('/auto-route', wrap(async (_req, res) => {
+    const { loadConfig, saveConfig } = await import('../providers-store.mjs');
+    const cfg = loadConfig();
+    const headroomPort = 8787;
+    const proxyUrl = `http://127.0.0.1:${headroomPort}/v1`;
+
+    // For each provider, prepend the headroom proxy URL to baseURL
+    const providers = cfg.provider || {};
+    let changed = 0;
+    for (const [id, p] of Object.entries(providers)) {
+      if (!p || typeof p !== 'object') continue;
+      const baseURL = p.baseURL || p.options?.baseURL || '';
+      // Only update if not already routed
+      if (baseURL && !baseURL.includes('127.0.0.1:8787') && !baseURL.includes('localhost:8787')) {
+        const newBaseURL = `${proxyUrl}/${baseURL.replace(/^https?:\/\//, '')}`;
+        if (p.options) {
+          providers[id] = { ...p, options: { ...p.options, baseURL: newBaseURL } };
+        } else {
+          providers[id] = { ...p, baseURL: newBaseURL };
+        }
+        changed++;
+      }
+    }
+    cfg.provider = providers;
+    saveConfig(cfg);
+
+    res.json({ ok: true, changed, message: `Updated ${changed} provider(s) to route through Headroom proxy.` });
+  }));
+
+  // POST /api/headroom/startup-hook — trigger the startup hook programmatically
+  router.post('/startup-hook', wrap(async (_req, res) => {
+    const { readSettings } = await import('./_shared.mjs');
+    const settings = readSettings();
+    const headroomSettings = settings?.data?.headroom;
+    if (!headroomSettings) {
+      res.status(400).json({ error: 'bad_request', message: 'Headroom settings not found in settings.json' });
+      return;
+    }
+    const result = await headroomStartupHook(headroomSettings);
+    res.json(result);
+  }));
+
+  return router;
+}

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

@@ -127,13 +127,17 @@ export function createLightragRouter({ projectRoot }) {
         const content = readFileSync(logFile, 'utf8');
         const lines = content.split('\n');
         logTail.push(...lines.slice(-30));
-      } catch { /* ignore */ }
+      } catch (err) {
+        console.warn('swallowed in lightrag log tail:', err.message);
+      }
     }
 
     let logSize = 0;
     try {
       if (existsSync(logFile)) logSize = statSync(logFile).size;
-    } catch { /* ignore */ }
+    } catch (err) {
+      console.warn('swallowed in lightrag log stat:', err.message);
+    }
 
     res.json({
       running: alive,