@polderlabs/bizar 8.0.0 → 9.0.0

package/.claude/worktrees/kanban-overhaul/mods-examples/impeccable/route.mjs

@@ -0,0 +1,136 @@
+/**
+ * mods/impeccable/route.mjs
+ *
+ * Wraps `impeccable detect` and stores results in the project's Obsidian
+ * vault under `.obsidian/impeccable/`. Agents that read the vault can
+ * surface the most recent scan results at session start.
+ *
+ * Endpoints
+ *   GET  /state          — last scan summary + config
+ *   POST /scan           — run impeccable detect on the configured scope
+ *   GET  /report         — return last full JSON report
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+function resolveActiveProjectRoot() {
+  try {
+    const active = globalThis.__bizarProjectsStore?.active?.();
+    if (active && active.path && fs.existsSync(active.path)) return active.path;
+  } catch { /* ignore */ }
+  return process.cwd();
+}
+
+function scanDir(projectRoot) {
+  return path.resolve(projectRoot, '.obsidian', 'impeccable');
+}
+
+function stateFile(projectRoot) {
+  return path.resolve(scanDir(projectRoot), 'state.json');
+}
+
+function reportFile(projectRoot) {
+  return path.resolve(scanDir(projectRoot), 'last-report.json');
+}
+
+function readState(projectRoot) {
+  const p = stateFile(projectRoot);
+  if (!fs.existsSync(p)) return { lastScanAt: null, lastFindings: 0, lastExitCode: null, scope: 'src' };
+  try {
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return { lastScanAt: null, lastFindings: 0, lastExitCode: null, scope: 'src' };
+  }
+}
+
+function writeState(projectRoot, data) {
+  fs.mkdirSync(scanDir(projectRoot), { recursive: true });
+  fs.writeFileSync(stateFile(projectRoot), JSON.stringify(data, null, 2), 'utf8');
+}
+
+function runImpeccable(projectRoot, scope) {
+  return new Promise((resolve, reject) => {
+    const args = ['--yes', 'impeccable', 'detect', '--json', scope];
+    const proc = spawn('npx', args, {
+      cwd: projectRoot,
+      env: { ...process.env },
+      timeout: 5 * 60 * 1000,
+    });
+    let stdout = '';
+    let stderr = '';
+    proc.stdout.on('data', (d) => { stdout += d.toString(); });
+    proc.stderr.on('data', (d) => { stderr += d.toString(); });
+    proc.on('close', (code) => resolve({ code, stdout, stderr }));
+    proc.on('error', reject);
+  });
+}
+
+export default function register({ router }) {
+  const projectRoot = resolveActiveProjectRoot();
+
+  router.get('/state', (req, res) => {
+    const state = readState(projectRoot);
+    res.json({
+      ...state,
+      package: 'impeccable',
+      installCommand: 'npx --yes impeccable skills install -y --scope=user',
+      repoUrl: 'https://github.com/pbakaus/impeccable',
+    });
+  });
+
+  router.post('/scan', async (req, res) => {
+    const state = readState(projectRoot);
+    const scope = (req.body?.scope || state.scope || 'src');
+    try {
+      const { code, stdout, stderr } = await runImpeccable(projectRoot, scope);
+      // Try to parse JSON; impeccable's --json output should be valid JSON
+      let findings = [];
+      let parsed = null;
+      const lines = stdout.split('\n').filter(Boolean);
+      // Find the JSON block (last complete {...} block)
+      const jsonStart = stdout.indexOf('{');
+      const jsonEnd = stdout.lastIndexOf('}');
+      if (jsonStart !== -1 && jsonEnd > jsonStart) {
+        try {
+          parsed = JSON.parse(stdout.slice(jsonStart, jsonEnd + 1));
+          findings = Array.isArray(parsed) ? parsed : (parsed.findings || parsed.issues || []);
+        } catch { /* imperfect JSON, fall back to counting lines */ }
+      }
+      if (findings.length === 0) {
+        // Crude line-based count
+        const lines2 = stdout.split('\n').filter((l) => /\bfail|warn|anti-pattern/i.test(l));
+        findings = lines2.map((l) => ({ message: l.trim() }));
+      }
+      const summary = {
+        lastScanAt: new Date().toISOString(),
+        lastExitCode: code,
+        lastFindings: findings.length,
+        scope,
+      };
+      fs.mkdirSync(scanDir(projectRoot), { recursive: true });
+      writeState(projectRoot, { ...state, ...summary });
+      fs.writeFileSync(reportFile(projectRoot), JSON.stringify({
+        ...summary,
+        findings,
+        stderr: stderr.slice(-2000),
+      }, null, 2), 'utf8');
+      res.json({ ok: code === 0 || code === 2, ...summary, findings: findings.slice(0, 200) });
+    } catch (err) {
+      res.status(500).json({ error: 'scan_failed', message: err.message });
+    }
+  });
+
+  router.get('/report', (req, res) => {
+    const p = reportFile(projectRoot);
+    if (!fs.existsSync(p)) {
+      res.status(404).json({ error: 'no_report', message: 'Run a scan first via POST /scan' });
+      return;
+    }
+    try {
+      res.json(JSON.parse(fs.readFileSync(p, 'utf8')));
+    } catch (err) {
+      res.status(500).json({ error: 'parse_failed', message: err.message });
+    }
+  });
+}

