@polderlabs/bizar 4.0.0 → 4.2.0

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

@@ -19,6 +19,7 @@ import { parseFrontmatter, serializeFrontmatter } from './yaml.mjs';
 import { validateNote } from './memory-schema.mjs';
 import { scan as scanSecrets, hasHighFindings } from './memory-secrets.mjs';
 import { atomicWriteJson, safeReadJSON, safeReadText } from '../../../cli/atomic.mjs';
+import * as memoryGit from './memory-git.mjs';
 
 const HOME = homedir();
 const BIZAR_MEMORY_ROOT = join(HOME, '.local', 'share', 'bizar', 'memory');
@@ -333,6 +334,33 @@ export function writeNote(projectRoot, relPath, { frontmatter, body }) {
   const content = `---\n${yamlBlock}\n---\n\n${body}`;
   writeFileSync(filePath, content, 'utf8');
 
+  // Auto-commit the written file to git (if configured).
+  // The lock serializes commits, not writes — concurrent writes will each
+  // trigger their own commit, which is the intended behaviour.
+  (() => {
+    try {
+      if (!memoryGit.isGitInstalled()) return;
+      const { config } = loadConfig(projectRoot);
+      if (config.mode === 'local-only') return;
+      if (config.git?.autoCommitOnMemoryWrite !== true) return;
+      const lockResult = memoryGit.acquireLock(vaultRoot);
+      if (!lockResult || lockResult.error) return; // skip if locked or error
+      try {
+        memoryGit.addFile(vaultRoot, relPath);
+        const summary = frontmatter.title || relPath;
+        const message = (config.git.commitMessageTemplate || 'memory(BizarHarness): {summary}')
+          .replace('{summary}', summary);
+        memoryGit.commit(vaultRoot, message, { author: config.git.commitAuthor });
+      } finally {
+        lockResult.release();
+      }
+    } catch (err) {
+      // Log but never re-throw — the write already succeeded; a failed
+      // auto-commit is recoverable on next write or manual commit.
+      console.error('[memory-store] autoCommitOnMemoryWrite failed:', err?.message || err);
+    }
+  })();
+
   const st = statSync(filePath);
   return {
     relPath,
@@ -422,3 +450,22 @@ export function validateAll(projectRoot) {
   }
   return results;
 }
+
+// ── LightRAG integration (v4.1.0) ──────────────────────────────────────────
+//
+// Re-export the LightRAG orchestrator from the memory-store module so the
+// dashboard, CLI, and tests have a single import surface. The actual
+// implementation lives in `memory-lightrag.mjs`.
+
+export {
+  resolveLightRAGConfig,
+  isInstalled as isLightRAGInstalled,
+  isRunning as isLightRAGRunning,
+  startServer as startLightRAG,
+  stopServer as stopLightRAG,
+  ensureRunning as ensureLightRAGRunning,
+  insertNote as insertLightRAGNote,
+  insertAllNotes as insertLightRAGAll,
+  reindexVault,
+  query as queryLightRAG,
+} from './memory-lightrag.mjs';

package/bizar-dash/src/server/mod-security.mjs

@@ -22,7 +22,7 @@
  *      Path-traversal attacks (e.g. `../`) are blocked.
  *   3. **Subprocess allowlist** — only whitelisted binaries
  *      (`bizar`, `opencode`, `python3`, `graphify`, `git`, `node`,
- *      `npm`, `pip`, `pipx`, `uv`, `rtk`) can be spawned. Custom
+ *      `npm`, `pip`, `pipx`, `uv`, `headroom`) can be spawned. Custom
  *      binaries require an explicit `process:spawn:<bin>` permission.
  *   4. **Audit log** — every privileged operation (fs read/write,
  *      process spawn, network fetch) is logged to
@@ -73,7 +73,7 @@ export const ALLOWED_BINARIES = new Set([
   'npm',
   'npx',
   'git',
-  'rtk',
+  'headroom',
   'jq',
 ]);
 

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

