@polderlabs/bizar 3.23.1 → 4.0.0

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

@@ -0,0 +1,243 @@
+/**
+ * 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/bizar-dash/src/server/obsidian-store.mjs

@@ -0,0 +1,318 @@
+/**
+ * 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,
+  };
+}