@polderlabs/bizar 9.0.0 → 10.0.7

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/notifications-store.mjs

@@ -1,243 +0,0 @@
-/**
- * src/server/notifications-store.mjs
- *
- * v3.3.0 — Per-user notification stream.
- *
- * Storage:
- *   ~/.config/bizar/notifications.jsonl   (append-only log)
- *
- * Each entry:
- *   { id, ts, severity, message, source, read, meta? }
- *
- * The store also keeps a Set of "read" ids in memory and writes them
- * to ~/.config/bizar/notifications.read.json so the read state
- * survives restarts.
- *
- * Reading is "append-only" but the read state is destructive. That's
- * the standard pattern for this kind of activity log.
- */
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  renameSync,
-  appendFileSync,
-  mkdirSync,
-  statSync,
-} from 'node:fs';
-import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
-import { randomBytes } from 'node:crypto';
-
-const HOME = homedir();
-const BIZAR_HOME = join(HOME, '.config', 'bizar');
-const LOG_FILE = join(BIZAR_HOME, 'notifications.jsonl');
-const READ_FILE = join(BIZAR_HOME, 'notifications.read.json');
-
-const VALID_SEVERITY = ['info', 'success', 'warning', 'error'];
-const MAX_KEPT = 1000;
-
-function atomicWriteText(filePath, text) {
-  const tmp = `${filePath}.tmp.${process.pid}`;
-  writeFileSync(tmp, text, 'utf8');
-  renameSync(tmp, filePath);
-}
-
-function atomicWriteJson(filePath, data) {
-  atomicWriteText(filePath, JSON.stringify(data, null, 2) + '\n');
-}
-
-function genId() {
-  return `n_${Date.now().toString(36)}${randomBytes(3).toString('hex')}`;
-}
-
-function ensureLogFile() {
-  mkdirSync(dirname(LOG_FILE), { recursive: true });
-  if (!existsSync(LOG_FILE)) {
-    writeFileSync(LOG_FILE, '', 'utf8');
-  }
-}
-
-function safeParse(line) {
-  try {
-    return JSON.parse(line);
-  } catch {
-    return null;
-  }
-}
-
-function loadReadSet() {
-  try {
-    if (!existsSync(READ_FILE)) return new Set();
-    const raw = JSON.parse(readFileSync(READ_FILE, 'utf8'));
-    if (Array.isArray(raw)) return new Set(raw);
-    return new Set();
-  } catch {
-    return new Set();
-  }
-}
-
-function saveReadSet(set) {
-  try {
-    mkdirSync(dirname(READ_FILE), { recursive: true });
-    atomicWriteJson(READ_FILE, Array.from(set));
-  } catch {
-    /* best-effort */
-  }
-}
-
-let _readSet = null;
-function getReadSet() {
-  if (_readSet === null) _readSet = loadReadSet();
-  return _readSet;
-}
-
-export const notificationsStore = {
-  LOG_FILE,
-  READ_FILE,
-
-  /**
-   * Append a new notification. Returns the record. If `broadcast` is
-   * provided the new event is also pushed to all WS clients.
-   */
-  add(input, { broadcast } = {}) {
-    if (!input || typeof input !== 'object') {
-      throw new Error('notification input required');
-    }
-    const severity = VALID_SEVERITY.includes(input.severity) ? input.severity : 'info';
-    const record = {
-      id: input.id || genId(),
-      ts: input.ts || new Date().toISOString(),
-      severity,
-      message: (input.message || '').toString().slice(0, 1000),
-      source: (input.source || 'system').toString().slice(0, 100),
-      title: (input.title || '').toString().slice(0, 200),
-      link: input.link || null,
-      read: false,
-      meta: input.meta && typeof input.meta === 'object' ? input.meta : null,
-    };
-    try {
-      ensureLogFile();
-      appendFileSync(LOG_FILE, JSON.stringify(record) + '\n', 'utf8');
-      // Rotate when the log gets big.
-      try {
-        const st = statSync(LOG_FILE);
-        if (st.size > 2 * 1024 * 1024) {
-          const lines = readFileSync(LOG_FILE, 'utf8').split(/\r?\n/);
-          const kept = lines.slice(-MAX_KEPT).join('\n') + '\n';
-          atomicWriteText(LOG_FILE, kept);
-        }
-      } catch {
-        /* best-effort */
-      }
-      if (typeof broadcast === 'function') {
-        broadcast({ type: 'notification:new', notification: record });
-      }
-    } catch (err) {
-      console.error('[notifications] append failed:', err.message);
-    }
-    return record;
-  },
-
-  /**
-   * List notifications, newest first. Supports an optional `unread` flag
-   * to filter to unread only, and an optional `limit`.
-   */
-  list({ unread = false, limit = 200 } = {}) {
-    try {
-      ensureLogFile();
-      const text = readFileSync(LOG_FILE, 'utf8');
-      if (!text.trim()) return [];
-      const lines = text.split(/\r?\n/).filter(Boolean);
-      const readSet = getReadSet();
-      const out = [];
-      for (let i = lines.length - 1; i >= 0 && out.length < Math.max(1, limit); i--) {
-        const p = safeParse(lines[i]);
-        if (!p) continue;
-        const isRead = readSet.has(p.id);
-        if (unread && isRead) continue;
-        out.push({ ...p, read: isRead });
-      }
-      return out;
-    } catch {
-      return [];
-    }
-  },
-
-  /** Stats: total, unread, latest ts, severity counts. */
-  stats() {
-    try {
-      ensureLogFile();
-      const text = readFileSync(LOG_FILE, 'utf8');
-      const lines = text.split(/\r?\n/).filter(Boolean);
-      const readSet = getReadSet();
-      const counts = { info: 0, success: 0, warning: 0, error: 0 };
-      let unread = 0;
-      let lastTs = null;
-      for (const line of lines) {
-        const p = safeParse(line);
-        if (!p) continue;
-        counts[p.severity] = (counts[p.severity] || 0) + 1;
-        if (!readSet.has(p.id)) unread += 1;
-        if (!lastTs || p.ts > lastTs) lastTs = p.ts;
-      }
-      return {
-        total: lines.length,
-        unread,
-        lastTs,
-        counts,
-      };
-    } catch {
-      return { total: 0, unread: 0, lastTs: null, counts: {} };
-    }
-  },
-
-  /** Mark a single id as read. */
-  markRead(id) {
-    if (!id) return false;
-    const set = getReadSet();
-    set.add(id);
-    saveReadSet(set);
-    return true;
-  },
-
-  /** Mark every notification as read. */
-  markAllRead() {
-    try {
-      ensureLogFile();
-      const text = readFileSync(LOG_FILE, 'utf8');
-      const lines = text.split(/\r?\n/).filter(Boolean);
-      const set = getReadSet();
-      for (const line of lines) {
-        const p = safeParse(line);
-        if (p && p.id) set.add(p.id);
-      }
-      saveReadSet(set);
-      return set.size;
-    } catch {
-      return 0;
-    }
-  },
-
-  /** Remove a notification from the log (e.g. user dismisses). */
-  remove(id) {
-    if (!id) return false;
-    try {
-      ensureLogFile();
-      const text = readFileSync(LOG_FILE, 'utf8');
-      const lines = text.split(/\r?\n/).filter(Boolean);
-      const kept = lines.filter((l) => {
-        const p = safeParse(l);
-        return p && p.id !== id;
-      });
-      if (kept.length === lines.length) return false;
-      atomicWriteText(LOG_FILE, kept.join('\n') + (kept.length ? '\n' : ''));
-      const set = getReadSet();
-      set.delete(id);
-      saveReadSet(set);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-};

package/.claude/worktrees/kanban-overhaul/bizar-dash/src/server/obsidian-store.mjs

@@ -1,318 +0,0 @@
-/**
- * src/server/obsidian-store.mjs
- *
- * Per-project Obsidian vault for long-term agent memory. Each project
- * gets an `.obsidian/` directory inside its worktree root. Notes are
- * plain Markdown files git-tracked so the vault survives across clones
- * and machines. Obsidian itself can open the directory as a vault;
- * the agent sees the same files via the API.
- *
- * Conventions
- * ───────────
- *   .obsidian/
- *     ├── vault.json               vault metadata (Obsidian format)
- *     ├── README.md                project-level overview (rendered in dashboard)
- *     ├── INDEX.md                  auto-generated index of all notes
- *     ├── daily/                   daily journal entries
- *     │   └── YYYY-MM-DD.md
- *     ├── decisions/               architecture / design decisions
- *     ├── patterns/                code patterns learned
- *     ├── api/                     API contracts discovered
- *     └── tasks/                   per-task learnings
- *
- * Files are markdown with YAML frontmatter (id, title, tags, created, updated).
- * The dashboard exposes CRUD + search via REST.
- *
- * Why Obsidian and not just SQLite?
- * ──────────────────────────────────
- * 1. Git-trackable, portable, human-readable
- * 2. Renders in Obsidian.app for the user to browse
- * 3. Plugins (graph view, backlinks, dataview) work out of the box
- * 4. Plain markdown so any tool (cat, grep, IDE) can read it
- * 5. Backlinks emerge naturally as agents cross-link notes
- */
-import {
-  existsSync,
-  readFileSync,
-  writeFileSync,
-  readdirSync,
-  mkdirSync,
-  unlinkSync,
-  statSync,
-  rmSync,
-} from 'node:fs';
-import { join, dirname, relative, resolve } from 'node:path';
-
-/**
- * @param {string} projectRoot — absolute path to the project's working dir
- * @returns {string} absolute path to the project's `.obsidian/` dir
- */
-export function obsidianVaultDir(projectRoot) {
-  return join(projectRoot, '.obsidian');
-}
-
-/** Standard subdirectories inside every Obsidian vault. */
-const STANDARD_SUBDIRS = ['daily', 'decisions', 'patterns', 'api', 'tasks'];
-
-/**
- * Initialize the vault for a project. Creates `.obsidian/`, the standard
- * subdirectories, a README.md, and a vault.json. Idempotent.
- *
- * @returns {{ vaultDir: string, created: string[] }}
- */
-export function initObsidianVault(projectRoot) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  const created = [];
-  if (!existsSync(vaultDir)) {
-    mkdirSync(vaultDir, { recursive: true });
-    created.push('.obsidian/');
-  }
-  for (const sub of STANDARD_SUBDIRS) {
-    const subPath = join(vaultDir, sub);
-    if (!existsSync(subPath)) {
-      mkdirSync(subPath, { recursive: true });
-      created.push(`.obsidian/${sub}/`);
-    }
-  }
-  const readmePath = join(vaultDir, 'README.md');
-  if (!existsSync(readmePath)) {
-    writeFileSync(
-      readmePath,
-      `# ${projectRoot.split('/').pop() || 'Project'} — Obsidian Vault\n\n` +
-        `Long-term memory for this project's AI agents.\n\n` +
-        `## Structure\n\n` +
-        `- \`daily/\` — daily journal entries (one file per day)\n` +
-        `- \`decisions/\` — architecture / design decisions\n` +
-        `- \`patterns/\` — code patterns learned\n` +
-        `- \`api/\` — API contracts discovered\n` +
-        `- \`tasks/\` — per-task learnings\n\n` +
-        `All notes are plain markdown with YAML frontmatter.\n` +
-        `Agents maintain this vault automatically.\n`,
-      'utf8',
-    );
-    created.push('.obsidian/README.md');
-  }
-  const vaultJsonPath = join(vaultDir, 'vault.json');
-  if (!existsSync(vaultJsonPath)) {
-    writeFileSync(
-      vaultJsonPath,
-      JSON.stringify(
-        {
-          name: projectRoot.split('/').pop() || 'Project',
-          version: '1.0.0',
-          format: 'obsidian-vault',
-          createdAt: new Date().toISOString(),
-          managedBy: 'bizar-dash',
-        },
-        null,
-        2,
-      ),
-      'utf8',
-    );
-    created.push('.obsidian/vault.json');
-  }
-  return { vaultDir, created };
-}
-
-/** Parse a markdown file's YAML frontmatter. Returns { frontmatter, body }. */
-function parseFrontmatter(raw) {
-  if (!raw.startsWith('---')) return { frontmatter: {}, body: raw };
-  const end = raw.indexOf('\n---', 3);
-  if (end === -1) return { frontmatter: {}, body: raw };
-  const fmBlock = raw.slice(3, end).trim();
-  const body = raw.slice(end + 4).replace(/^\n/, '');
-  const frontmatter = {};
-  for (const line of fmBlock.split('\n')) {
-    const m = line.match(/^([\w-]+):\s*(.*)$/);
-    if (m) frontmatter[m[1]] = m[2].replace(/^["']|["']$/g, '');
-  }
-  return { frontmatter, body };
-}
-
-function serializeFrontmatter(fm) {
-  const lines = ['---'];
-  for (const [k, v] of Object.entries(fm)) {
-    if (v === undefined || v === null) continue;
-    lines.push(`${k}: ${typeof v === 'string' && v.includes(':') ? `"${v}"` : v}`);
-  }
-  lines.push('---', '');
-  return lines.join('\n');
-}
-
-/**
- * Recursively walk the vault directory and return all .md files.
- * @returns {Array<{ path: string, relPath: string, mtime: number, size: number }>}
- */
-export function listVaultNotes(projectRoot) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  if (!existsSync(vaultDir)) return [];
-  const out = [];
-  function walk(dir, prefix) {
-    let entries;
-    try { entries = readdirSync(dir, { withFileTypes: true }); }
-    catch { return; }
-    for (const e of entries) {
-      const full = join(dir, e.name);
-      const rel = prefix ? `${prefix}/${e.name}` : e.name;
-      if (e.isDirectory()) {
-        if (e.name === 'node_modules' || e.name.startsWith('.')) continue;
-        walk(full, rel);
-      } else if (e.name.endsWith('.md')) {
-        try {
-          const st = statSync(full);
-          out.push({ path: full, relPath: rel, mtime: st.mtimeMs, size: st.size });
-        } catch { /* ignore */ }
-      }
-    }
-  }
-  walk(vaultDir, '');
-  return out.sort((a, b) => b.mtime - a.mtime);
-}
-
-/**
- * Read a single note by its path relative to the vault root.
- * Returns { relPath, frontmatter, body, raw, mtime, size } or null.
- */
-export function readVaultNote(projectRoot, relPath) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  const filePath = resolveSafe(vaultDir, relPath);
-  if (!filePath || !existsSync(filePath)) return null;
-  const raw = readFileSync(filePath, 'utf8');
-  const st = statSync(filePath);
-  const { frontmatter, body } = parseFrontmatter(raw);
-  return {
-    relPath,
-    frontmatter,
-    body,
-    raw,
-    mtime: st.mtimeMs,
-    size: st.size,
-  };
-}
-
-/** Path safety: never let a note path escape the vault dir. */
-function resolveSafe(vaultDir, relPath) {
-  if (!relPath || relPath.includes('\0')) return null;
-  const abs = resolve(vaultDir, relPath);
-  const rel = relative(vaultDir, abs);
-  if (rel.startsWith('..') || abs !== resolve(abs)) return null;
-  return abs;
-}
-
-/**
- * Create or update a note. `relPath` is relative to the vault root,
- * e.g. "daily/2026-06-25.md" or "decisions/use-svelte.md".
- * `frontmatter` is a key/value map; `body` is the markdown content.
- */
-export function writeVaultNote(projectRoot, relPath, { frontmatter = {}, body = '' } = {}) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  if (!existsSync(vaultDir)) initObsidianVault(projectRoot);
-  const filePath = resolveSafe(vaultDir, relPath);
-  if (!filePath) throw new Error(`Invalid note path: ${relPath}`);
-  mkdirSync(dirname(filePath), { recursive: true });
-  const fm = {
-    id: relPath.replace(/\.md$/, '').replace(/[\\/]/g, '-'),
-    title: frontmatter.title || relPath.replace(/\.md$/, '').split('/').pop(),
-    tags: Array.isArray(frontmatter.tags) ? frontmatter.tags.join(', ') : (frontmatter.tags || ''),
-    created: frontmatter.created || new Date().toISOString(),
-    updated: new Date().toISOString(),
-    ...frontmatter,
-  };
-  delete fm.id; delete fm.title; delete fm.tags; delete fm.created; delete fm.updated;
-  // Restore the canonical fields explicitly
-  const finalFm = {
-    id: relPath.replace(/\.md$/, '').replace(/[\\/]/g, '-'),
-    title: frontmatter.title || relPath.replace(/\.md$/, '').split('/').pop(),
-    tags: Array.isArray(frontmatter.tags) ? frontmatter.tags.join(', ') : (frontmatter.tags || ''),
-    created: frontmatter.created || new Date().toISOString(),
-    updated: new Date().toISOString(),
-    ...frontmatter,
-  };
-  const content = serializeFrontmatter(finalFm) + '\n' + body;
-  writeFileSync(filePath, content, 'utf8');
-  return readVaultNote(projectRoot, relPath);
-}
-
-/** Delete a note by relative path. */
-export function deleteVaultNote(projectRoot, relPath) {
-  const filePath = resolveSafe(obsidianVaultDir(projectRoot), relPath);
-  if (!filePath || !existsSync(filePath)) return false;
-  unlinkSync(filePath);
-  return true;
-}
-
-/** Recursive search across all notes. Returns matching {relPath, snippet, score}. */
-export function searchVault(projectRoot, query, { limit = 25 } = {}) {
-  if (!query || typeof query !== 'string') return [];
-  const q = query.toLowerCase();
-  const tokens = q.split(/\s+/).filter((t) => t.length >= 2);
-  if (tokens.length === 0) return [];
-  const results = [];
-  for (const note of listVaultNotes(projectRoot)) {
-    let raw;
-    try { raw = readFileSync(note.path, 'utf8'); } catch { continue; }
-    const lower = raw.toLowerCase();
-    let score = 0;
-    for (const t of tokens) {
-      if (lower.includes(t)) score += (lower.split(t).length - 1);
-    }
-    if (score === 0) continue;
-    // Snippet around first match
-    const idx = lower.indexOf(tokens[0]);
-    const start = Math.max(0, idx - 60);
-    const end = Math.min(raw.length, idx + 160);
-    const snippet = (start > 0 ? '…' : '') + raw.slice(start, end).replace(/\s+/g, ' ').trim();
-    results.push({ relPath: note.relPath, snippet, score, mtime: note.mtime });
-    if (results.length >= limit * 4) break;
-  }
-  return results.sort((a, b) => b.score - a.score).slice(0, limit);
-}
-
-/** Rebuild the auto-generated INDEX.md listing all notes grouped by folder. */
-export function rebuildIndex(projectRoot) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  if (!existsSync(vaultDir)) return null;
-  const notes = listVaultNotes(projectRoot);
-  const grouped = {};
-  for (const n of notes) {
-    const folder = n.relPath.includes('/') ? n.relPath.split('/')[0] : '_root';
-    if (!grouped[folder]) grouped[folder] = [];
-    grouped[folder].push(n);
-  }
-  const lines = ['---', 'title: Index', `updated: ${new Date().toISOString()}`, '---', '',
-    '# Index', '', 'Auto-generated by the Obsidian vault integration.', ''];
-  for (const folder of Object.keys(grouped).sort()) {
-    lines.push(`## ${folder}`, '');
-    for (const n of grouped[folder].slice(0, 50)) {
-      lines.push(`- [[${n.relPath.replace(/\.md$/, '')}]]`);
-    }
-    if (grouped[folder].length > 50) {
-      lines.push(`- _…and ${grouped[folder].length - 50} more_`);
-    }
-    lines.push('');
-  }
-  const indexPath = join(vaultDir, 'INDEX.md');
-  writeFileSync(indexPath, lines.join('\n'), 'utf8');
-  return indexPath;
-}
-
-/** Vault summary stats. */
-export function vaultStats(projectRoot) {
-  const vaultDir = obsidianVaultDir(projectRoot);
-  const exists = existsSync(vaultDir);
-  if (!exists) {
-    return { exists: false, vaultDir, noteCount: 0, totalSize: 0 };
-  }
-  const notes = listVaultNotes(projectRoot);
-  const totalSize = notes.reduce((acc, n) => acc + n.size, 0);
-  const folders = new Set(notes.map((n) => n.relPath.split('/')[0]));
-  return {
-    exists: true,
-    vaultDir,
-    noteCount: notes.length,
-    totalSize,
-    folderCount: folders.size,
-    folders: [...folders].sort(),
-    lastModified: notes[0]?.mtime || null,
-  };
-}

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