@@ -23,6 +23,28 @@ const { atomicWriteJson } = await import(`${SERVER_ROOT}/../../../cli/atomic.mjs
 
 const { wrap } = await import('./_shared.mjs').then((m) => m);
 
+// Lazy import to avoid circular dependency with memory-lightrag.mjs
+async function getMemoryLightrag() {
+  return import(`${SERVER_ROOT}/memory-lightrag.mjs`).then((m) => m);
+}
+
+/**
+ * Redact apiKey in the lightrag block before sending to the UI.
+ * apiKey '***' means it was already redacted.
+ * Any non-empty string that is not '***' is replaced with '***'.
+ */
+function redactLightRAGConfig(config) {
+  if (!config || !config.lightrag) return config;
+  const { lightrag, ...rest } = config;
+  const redactedLightrag = {
+    ...lightrag,
+    apiKey: lightrag.apiKey && lightrag.apiKey !== '' && lightrag.apiKey !== '***'
+      ? '***'
+      : lightrag.apiKey || undefined,
+  };
+  return { ...rest, lightrag: redactedLightrag };
+}
+
 export function createMemoryRouter({ projectRoot }) {
   const router = Router();
 
@@ -82,12 +104,42 @@ export function createMemoryRouter({ projectRoot }) {
   router.get('/memory/config', wrap(async (_req, res) => {
     const { loadConfig } = memoryStore;
     const { config, exists } = loadConfig(projectRoot);
-    res.json({ exists, config });
+    res.json({ exists, config: redactLightRAGConfig(config) });
   }));
 
   // POST /memory/config
   router.post('/memory/config', wrap(async (req, res) => {
     const { loadConfig, saveConfig } = memoryStore;
+
+    // ── Patch mode: merge only the lightrag block ──────────────────────────
+    if (req.body && req.body.patch === true) {
+      const { writeLightRAGConfig } = await getMemoryLightrag();
+      const { lightrag, patch: _patch, ...restPatch } = req.body;
+
+      // Validate no unexpected top-level fields in patch
+      if (Object.keys(restPatch).length > 0) {
+        res.status(400).json({ error: 'bad_request', message: 'patch mode only accepts a "lightrag" field' });
+        return;
+      }
+      if (!lightrag || typeof lightrag !== 'object') {
+        res.status(400).json({ error: 'bad_request', message: 'patch mode requires a "lightrag" object' });
+        return;
+      }
+
+      const result = writeLightRAGConfig(projectRoot, lightrag);
+      if (!result.ok) {
+        res.status(400).json({ error: 'validation_error', message: result.error });
+        return;
+      }
+
+      // Return full config with redacted lightrag block
+      const { config: full } = loadConfig(projectRoot);
+      const redacted = redactLightRAGConfig(full);
+      res.json({ ok: true, config: redacted });
+      return;
+    }
+
+    // ── Full replace mode (existing behaviour) ───────────────────────────────
     const { config: newConfig, confirm } = req.body || {};
     if (!newConfig || typeof newConfig !== 'object') {
       res.status(400).json({ error: 'bad_request', message: 'body must include config object' });
@@ -111,7 +163,8 @@ export function createMemoryRouter({ projectRoot }) {
       res.status(500).json({ error: 'write_failed', message: result.error });
       return;
     }
-    res.json({ ok: true, config: merged });
+    const redacted = redactLightRAGConfig(merged);
+    res.json({ ok: true, config: redacted });
   }));
 
   // GET /memory/notes
@@ -437,20 +490,34 @@ export function createMemoryRouter({ projectRoot }) {
     res.json({ conflicts });
   }));
 
-  // POST /memory/reindex — STUB
+  // POST /memory/reindex — v4.1.0 real LightRAG population
   router.post('/memory/reindex', wrap(async (_req, res) => {
-    const cacheDir = join(projectRoot, '.bizar', 'memory-cache');
-    if (!existsSync(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
-    }
-    const marker = join(cacheDir, 'last-reindex-attempt.json');
-    const data = {
-      attemptedAt: new Date().toISOString(),
-      ok: false,
-      reason: 'lightrag-not-implemented',
-    };
-    atomicWriteJson(marker, data);
-    res.json({ ok: false, stub: true });
+    const { reindexVault } = memoryStore;
+    const result = await reindexVault(projectRoot, {});
+    if (!result.ok && result.inserted === 0) {
+      res.status(422).json(result);
+      return;
+    }
+    res.json(result);
+  }));
+
+  // GET /memory/query?q=...&topK=10 — merged lexical + semantic search
+  router.get('/memory/query', wrap(async (req, res) => {
+    const q = String(req.query.q || '').trim();
+    if (!q) {
+      res.status(400).json({ error: 'q required' });
+      return;
+    }
+    const topK = Math.min(parseInt(req.query.topK, 10) || 10, 50);
+    const { searchVault, queryLightRAG } = memoryStore;
+    const lexical = searchVault(projectRoot, q, { limit: topK });
+    let semantic = null;
+    try {
+      semantic = await queryLightRAG(projectRoot, q, { topK });
+    } catch (err) {
+      semantic = { ok: false, error: err.message };
+    }
+    res.json({ ok: true, q, lexical, semantic });
   }));
 
   // GET /memory/doctor
@@ -495,5 +562,97 @@ export function createMemoryRouter({ projectRoot }) {
     res.json({ ok: allPassed, checks });
   }));
 
+  // GET /memory/lightrag/status
+  router.get('/memory/lightrag/status', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, isRunning } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const pidFile = join(cfg.workingDir, 'lightrag.pid');
+
+    // Inline readPidAlive logic
+    let pid = null;
+    let alive = false;
+    if (existsSync(pidFile)) {
+      try {
+        pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+        if (Number.isFinite(pid) && pid > 0) {
+          try {
+            process.kill(pid, 0);
+            alive = true;
+          } catch {
+            alive = false;
+          }
+        } else {
+          pid = null;
+        }
+      } catch {
+        pid = null;
+      }
+    }
+
+    const running = alive && (await isRunning(cfg));
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    const logTail = [];
+
+    if (existsSync(logFile)) {
+      try {
+        const content = readFileSync(logFile, 'utf8');
+        const lines = content.split('\n');
+        logTail.push(...lines.slice(-30));
+      } catch {}
+    }
+
+    let lastError = null;
+    if (!running && pid !== null) {
+      lastError = 'process not responding to health checks';
+    }
+
+    res.json({
+      running,
+      pid: running ? pid : null,
+      host: cfg.host,
+      port: cfg.port,
+      llmBinding: cfg.llmBinding,
+      embeddingBinding: cfg.embeddingBinding,
+      llmModel: cfg.llmModel,
+      embeddingModel: cfg.embeddingModel,
+      lastError,
+      logTail,
+    });
+  }));
+
+  // POST /memory/lightrag/start
+  router.post('/memory/lightrag/start', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, startServer } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const result = await startServer(cfg, {});
+    res.json(result);
+  }));
+
+  // POST /memory/lightrag/stop
+  router.post('/memory/lightrag/stop', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig, stopServer } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const result = await stopServer(cfg, {});
+    res.json(result);
+  }));
+
+  // GET /memory/lightrag/log
+  router.get('/memory/lightrag/log', wrap(async (_req, res) => {
+    const { resolveLightRAGConfig } = await getMemoryLightrag();
+    const cfg = resolveLightRAGConfig(projectRoot);
+    const logFile = join(cfg.workingDir, 'lightrag.log');
+    if (!existsSync(logFile)) {
+      res.json({ lines: [] });
+      return;
+    }
+    try {
+      const content = readFileSync(logFile, 'utf8');
+      const lines = content.split('\n');
+      res.json({ lines: lines.slice(-200) });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  }));
+
   return router;
 }

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

@@ -302,7 +302,7 @@ export async function createServer({
   }
   currentBroadcast = localBroadcast;
 
-  const apiRouter = createApiRouter({
+  const apiRouter = await createApiRouter({
     state,
     watcher,
     projectRoot,

package/bizar-dash/src/server/state.mjs

@@ -13,7 +13,7 @@
  *   - getChat:      per-project sessions/<id>.jsonl (preferred) — falls
  *                   back to legacy .bizar/sessions if no project is active
  *   - getAgents:    ~/.config/opencode/agents/*.md (frontmatter parse)
- *   - getArtifacts:     scans artifacts/ (worktree) and ~/.config/opencode/artifacts/
+ *   - getArtifacts:     scans .bizar/artifacts/ (worktree) and ~/.config/opencode/artifacts/
  */
 import {
   existsSync,
@@ -47,7 +47,7 @@ export function createState({ projectRoot, opencodeConfigDir, bizarRoot }) {
     bizarDir: join(projectRoot, '.bizar'),
     sessionsDir: join(projectRoot, '.bizar', 'sessions'),
     activityLog: join(projectRoot, '.bizar', 'activity.log'),
-    plansDir: join(projectRoot, 'artifacts'),
+    plansDir: join(projectRoot, '.bizar', 'artifacts'),
     globalPlansDir: join(opencodeConfigDir, 'artifacts'),
     settingsFile: join(HOME, '.config', 'bizar', 'settings.json'),
   };