package/.claude/worktrees/kanban-overhaul/mods-examples/impeccable/web/index.html

@@ -0,0 +1,180 @@
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8" />
+<title>Impeccable</title>
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body {
+    margin: 0;
+    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, sans-serif;
+    background: #0f1115;
+    color: #e6e8ec;
+    font-size: 14px;
+    padding: 28px;
+  }
+  h1 { margin: 0 0 8px; font-size: 22px; }
+  .lede { color: #8b92a1; max-width: 720px; line-height: 1.5; margin-bottom: 24px; }
+  .toolbar { display: flex; align-items: center; gap: 12px; margin-bottom: 18px; flex-wrap: wrap; }
+  .toolbar button {
+    padding: 8px 16px;
+    border-radius: 8px;
+    border: 1px solid #6366f1;
+    background: #6366f1;
+    color: white;
+    font-size: 13px;
+    font-weight: 600;
+    cursor: pointer;
+  }
+  .toolbar button:disabled { opacity: 0.5; cursor: not-allowed; }
+  .toolbar select {
+    padding: 7px 10px;
+    border-radius: 8px;
+    border: 1px solid #2a2e36;
+    background: #181b21;
+    color: #e6e8ec;
+    font-size: 13px;
+  }
+  .stat-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(160px, 1fr)); gap: 12px; max-width: 980px; margin-bottom: 24px; }
+  .stat {
+    border: 1px solid #2a2e36;
+    border-radius: 10px;
+    padding: 14px;
+    background: #181b21;
+  }
+  .stat .label { font-size: 11px; color: #8b92a1; text-transform: uppercase; letter-spacing: 0.04em; }
+  .stat .value { font-size: 22px; font-weight: 700; margin-top: 4px; font-variant-numeric: tabular-nums; }
+  .findings { max-width: 980px; }
+  .finding {
+    border: 1px solid #2a2e36;
+    border-radius: 10px;
+    padding: 12px 14px;
+    background: #181b21;
+    margin-bottom: 8px;
+    font-size: 13px;
+  }
+  .finding .msg { font-family: ui-monospace, Menlo, Consolas, monospace; }
+  .finding .meta { color: #8b92a1; font-size: 11px; margin-top: 4px; }
+  .status { padding: 12px 14px; border-radius: 10px; background: #181b21; border: 1px solid #2a2e36; color: #8b92a1; font-size: 13px; max-width: 980px; }
+  .status.error { color: #ef4444; }
+  .status.success { color: #22c55e; }
+  .empty { color: #8b92a1; font-style: italic; padding: 24px; text-align: center; border: 1px dashed #2a2e36; border-radius: 10px; }
+</style>
+</head>
+<body>
+<h1>🛡 Impeccable</h1>
+<p class="lede">UI anti-pattern detector. Catches AI-generated UI tells, accessibility violations, and design quality issues across HTML, CSS, JSX, TSX, Vue, Svelte.</p>
+
+<div class="toolbar">
+  <select id="scope">
+    <option value="src">src/</option>
+    <option value="lib">lib/</option>
+    <option value="components">components/</option>
+    <option value="ui">ui/</option>
+    <option value=".">all (. — root)</option>
+  </select>
+  <button id="scan-btn">Run scan</button>
+  <button id="reload-btn" class="secondary" style="background:transparent;color:#6366f1">Reload</button>
+</div>
+
+<div class="status" id="status">Loading…</div>
+
+<div class="stat-grid" id="stats" style="display:none">
+  <div class="stat"><div class="label">Findings</div><div class="value" id="s-findings">—</div></div>
+  <div class="stat"><div class="label">Exit</div><div class="value" id="s-exit">—</div></div>
+  <div class="stat"><div class="label">Scope</div><div class="value" id="s-scope">—</div></div>
+  <div class="stat"><div class="label">Last scan</div><div class="value" id="s-time">—</div></div>
+</div>
+
+<div class="findings" id="findings"></div>
+
+<script>
+const $ = (id) => document.getElementById(id);
+let busy = false;
+
+async function load() {
+  busy = true;
+  $('scan-btn').disabled = true;
+  try {
+    const r = await fetch('/api/mods/impeccable/state');
+    if (!r.ok) throw new Error('status ' + r.status);
+    const s = await r.json();
+    $('status').className = 'status success';
+    $('status').textContent = `Last scan: ${s.lastScanAt ? new Date(s.lastScanAt).toLocaleString() : 'never'} · ${s.lastFindings ?? 0} findings`;
+    $('stats').style.display = 'grid';
+    $('s-findings').textContent = s.lastFindings ?? 0;
+    $('s-exit').textContent = s.lastExitCode ?? '—';
+    $('s-scope').textContent = s.scope || '—';
+    $('s-time').textContent = s.lastScanAt ? new Date(s.lastScanAt).toLocaleString() : '—';
+    // Try to load findings from /report
+    const rr = await fetch('/api/mods/impeccable/report');
+    if (rr.ok) {
+      const report = await rr.json();
+      renderFindings(report.findings || []);
+    } else {
+      renderFindings([]);
+    }
+  } catch (e) {
+    $('status').className = 'status error';
+    $('status').textContent = 'Load failed: ' + e.message;
+  } finally {
+    busy = false;
+    $('scan-btn').disabled = false;
+  }
+}
+
+function renderFindings(findings) {
+  const root = $('findings');
+  if (!findings.length) {
+    root.innerHTML = '<div class="empty">No findings yet. Run a scan.</div>';
+    return;
+  }
+  root.innerHTML = '';
+  for (const f of findings) {
+    const div = document.createElement('div');
+    div.className = 'finding';
+    div.innerHTML = `<div class="msg">${(f.message || f.rule || JSON.stringify(f)).toString().replace(/[<>&]/g, c => ({'<':'&lt;','>':'&gt;','&':'&amp;'}[c]))}</div>` +
+      `<div class="meta">${f.file || f.path || ''}${f.line ? ':' + f.line : ''} ${f.rule ? '· ' + f.rule : ''}</div>`;
+    root.appendChild(div);
+  }
+}
+
+async function runScan() {
+  if (busy) return;
+  busy = true;
+  $('scan-btn').disabled = true;
+  $('status').className = 'status';
+  $('status').textContent = 'Running impeccable detect…';
+  const scope = $('scope').value;
+  try {
+    const r = await fetch('/api/mods/impeccable/scan', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ scope }),
+    });
+    const data = await r.json();
+    if (!r.ok || data.error) throw new Error(data.message || data.error || 'scan failed');
+    $('status').className = 'status success';
+    $('status').textContent = `Scan complete · ${data.lastFindings} findings · exit ${data.lastExitCode}`;
+    $('stats').style.display = 'grid';
+    $('s-findings').textContent = data.lastFindings;
+    $('s-exit').textContent = data.lastExitCode;
+    $('s-scope').textContent = data.scope;
+    $('s-time').textContent = new Date().toLocaleString();
+    renderFindings(data.findings || []);
+  } catch (e) {
+    $('status').className = 'status error';
+    $('status').textContent = 'Scan failed: ' + e.message;
+  } finally {
+    busy = false;
+    $('scan-btn').disabled = false;
+  }
+}
+
+$('scan-btn').addEventListener('click', runScan);
+$('reload-btn').addEventListener('click', load);
+load();
+</script>
+</body>
+</html>

package/.claude/worktrees/kanban-overhaul/mods-examples/lightrag/INSTRUCTIONS.md

@@ -0,0 +1,81 @@
+---
+name: lightrag-instructions
+description: Always-on rules installed by the LightRAG mod. When the LightRAG server is running, prefer the knowledge graph for cross-document questions before re-reading source files.
+---
+
+# LightRAG — Installed Instructions
+
+These rules apply whenever the **lightrag** mod is enabled and the LightRAG server is running (default port 9621).
+
+## What is LightRAG?
+
+LightRAG is a graph-based Retrieval-Augmented Generation system. It builds a knowledge graph from ingested documents and answers questions by traversing entities and relationships, not just keyword-matching chunks.
+
+The Bizar dashboard exposes a LightRAG view at `/lightrag` that lets you:
+- Insert documents (text, file paths, URLs)
+- Query the knowledge graph (5 modes: local, global, hybrid, naive, mix)
+- Inspect entities and relationships
+- See query history
+
+The HTTP server runs at `http://127.0.0.1:9621` by default. The Bizar dashboard talks to it via the REST API.
+
+## When to Use LightRAG (vs grep / Semble)
+
+**Use LightRAG for:**
+- "What does this codebase say about X?" (semantic, not literal)
+- "What entities relate to Y?" (graph traversal)
+- "Summarize all documentation about Z"
+- "Find all decisions made about authentication"
+- Any cross-document question where grep would give 30+ results
+
+**Use grep / Semble for:**
+- Single-line, single-file lookups
+- "Does the string `TODO` exist?"
+- "Where is function X defined?"
+
+**Use Semble for:**
+- Code-aware semantic search
+- "What calls function X?" (with file:line)
+- "Find the line that handles auth"
+
+LightRAG is for **natural-language questions about content**, not code structure.
+
+## Rules by Agent
+
+### @mimir (research)
+- Before deep-diving into a research question with 20+ tool calls, query the LightRAG knowledge graph first: `POST /query` with the question text. The graph often points you at the right document in 1-2 calls.
+- If LightRAG returns no results, fall back to Semble and grep. Don't force-fit results.
+- After running any new document through LightRAG, the graph updates — query again to see the new context.
+
+### @frigg (Q&A)
+- When the user asks a project-specific question that grep can't answer (e.g. "what did we decide about X?"), check LightRAG first via `POST /query` with the question as the query text.
+- LightRAG returns retrieved context with the answer. Use that as the basis for the response.
+
+### @odin (router)
+- After completing a piece of work that produced documentation (decisions, postmortems, ADRs), consider whether the content should be ingested into LightRAG. If yes, call the dashboard's `/api/mods/lightrag/insert` with the file path.
+
+## API quick reference
+
+```
+POST /query              — body: { query: string, mode: "mix" | "local" | "global" | "hybrid" | "naive" }
+POST /insert/text        — body: { text: string, id?: string }
+POST /insert/file        — body: { path: string }   (file is read and ingested)
+GET  /entities            — list entities
+GET  /relations           — list relationships
+GET  /status              — server health + counts
+```
+
+All endpoints are at `http://127.0.0.1:9621` (or via the dashboard at `/api/mods/lightrag/proxy/*`).
+
+## Common pitfalls
+
+- **Embedding model must be set before indexing.** If you change it, re-embed all text chunks, entities, and relationships. (LightRAG does not provide a re-embedding tool.)
+- **Vector dimension depends on the embedding model.** Some storage backends (e.g. PostgreSQL) require the vector dimension to be defined when creating tables. If you change the embedding model, you may need to drop and recreate the vector tables.
+- **The server binds to 127.0.0.1 by default.** The dashboard proxies requests to it. If you want to access LightRAG from outside the host, set `host: 0.0.0.0` in the mod config.
+- **First query is slow** (~3s) because the graph cache is cold. Subsequent queries are faster.
+
+## See also
+
+- LightRAG docs: https://github.com/HKUDS/LightRAG
+- Bizar mod guide: `.obsidian/reference/mods.md`
+- Dashboard mod config: `Settings → Mods → LightRAG`

package/.claude/worktrees/kanban-overhaul/mods-examples/lightrag/mod.json

@@ -0,0 +1,61 @@
+{
+  "id": "lightrag",
+  "name": "LightRAG",
+  "version": "1.0.0",
+  "author": "BizarHarness",
+  "description": "LightRAG server integration — graph-based RAG for the Bizar dashboard. Auto-starts a LightRAG HTTP server (lightrag-hku[api] Python package) and exposes it as a dashboard view with document insert + query UI. v1.0.0 ships a mod instructions skill that teaches agents to query the knowledge graph for cross-document questions before re-reading source files.",
+  "kind": "server",
+  "entry": {
+    "route": "route.mjs",
+    "view": {
+      "id": "lightrag",
+      "label": "LightRAG",
+      "icon": "Brain",
+      "description": "Graph-based RAG server. Insert documents, query the knowledge graph."
+    }
+  },
+  "permissions": [
+    "process:spawn:lightrag-server",
+    "process:spawn:uv",
+    "process:spawn:uvx",
+    "process:spawn:python3",
+    "process:spawn:curl",
+    "fs:read:.bizar/lightrag",
+    "fs:write:.bizar/lightrag",
+    "fs:read:.obsidian",
+    "fs:write:.obsidian"
+  ],
+  "configSchema": {
+    "host": {
+      "type": "string",
+      "default": "127.0.0.1",
+      "description": "Host the LightRAG server binds to."
+    },
+    "port": {
+      "type": "number",
+      "default": 9621,
+      "description": "Port the LightRAG server binds to."
+    },
+    "autoStart": {
+      "type": "boolean",
+      "default": true,
+      "description": "If true, auto-start the LightRAG server when the mod loads."
+    },
+    "workingDir": {
+      "type": "string",
+      "default": ".bizar/lightrag",
+      "description": "Working directory for the LightRAG server (data persisted here)."
+    },
+    "llmModel": {
+      "type": "string",
+      "default": "minimax/MiniMax-M3",
+      "description": "LLM model to use for entity-relation extraction and query synthesis. Uses the cline provider format."
+    },
+    "embeddingModel": {
+      "type": "string",
+      "default": "text-embedding-3-small",
+      "description": "Embedding model. Must be set before indexing."
+    }
+  },
+  "bizar": ">=3.22.0"
+}