@polderlabs/bizar 4.4.13 → 4.5.1

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

@@ -12,7 +12,8 @@
 import { Router } from 'express';
 import { join, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { existsSync, mkdirSync, readFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, statSync, readdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
 
 const SERVER_ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const memoryStore = await import(`${SERVER_ROOT}/memory-store.mjs`).then((m) => m);
@@ -512,11 +513,17 @@ export function createMemoryRouter({ projectRoot }) {
     const { searchVault, queryLightRAG } = memoryStore;
     const lexical = searchVault(projectRoot, q, { limit: topK });
     let semantic = null;
+    const startedAt = Date.now();
     try {
       semantic = await queryLightRAG(projectRoot, q, { topK });
     } catch (err) {
       semantic = { ok: false, error: err.message };
     }
+    // Record the query duration for the LightRAG stats panel. Best-effort.
+    try {
+      const { recordQuery } = await getMemoryLightrag();
+      recordQuery(projectRoot, Date.now() - startedAt);
+    } catch { /* ignore */ }
     res.json({ ok: true, q, lexical, semantic });
   }));
 
@@ -654,5 +661,665 @@ export function createMemoryRouter({ projectRoot }) {
     }
   }));
 
+  // ── v4.6.0 Global memory-config surface ─────────────────────────────────
+  //
+  // A second config file at `~/.config/bizar/memory-config.json` holds
+  // operator-facing settings that aren't tied to a single project —
+  // e.g. the global default LightRAG URL, the global obsidian vault
+  // path, and git push defaults. The Settings view (handled by the
+  // sibling thor-settings agent) reads + writes this file via these
+  // endpoints.
+  //
+  // Distinct from the per-project `.bizar/memory.json` (the existing
+  // /memory/config surfaces that). We use a separate path to keep the
+  // two systems cleanly separated.
+
+  const GLOBAL_MEMORY_CONFIG_PATH = join(
+    process.env.HOME || '/tmp',
+    '.config',
+    'bizar',
+    'memory-config.json',
+  );
+
+  function loadGlobalMemoryConfig() {
+    try {
+      if (!existsSync(GLOBAL_MEMORY_CONFIG_PATH)) {
+        return {
+          exists: false,
+          config: {
+            lightrag: { enabled: false, url: 'http://127.0.0.1:9621', llm: '', embedding: '' },
+            obsidian: { vaultPath: '', syncInterval: 300 },
+            git: { repoPath: '', remoteUrl: '', branch: 'main', autoSync: false },
+          },
+        };
+      }
+      const raw = JSON.parse(readFileSync(GLOBAL_MEMORY_CONFIG_PATH, 'utf8'));
+      return { exists: true, config: raw };
+    } catch {
+      return {
+        exists: false,
+        error: 'corrupt_json',
+        config: {
+          lightrag: { enabled: false, url: 'http://127.0.0.1:9621', llm: '', embedding: '' },
+          obsidian: { vaultPath: '', syncInterval: 300 },
+          git: { repoPath: '', remoteUrl: '', branch: 'main', autoSync: false },
+        },
+      };
+    }
+  }
+
+  function saveGlobalMemoryConfig(config) {
+    const dir = dirname(GLOBAL_MEMORY_CONFIG_PATH);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    atomicWriteJson(GLOBAL_MEMORY_CONFIG_PATH, config);
+  }
+
+  // GET /memory/config/global — grouped shape (lightrag/obsidian/git).
+  router.get('/memory/config/global', wrap(async (_req, res) => {
+    const { exists, config, error } = loadGlobalMemoryConfig();
+    res.json({
+      exists,
+      path: GLOBAL_MEMORY_CONFIG_PATH,
+      config,
+      ...(error ? { error } : {}),
+    });
+  }));
+
+  // PUT /memory/config/global — partial update. Validates each block
+  // and merges on top of the existing config.
+  router.put('/memory/config/global', wrap(async (req, res) => {
+    const body = req.body || {};
+    const { exists, config: existing } = loadGlobalMemoryConfig();
+
+    // Light validation — no zod import (keep surface small). Each
+    // block is shallow-merged; if a block is present, we shallow-merge
+    // its top-level fields, rejecting unknown top-level keys.
+    const next = JSON.parse(JSON.stringify(existing));
+
+    const VALID_TOP_KEYS = new Set(['lightrag', 'obsidian', 'git']);
+    const EXTRA_KEYS = Object.keys(body).filter((k) => !VALID_TOP_KEYS.has(k));
+    if (EXTRA_KEYS.length > 0) {
+      res.status(400).json({
+        error: 'bad_request',
+        message: `unknown top-level keys: ${EXTRA_KEYS.join(', ')}`,
+      });
+      return;
+    }
+
+    if (body.lightrag !== undefined) {
+      if (typeof body.lightrag !== 'object' || body.lightrag === null || Array.isArray(body.lightrag)) {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag must be an object' });
+        return;
+      }
+      const l = body.lightrag;
+      if ('enabled' in l && typeof l.enabled !== 'boolean') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.enabled must be boolean' });
+        return;
+      }
+      if ('url' in l && typeof l.url !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.url must be a string' });
+        return;
+      }
+      if ('llm' in l && typeof l.llm !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.llm must be a string' });
+        return;
+      }
+      if ('embedding' in l && typeof l.embedding !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'lightrag.embedding must be a string' });
+        return;
+      }
+      next.lightrag = { ...next.lightrag, ...l };
+    }
+
+    if (body.obsidian !== undefined) {
+      if (typeof body.obsidian !== 'object' || body.obsidian === null || Array.isArray(body.obsidian)) {
+        res.status(400).json({ error: 'bad_request', message: 'obsidian must be an object' });
+        return;
+      }
+      const o = body.obsidian;
+      if ('vaultPath' in o && typeof o.vaultPath !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'obsidian.vaultPath must be a string' });
+        return;
+      }
+      if ('syncInterval' in o) {
+        const n = Number(o.syncInterval);
+        if (!Number.isFinite(n) || n < 0 || n > 86400 * 30) {
+          res.status(400).json({ error: 'bad_request', message: 'obsidian.syncInterval must be 0..2592000 seconds' });
+          return;
+        }
+        next.obsidian.syncInterval = n;
+      }
+      if ('vaultPath' in o) next.obsidian.vaultPath = o.vaultPath;
+    }
+
+    if (body.git !== undefined) {
+      if (typeof body.git !== 'object' || body.git === null || Array.isArray(body.git)) {
+        res.status(400).json({ error: 'bad_request', message: 'git must be an object' });
+        return;
+      }
+      const g = body.git;
+      if ('repoPath' in g && typeof g.repoPath !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'git.repoPath must be a string' });
+        return;
+      }
+      if ('remoteUrl' in g && typeof g.remoteUrl !== 'string') {
+        res.status(400).json({ error: 'bad_request', message: 'git.remoteUrl must be a string' });
+        return;
+      }
+      if ('branch' in g) {
+        if (typeof g.branch !== 'string' || !/^[A-Za-z0-9._/-]{1,200}$/.test(g.branch)) {
+          res.status(400).json({ error: 'bad_request', message: 'git.branch must be a valid git ref name' });
+          return;
+        }
+        next.git.branch = g.branch;
+      }
+      if ('autoSync' in g && typeof g.autoSync !== 'boolean') {
+        res.status(400).json({ error: 'bad_request', message: 'git.autoSync must be boolean' });
+        return;
+      }
+      if ('repoPath' in g) next.git.repoPath = g.repoPath;
+      if ('remoteUrl' in g) next.git.remoteUrl = g.remoteUrl;
+      if ('autoSync' in g) next.git.autoSync = g.autoSync;
+    }
+
+    try {
+      saveGlobalMemoryConfig(next);
+    } catch (err) {
+      res.status(500).json({ error: 'write_failed', message: err.message });
+      return;
+    }
+    res.json({ ok: true, exists: true, path: GLOBAL_MEMORY_CONFIG_PATH, config: next });
+  }));
+
+  // POST /memory/test-git — test the configured git repo. Returns:
+  //   { ok: bool, checks: [...], message?: string }
+  // Steps performed:
+  //   1. Path exists?
+  //   2. Is a directory?
+  //   3. Is a valid git repo (has .git/)?
+  //   4. (Optional) Has a configured remote?
+  //   5. (Optional) Can we push (skipped unless ?push=1)?
+  router.post('/memory/test-git', wrap(async (req, res) => {
+    const { config } = loadGlobalMemoryConfig();
+    const repoPath = config?.git?.repoPath || '';
+    const remoteUrl = config?.git?.remoteUrl || '';
+    const wantPush = req.query.push === '1' || req.body?.push === true;
+
+    const checks = [];
+    if (!repoPath) {
+      checks.push({ name: 'repo_path_set', pass: false, detail: 'git.repoPath is empty — set it in Settings first' });
+      res.json({ ok: false, checks, message: 'repo path not configured' });
+      return;
+    }
+
+    checks.push({
+      name: 'repo_path_exists',
+      pass: existsSync(repoPath),
+      detail: existsSync(repoPath) ? repoPath : `${repoPath} does not exist`,
+    });
+
+    let isGit = false;
+    let isDir = false;
+    try {
+      const s = statSync(repoPath);
+      isDir = s.isDirectory();
+      checks.push({ name: 'repo_is_directory', pass: isDir, detail: isDir ? 'yes' : 'not a directory' });
+    } catch (err) {
+      checks.push({ name: 'repo_is_directory', pass: false, detail: err.message });
+    }
+
+    if (isDir) {
+      isGit = existsSync(join(repoPath, '.git'));
+      checks.push({ name: 'is_git_repo', pass: isGit, detail: isGit ? 'yes' : 'no .git/ directory' });
+    } else {
+      checks.push({ name: 'is_git_repo', pass: false, detail: 'skipped (not a directory)' });
+    }
+
+    if (remoteUrl) {
+      checks.push({ name: 'remote_url_set', pass: true, detail: remoteUrl });
+    } else {
+      checks.push({ name: 'remote_url_set', pass: false, detail: 'no remote configured' });
+    }
+
+    if (wantPush && isGit && remoteUrl) {
+      try {
+        const out = execFileSync('git', ['ls-remote', '--heads', remoteUrl], { timeout: 5000 }).toString();
+        checks.push({ name: 'remote_reachable', pass: true, detail: `${out.split('\n').filter(Boolean).length} heads` });
+      } catch (err) {
+        checks.push({ name: 'remote_reachable', pass: false, detail: err.message });
+      }
+    }
+
+    const ok = checks.every((c) => c.pass);
+    res.json({
+      ok,
+      checks,
+      message: ok ? 'git config looks healthy' : 'one or more checks failed',
+    });
+  }));
+
+  // ── v4.7.0 — Memory tab endpoints ─────────────────────────────────────────
+  //
+  // These endpoints are the canonical surface for the dedicated Memory
+  // tab. They sit alongside the per-resource endpoints above and return
+  // the shapes the React panels expect (always objects, never arrays).
+
+  // GET /memory/health — composite health score (0..100) + breakdown.
+  // Components:
+  //   - vaultExists      (vault dir on disk)
+  //   - vaultWritable    (can write a temp file and unlink it)
+  //   - gitClean         (mode is managed/linked AND `git status` is clean)
+  //   - lightragRunning  (server up + health check ok)
+  //   - schemaValid      (no validation errors across the vault)
+  //   - secretsClean     (no HIGH-severity secret findings)
+  router.get('/memory/health', wrap(async (_req, res) => {
+    const { resolveVault, loadConfig, listNotes, validateAll, scanForSecrets } = memoryStore;
+    const { isGitInstalled, status: gitStatus } = memoryGit;
+
+    const checks = [];
+    let score = 0;
+
+    const { exists, config } = loadConfig(projectRoot);
+    if (!exists) {
+      res.json({
+        score: 0,
+        status: 'unconfigured',
+        checks: [{ name: 'config', pass: false, detail: 'memory not initialised' }],
+        message: 'memory not initialised — run `bizar memory init`',
+      });
+      return;
+    }
+
+    const { vaultRoot, mode } = resolveVault(projectRoot);
+    const vaultExists = existsSync(vaultRoot);
+    checks.push({
+      name: 'vault_exists',
+      pass: vaultExists,
+      detail: vaultExists ? vaultRoot : 'vault directory missing',
+    });
+    if (vaultExists) score += 20;
+
+    // Writable?
+    let writable = false;
+    if (vaultExists) {
+      try {
+        const probe = join(vaultRoot, '.health-probe.tmp');
+        writeFileSync(probe, 'ok');
+        try {
+          const { unlinkSync } = await import('node:fs');
+          unlinkSync(probe);
+        } catch { /* best effort */ }
+        writable = true;
+      } catch {
+        writable = false;
+      }
+    }
+    checks.push({ name: 'vault_writable', pass: writable, detail: writable ? 'yes' : 'no' });
+    if (writable) score += 10;
+
+    // Git clean?
+    let gitClean = null;
+    if ((mode === 'managed' || mode === 'linked') && vaultExists && isGitInstalled()) {
+      const gs = gitStatus(vaultRoot);
+      gitClean = gs.clean;
+      checks.push({
+        name: 'git_clean',
+        pass: gs.clean,
+        detail: gs.clean ? 'working tree clean' : `${(gs.modified?.length || 0) + (gs.untracked?.length || 0)} pending`,
+      });
+      if (gs.clean) score += 20;
+    } else if (mode === 'local-only') {
+      checks.push({ name: 'git_clean', pass: true, detail: 'local-only mode (no git)' });
+      // local-only mode shouldn't penalise — count as clean
+      score += 20;
+    } else {
+      checks.push({ name: 'git_clean', pass: false, detail: 'git not installed or vault missing' });
+    }
+
+    // LightRAG running?
+    let lightragRunning = false;
+    try {
+      const { resolveLightRAGConfig, isRunning } = await getMemoryLightrag();
+      const cfg = resolveLightRAGConfig(projectRoot);
+      lightragRunning = await isRunning(cfg);
+    } catch {
+      lightragRunning = false;
+    }
+    checks.push({
+      name: 'lightrag_running',
+      pass: lightragRunning,
+      detail: lightragRunning ? 'yes' : 'stopped or disabled',
+    });
+    if (lightragRunning) score += 20;
+
+    // Schema valid?
+    let invalidCount = 0;
+    if (vaultExists) {
+      const validationResults = validateAll(projectRoot);
+      invalidCount = validationResults.length;
+    }
+    checks.push({
+      name: 'schema_valid',
+      pass: invalidCount === 0,
+      detail: invalidCount === 0 ? 'all notes valid' : `${invalidCount} invalid`,
+    });
+    if (invalidCount === 0 && vaultExists) score += 15;
+
+    // Secrets clean?
+    let highFindings = 0;
+    if (vaultExists) {
+      for (const n of listNotes(projectRoot)) {
+        const r = scanForSecrets(projectRoot, n.relPath);
+        if (!r.safe) {
+          for (const f of r.findings) {
+            if (f.severity === 'HIGH') highFindings++;
+          }
+        }
+      }
+    }
+    checks.push({
+      name: 'secrets_clean',
+      pass: highFindings === 0,
+      detail: highFindings === 0 ? 'no HIGH-severity secrets' : `${highFindings} HIGH finding(s)`,
+    });
+    if (highFindings === 0) score += 15;
+
+    const status = score >= 80 ? 'healthy' : score >= 50 ? 'degraded' : 'unhealthy';
+    res.json({
+      score,
+      status,
+      checks,
+      message:
+        status === 'healthy' ? 'memory system healthy' :
+        status === 'degraded' ? 'one or more subsystems need attention' :
+        'multiple subsystems failing',
+    });
+  }));
+
+  // GET /memory/storage — disk-usage summary for the Memory tab.
+  // Walks the vault + .bizar/memory-cache + lightrag working dir.
+  router.get('/memory/storage', wrap(async (_req, res) => {
+    const { resolveVault } = memoryStore;
+    const { vaultRoot, mode } = resolveVault(projectRoot);
+
+    const targets = [];
+    if (existsSync(vaultRoot)) targets.push({ name: 'vault', path: vaultRoot });
+    const cacheDir = join(projectRoot, '.bizar', 'memory-cache');
+    if (existsSync(cacheDir)) targets.push({ name: 'memory-cache', path: cacheDir });
+    const lightragDir = join(projectRoot, '.bizar', 'lightrag');
+    if (existsSync(lightragDir)) targets.push({ name: 'lightrag', path: lightragDir });
+
+    let total = 0;
+    const breakdown = targets.map((t) => {
+      const size = dirSize(t.path);
+      total += size;
+      return { name: t.name, path: t.path, size };
+    });
+
+    res.json({
+      total,
+      breakdown,
+      mode,
+      vaultRoot,
+      message: total === 0 ? 'no memory data on disk yet' : `${formatBytes(total)} on disk`,
+    });
+  }));
+
+  // GET /memory/git/diff — textual diff of the working tree (last commit vs HEAD).
+  // Returns { hasDiff, lines, files } — `lines` is a flat unified-diff-ish view.
+  router.get('/memory/git/diff', wrap(async (_req, res) => {
+    const { resolveVault } = memoryStore;
+    const { isGitInstalled } = memoryGit;
+    const { vaultRoot, mode } = resolveVault(projectRoot);
+
+    if (mode === 'local-only') {
+      res.json({ hasDiff: false, lines: [], files: [], mode: 'local-only' });
+      return;
+    }
+    if (!isGitInstalled()) {
+      res.status(503).json({ error: 'git_not_installed' });
+      return;
+    }
+
+    let raw = '';
+    try {
+      raw = execFileSync('git', ['diff', '--no-color', '--no-ext-diff'], {
+        cwd: vaultRoot,
+        encoding: 'utf8',
+        maxBuffer: 8 * 1024 * 1024,
+      });
+    } catch (err) {
+      res.status(500).json({ error: 'diff_failed', message: err.message });
+      return;
+    }
+
+    // Also include untracked file names.
+    let untracked = [];
+    try {
+      const statusRaw = execFileSync('git', ['status', '--porcelain'], {
+        cwd: vaultRoot,
+        encoding: 'utf8',
+      });
+      for (const line of statusRaw.split('\n')) {
+        if (line.startsWith('??')) untracked.push(line.slice(3).trim());
+      }
+    } catch {
+      /* ignore */
+    }
+
+    const lines = raw.split('\n');
+    const files = [];
+    for (const line of lines) {
+      if (line.startsWith('diff --git ')) {
+        const m = line.match(/^diff --git a\/(.+) b\/(.+)$/);
+        if (m) files.push(m[2]);
+      }
+    }
+    for (const u of untracked) {
+      if (!files.includes(u)) files.push(u);
+    }
+
+    res.json({
+      hasDiff: lines.length > 1 || untracked.length > 0,
+      lines,
+      files,
+      mode,
+    });
+  }));
+
+  // GET /memory/lightrag/stats — aggregate stats for the LightRAG panel.
+  router.get('/memory/lightrag/stats', wrap(async (_req, res) => {
+    try {
+      const { stats } = await getMemoryLightrag();
+      const data = await stats(projectRoot);
+      res.json(data);
+    } catch (err) {
+      res.status(500).json({ error: 'stats_failed', message: err.message });
+    }
+  }));
+
+  // POST /memory/lightrag/reindex — alias of /memory/reindex (the canonical
+  // path lives there for backwards compat). Both return the same shape.
+  router.post('/memory/lightrag/reindex', wrap(async (_req, res) => {
+    const { reindexVault } = memoryStore;
+    const result = await reindexVault(projectRoot, {});
+    res.json(result);
+  }));
+
+  // POST /memory/lightrag/rebuild-graph — nuke the working dir + reindex.
+  router.post('/memory/lightrag/rebuild-graph', wrap(async (_req, res) => {
+    try {
+      const { rebuildGraph } = await getMemoryLightrag();
+      const result = await rebuildGraph(projectRoot, {});
+      res.json(result);
+    } catch (err) {
+      res.status(500).json({ error: 'rebuild_failed', message: err.message });
+    }
+  }));
+
+  // GET /memory/obsidian/tree — recursive folder tree for the Memory browser.
+  router.get('/memory/obsidian/tree', wrap(async (_req, res) => {
+    try {
+      const obsidian = await import(`${SERVER_ROOT}/memory-obsidian.mjs`);
+      const node = obsidian.tree(projectRoot);
+      res.json({ tree: node });
+    } catch (err) {
+      res.status(500).json({ error: 'tree_failed', message: err.message });
+    }
+  }));
+
+  // GET /memory/obsidian/backlinks?note=path/to/note.md
+  router.get('/memory/obsidian/backlinks', wrap(async (req, res) => {
+    const note = String(req.query.note || '').trim();
+    if (!note) {
+      res.status(400).json({ error: 'bad_request', message: 'note query param required' });
+      return;
+    }
+    try {
+      const obsidian = await import(`${SERVER_ROOT}/memory-obsidian.mjs`);
+      const links = obsidian.listBacklinks(projectRoot, note);
+      res.json({ note, backlinks: links });
+    } catch (err) {
+      res.status(500).json({ error: 'backlinks_failed', message: err.message });
+    }
+  }));
+
+  // GET /memory/obsidian/notes?path=...&limit=...
+  // Query-string variant of the canonical /memory/notes endpoint. Used by
+  // the ObsidianPanel folder browser which knows the parent path.
+  router.get('/memory/obsidian/notes', wrap(async (req, res) => {
+    const { listNotes } = memoryStore;
+    const all = listNotes(projectRoot);
+    const path = String(req.query.path || '').trim();
+    const limit = Math.min(parseInt(req.query.limit, 10) || 100, 500);
+    let notes = all;
+    if (path) {
+      notes = all.filter((n) => n.relPath.startsWith(path));
+    }
+    notes = notes.slice(0, limit);
+    res.json({ path: path || null, count: notes.length, notes });
+  }));
+
+  // PUT /memory/notes/* — update an existing note (or create).
+  router.put('/memory/notes/*', wrap(async (req, res) => {
+    const { writeNote } = memoryStore;
+    const relPath = req.params[0];
+    const { frontmatter, body } = req.body || {};
+    if (!relPath) {
+      res.status(400).json({ error: 'bad_request', message: 'path is required' });
+      return;
+    }
+    if (!relPath.endsWith('.md')) {
+      res.status(400).json({ error: 'bad_request', message: 'path must end in .md' });
+      return;
+    }
+    try {
+      const note = writeNote(projectRoot, relPath, { frontmatter: frontmatter || {}, body: body || '' });
+      res.json(note);
+    } catch (err) {
+      if (err.code === 'SCHEMA_VALIDATION_FAILED' || err.code === 'SECRET_DETECTED') {
+        res.status(400).json({ error: err.code, message: err.message, findings: err.findings });
+      } else {
+        res.status(400).json({ error: 'bad_request', message: err.message });
+      }
+    }
+  }));
+
+  // POST /memory/semantic-search — cross-source search.
+  // Body: { query: string, limit?: number, sources?: Array<'lightrag'|'obsidian'> }
+  router.post('/memory/semantic-search', wrap(async (req, res) => {
+    const body = req.body || {};
+    const query = String(body.query || '').trim();
+    if (!query) {
+      res.status(400).json({ error: 'bad_request', message: 'query is required' });
+      return;
+    }
+    const limit = Math.min(parseInt(body.limit, 10) || 10, 50);
+    const requestedSources = Array.isArray(body.sources) && body.sources.length > 0
+      ? new Set(body.sources.map((s) => String(s).toLowerCase()))
+      : new Set(['lightrag', 'obsidian']);
+
+    const results = [];
+    if (requestedSources.has('obsidian')) {
+      const { searchVault } = memoryStore;
+      const lex = searchVault(projectRoot, query, { limit });
+      for (const r of lex) {
+        results.push({
+          source: 'obsidian',
+          relPath: r.relPath,
+          snippet: r.snippet,
+          score: r.score,
+          mtime: r.mtime,
+        });
+      }
+    }
+    if (requestedSources.has('lightrag')) {
+      try {
+        const { resolveLightRAGConfig, query: lightragQuery } = await getMemoryLightrag();
+        const cfg = resolveLightRAGConfig(projectRoot);
+        const r = await lightragQuery(cfg, query, { topK: limit });
+        if (r.ok && r.response) {
+          // LightRAG's response shape varies by mode; coerce to a snippet.
+          const text = typeof r.response === 'string'
+            ? r.response
+            : (r.response?.response || r.response?.answer || JSON.stringify(r.response));
+          results.push({
+            source: 'lightrag',
+            relPath: null,
+            snippet: String(text).slice(0, 500),
+            score: 1,
+            mtime: null,
+            raw: r.response,
+          });
+        }
+      } catch (err) {
+        results.push({ source: 'lightrag', error: err.message });
+      }
+    }
+
+    // Dedupe by (source, relPath), keep highest score.
+    const seen = new Map();
+    for (const r of results) {
+      const key = `${r.source}|${r.relPath || '_query_'}`;
+      const prev = seen.get(key);
+      if (!prev || (r.score || 0) > (prev.score || 0)) {
+        seen.set(key, r);
+      }
+    }
+    const deduped = [...seen.values()].sort((a, b) => (b.score || 0) - (a.score || 0));
+
+    res.json({ query, count: deduped.length, results: deduped });
+  }));
+
   return router;
 }
+
+/**
+ * Recursively sum file sizes under `dir`. Returns 0 if dir doesn't exist.
+ */
+function dirSize(dir) {
+  let total = 0;
+  function walk(d) {
+    let st;
+    try { st = statSync(d); } catch { return; }
+    if (st.isFile()) { total += st.size; return; }
+    if (!st.isDirectory()) return;
+    let entries;
+    try { entries = readdirSync(d, { withFileTypes: true }); } catch { return; }
+    for (const e of entries) {
+      if (e.name.startsWith('.')) continue;
+      walk(join(d, e.name));
+    }
+  }
+  walk(dir);
+  return total;
+}
+
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1024 * 1024) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1024 * 1024 * 1024) return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(n / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}