@@ -1,55 +0,0 @@
-/**
- * src/server/ocr.mjs
- *
- * v5.0.0 — Tesseract.js wrapper for OCR text extraction.
- *
- * Provides a single `extractText(imageBuffer, options?)` function.
- * The worker is created lazily and terminated after each call to avoid
- * memory leaks in long-running server processes.
- */
-
-import { createWorker } from 'tesseract.js';
-
-let worker = null;
-
-/**
- * Extract text from an image buffer using Tesseract.js OCR.
- *
- * @param {Buffer} imageBuffer - Raw image data (PNG, JPEG, etc.)
- * @param {{ lang?: string }} [options] - Recognition options.
- *   `lang` defaults to 'eng' (English).
- * @returns {Promise<string>} - The extracted text.
- */
-export async function extractText(imageBuffer, { lang = 'eng' } = {}) {
-  const w = worker || (worker = await createWorker(lang));
-
-  try {
-    const { data } = await w.recognize(imageBuffer);
-    return (data.text || '').trim();
-  } finally {
-    // Terminate and reset so a new worker picks up any config changes
-    // on the next call. This prevents the worker from accumulating state
-    // across requests in long-running servers.
-    try { await w.terminate(); } catch { /* ignore */ }
-    worker = null;
-  }
-}
-
-/**
- * Check whether Tesseract.js is available and can be initialised.
- * Useful for health-check endpoints.
- *
- * @returns {Promise<{ ok: boolean, message: string }>}
- */
-export async function checkOcrHealth() {
-  try {
-    const w = await createWorker('eng');
-    await w.terminate();
-    return { ok: true, message: 'Tesseract.js worker initialised OK' };
-  } catch (err) {
-    return {
-      ok: false,
-      message: `Tesseract.js init failed: ${err instanceof Error ? err.message : String(err)}`,
-    };
-  }
-}