@polderlabs/bizar 4.0.0 → 4.2.0

package/bizar-dash/tests/memory-config.test.mjs

@@ -0,0 +1,422 @@
+/**
+ * tests/memory-config.test.mjs
+ *
+ * Tests for writeLightRAGConfig, patch-mode POST /memory/config,
+ * redact behaviour, and LightRAG lifecycle endpoints.
+ */
+
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import http from 'node:http';
+
+const httpGet = (port, path) =>
+  new Promise((resolve) => {
+    const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+      let body = '';
+      res.on('data', (c) => (body += c));
+      res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(body || '{}') }));
+    });
+    req.end();
+  });
+
+const httpPost = (port, path, body) =>
+  new Promise((resolve) => {
+    const data = JSON.stringify(body);
+    const req = http.request(
+      { hostname: 'localhost', port, path, method: 'POST', headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(data) } },
+      (res) => {
+        let respBody = '';
+        res.on('data', (c) => (respBody += c));
+        res.on('end', () => resolve({ status: res.statusCode, body: JSON.parse(respBody || '{}') }));
+      },
+    );
+    req.write(data);
+    req.end();
+  });
+
+const {
+  writeLightRAGConfig,
+  resolveLightRAGConfig,
+} = await import('../src/server/memory-lightrag.mjs');
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+function makeTmp() {
+  const root = join(tmpdir(), `bizar-lightrag-cfg-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(root, { recursive: true });
+  mkdirSync(join(root, '.bizar'), { recursive: true });
+  return root;
+}
+
+async function buildApp(projectRoot) {
+  const { createMemoryRouter } = await import('../src/server/routes/memory.mjs');
+  const express = (await import('express')).default;
+  const app = express();
+  app.use(express.json());
+  app.use('/api', createMemoryRouter({ projectRoot }));
+  return app;
+}
+
+async function withApp(projectRoot, fn) {
+  const app = await buildApp(projectRoot);
+  const server = app.listen(0);
+  const port = server.address().port;
+  try {
+    return await fn(port);
+  } finally {
+    server.close();
+  }
+}
+
+// ── writeLightRAGConfig — unit tests ─────────────────────────────────────────
+
+describe('writeLightRAGConfig', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('deep-merges into existing lightrag block', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { enabled: false, port: 8000, llmModel: 'gpt-4o' },
+    }));
+
+    const result = writeLightRAGConfig(root, { enabled: true, port: 9000 });
+    assert.equal(result.ok, true);
+
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.lightrag.enabled, true);
+    assert.equal(mem.lightrag.port, 9000);
+    assert.equal(mem.lightrag.llmModel, 'gpt-4o'); // preserved
+  });
+
+  test('validates llmBinding is in known set', () => {
+    const result = writeLightRAGConfig(root, { llmBinding: 'not-a-binding' });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('llmBinding'));
+  });
+
+  test('validates embeddingBinding is in known set', () => {
+    const result = writeLightRAGConfig(root, { embeddingBinding: 'bad-embedding' });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('embeddingBinding'));
+  });
+
+  test('rejects port out of range (0)', () => {
+    const result = writeLightRAGConfig(root, { port: 0 });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('port'));
+  });
+
+  test('rejects port out of range (66666)', () => {
+    const result = writeLightRAGConfig(root, { port: 66666 });
+    assert.equal(result.ok, false);
+    assert.ok(result.error.includes('port'));
+  });
+
+  test('accepts port 1 and 65535', () => {
+    let r = writeLightRAGConfig(root, { port: 1 });
+    assert.equal(r.ok, true);
+    r = writeLightRAGConfig(root, { port: 65535 });
+    assert.equal(r.ok, true);
+  });
+
+  test('canonicalises <empty> to empty string for apiKey', () => {
+    const r = writeLightRAGConfig(root, { apiKey: '<empty>' });
+    assert.equal(r.ok, true);
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.lightrag.apiKey, '');
+  });
+
+  test('atomic — old or new file present after concurrent writes', () => {
+    writeLightRAGConfig(root, { port: 10000 });
+    for (let i = 0; i < 20; i++) {
+      writeLightRAGConfig(root, { port: i + 1 });
+    }
+    const content = readFileSync(join(root, '.bizar', 'memory.json'), 'utf8');
+    const parsed = JSON.parse(content);
+    assert.equal(parsed.lightrag.port, 20);
+  });
+
+  test('creates .bizar/memory.json if missing', () => {
+    const fresh = join(tmpdir(), `bizar-fresh-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(fresh, { recursive: true });
+    try {
+      const r = writeLightRAGConfig(fresh, { port: 5000 });
+      assert.equal(r.ok, true);
+      assert.ok(existsSync(join(fresh, '.bizar', 'memory.json')));
+      const mem = JSON.parse(readFileSync(join(fresh, '.bizar', 'memory.json'), 'utf8'));
+      assert.equal(mem.lightrag.port, 5000);
+    } finally {
+      rmSync(fresh, { recursive: true, force: true });
+    }
+  });
+
+  test('preserves non-lightrag fields when merging', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      projectId: 'test-proj',
+      memoryRepo: { mode: 'local-only' },
+      lightrag: { port: 7000 },
+    }));
+    const r = writeLightRAGConfig(root, { llmModel: 'claude-3' });
+    assert.equal(r.ok, true);
+    const mem = JSON.parse(readFileSync(join(root, '.bizar', 'memory.json'), 'utf8'));
+    assert.equal(mem.projectId, 'test-proj');
+    assert.equal(mem.lightrag.llmModel, 'claude-3');
+    assert.equal(mem.lightrag.port, 7000);
+  });
+});
+
+// ── resolveLightRAGConfig — apiKey defaults ───────────────────────────────────
+
+describe('resolveLightRAGConfig apiKey defaults', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('defaults apiKey to "env" when not set', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      lightrag: { port: 9621 },
+    }));
+    const cfg = resolveLightRAGConfig(root);
+    assert.equal(cfg.apiKey, 'env');
+    assert.equal(cfg.apiKeySource, 'env');
+  });
+
+  test('reads existing apiKeySource', () => {
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      lightrag: { port: 9621, apiKey: 'sk-123', apiKeySource: 'file' },
+    }));
+    const cfg = resolveLightRAGConfig(root);
+    assert.equal(cfg.apiKey, 'sk-123');
+    assert.equal(cfg.apiKeySource, 'file');
+  });
+});
+
+// ── HTTP route integration tests ─────────────────────────────────────────────
+
+describe('POST /api/memory/config patch mode', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, llmModel: 'original-model' },
+    }));
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns merged config with redacted apiKey', async () => {
+    writeLightRAGConfig(root, { apiKey: 'sk-secret123', apiKeySource: 'file' });
+
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', {
+        patch: true,
+        lightrag: { port: 5000 },
+      });
+      assert.equal(res.status, 200);
+      assert.equal(res.body.ok, true);
+      assert.equal(res.body.config.lightrag.port, 5000);
+      assert.equal(res.body.config.lightrag.llmModel, 'original-model');
+      // apiKey must be redacted
+      assert.equal(res.body.config.lightrag.apiKey, '***');
+    });
+  });
+
+  test('rejects patch without lightrag field', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, foo: 'bar' });
+      assert.equal(res.status, 400);
+    });
+  });
+
+  test('rejects unknown top-level fields in patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 1 }, mode: 'managed' });
+      assert.equal(res.status, 400);
+    });
+  });
+
+  test('validates port range through patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { port: 99999 } });
+      assert.equal(res.status, 400);
+      assert.ok(res.body.message.includes('port'));
+    });
+  });
+
+  test('validates llmBinding through patch', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/config', { patch: true, lightrag: { llmBinding: 'invalid' } });
+      assert.equal(res.status, 400);
+      assert.ok(res.body.message.includes('llmBinding'));
+    });
+  });
+});
+
+describe('GET /api/memory/config — redaction', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, apiKey: 'sk-abc123', apiKeySource: 'file' },
+    }));
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('GET /memory/config redacts apiKey to ***', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/config');
+      assert.equal(res.status, 200);
+      assert.equal(res.body.config.lightrag.apiKey, '***');
+      assert.equal(res.body.config.lightrag.apiKeySource, 'file');
+    });
+  });
+});
+
+describe('GET /api/memory/lightrag/status', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621, llmBinding: 'ollama', embeddingBinding: 'ollama', llmModel: 'test-model', embeddingModel: 'test-embed' },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns running:false when server not running', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/status');
+      assert.equal(res.status, 200);
+      assert.equal(res.body.running, false);
+      assert.equal(res.body.pid, null);
+      assert.equal(res.body.port, 9621);
+      assert.equal(res.body.llmBinding, 'ollama');
+      assert.equal(res.body.embeddingBinding, 'ollama');
+    });
+  });
+});
+
+describe('POST /api/memory/lightrag/start', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns ok:false with error when lightrag-server not installed (or ok:true if it is)', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/lightrag/start', {});
+      assert.equal(res.status, 200);
+      assert.equal(typeof res.body.ok, 'boolean');
+      if (!res.body.ok) {
+        assert.ok(res.body.error != null);
+      }
+    });
+  });
+});
+
+describe('POST /api/memory/lightrag/stop', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns ok:true when nothing is running', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpPost(port, '/api/memory/lightrag/stop', {});
+      assert.equal(res.status, 200);
+      assert.equal(res.body.ok, true);
+    });
+  });
+});
+
+describe('GET /api/memory/lightrag/log', () => {
+  let root;
+
+  beforeEach(() => {
+    root = makeTmp();
+    writeFileSync(join(root, '.bizar', 'memory.json'), JSON.stringify({
+      version: 1,
+      lightrag: { port: 9621 },
+    }));
+    mkdirSync(join(root, '.bizar', 'lightrag'), { recursive: true });
+    // Write a log file with 60 lines
+    const lines = Array.from({ length: 60 }, (_, i) => `log line ${i + 1}`).join('\n');
+    writeFileSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), lines);
+  });
+
+  afterEach(() => {
+    try { rmSync(root, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  test('returns last 200 lines', async () => {
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/log');
+      assert.equal(res.status, 200);
+      assert.ok(Array.isArray(res.body.lines));
+      assert.ok(res.body.lines.length <= 200);
+    });
+  });
+
+  test('returns empty lines when no log file', async () => {
+    rmSync(join(root, '.bizar', 'lightrag', 'lightrag.log'), { force: true });
+
+    await withApp(root, async (port) => {
+      const res = await httpGet(port, '/api/memory/lightrag/log');
+      assert.equal(res.status, 200);
+      assert.ok(Array.isArray(res.body.lines));
+      assert.equal(res.body.lines.length, 0);
+    });
+  });
+});

package/bizar-dash/tests/memory-git.test.mjs

@@ -9,7 +9,7 @@ import assert from 'node:assert';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
-import { execSync } from 'node:child_process';
+import { execSync, execFileSync } from 'node:child_process';
 
 const TEST_GIT = await import('../src/server/memory-git.mjs').then((m) => m);
 const GIT_INSTALLED = TEST_GIT.isGitInstalled();
@@ -135,4 +135,112 @@ describe('memory-git', () => {
     const result = TEST_GIT.pull(workingDir);
     assert.strictEqual(result.ok, true);
   });
+
+  describe('addRemote', () => {
+    (GIT_INSTALLED ? it : it.skip)('registers a new remote on a fresh repo', () => {
+      const dir = join(tmpdir(), `bizar-addremote-fresh-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const result = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(result, { ok: true, action: 'added' });
+
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: dir, encoding: 'utf8' }).trim();
+        assert.strictEqual(url, 'git@github.com:user/repo.git');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('is idempotent when same URL is set twice', () => {
+      const dir = join(tmpdir(), `bizar-addremote-idempotent-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const first = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(first, { ok: true, action: 'added' });
+
+        const second = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.deepEqual(second, { ok: true, action: 'unchanged' });
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('throws when remote exists with different URL and overwrite is false', () => {
+      const dir = join(tmpdir(), `bizar-addremote-noverwrite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        assert.throws(
+          () => TEST_GIT.addRemote(dir, 'origin', 'git@github.com:other/repo.git'),
+          /already exists/,
+        );
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('overwrites remote URL when overwrite flag is set', () => {
+      const dir = join(tmpdir(), `bizar-addremote-overwrite-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@github.com:user/repo.git');
+        const result = TEST_GIT.addRemote(dir, 'origin', 'git@github.com:other/repo.git', { overwrite: true });
+        assert.deepEqual(result, { ok: true, action: 'updated' });
+
+        const url = execFileSync('git', ['remote', 'get-url', 'origin'], { cwd: dir, encoding: 'utf8' }).trim();
+        assert.strictEqual(url, 'git@github.com:other/repo.git');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('lsRemote', () => {
+    (GIT_INSTALLED ? it : it.skip)('returns empty string for an unreachable remote', () => {
+      const dir = join(tmpdir(), `bizar-lsremote-unreachable-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        TEST_GIT.addRemote(dir, 'origin', 'git@127.0.0.1:1/nope.git');
+        const result = TEST_GIT.lsRemote(dir, 'origin', { timeoutMs: 1000 });
+        assert.strictEqual(result, '');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+
+    (GIT_INSTALLED ? it : it.skip)('returns empty string when the remote name does not exist', () => {
+      const dir = join(tmpdir(), `bizar-lsremote-nonexistent-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+      mkdirSync(dir, { recursive: true });
+      try {
+        execFileSync('git', ['init', '-b', 'main'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.email', 't@t'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+        execFileSync('git', ['config', 'user.name', 't'], { cwd: dir, encoding: 'utf8', stdio: 'pipe' });
+
+        const result = TEST_GIT.lsRemote(dir, 'nonexistent', { timeoutMs: 1000 });
+        assert.strictEqual(result, '');
+      } finally {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    });
+  });
 });

package/bizar-dash/tests/memory-lightrag.test.mjs

@@ -0,0 +1,153 @@
+/**
+ * tests/memory-lightrag.test.mjs
+ *
+ * v4.1.0 — Tests for the LightRAG orchestrator.
+ *
+ * Skips entirely if `lightrag-server` is not installed (the user can
+ * install it with `uv tool install "lightrag-hku[api]"`).
+ */
+
+import { test, describe, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = import.meta.dirname || join(__filename, '..');
+
+const {
+  findLightragBinary,
+  isInstalled,
+  resolveLightRAGConfig,
+  reindexVault,
+  query,
+  isRunning,
+} = await import('../src/server/memory-lightrag.mjs');
+
+const lightragAvailable = findLightragBinary() !== null;
+
+describe('memory-lightrag — preflight', { skip: !lightragAvailable }, () => {
+  test('findLightragBinary returns a path', () => {
+    const bin = findLightragBinary();
+    assert.ok(bin, 'expected binary path');
+    assert.ok(existsSync(bin), `expected ${bin} to exist`);
+  });
+
+  test('isInstalled returns true', async () => {
+    const ok = await isInstalled();
+    assert.equal(ok, true);
+  });
+});
+
+describe('memory-lightrag — config', { skip: !lightragAvailable }, () => {
+  test('resolveLightRAGConfig returns defaults when no memory.json', () => {
+    const fakeRoot = join(tmpdir(), 'bizar-memlight-test-no-config-' + Date.now());
+    mkdirSync(fakeRoot, { recursive: true });
+    try {
+      const cfg = resolveLightRAGConfig(fakeRoot);
+      assert.equal(cfg.enabled, true);
+      assert.equal(cfg.host, '127.0.0.1');
+      assert.equal(cfg.port, 9621);
+      assert.ok(cfg.workingDir.includes('.bizar/lightrag'));
+    } finally {
+      rmSync(fakeRoot, { recursive: true, force: true });
+    }
+  });
+
+  test('resolveLightRAGConfig reads user memory.json', () => {
+    const fakeRoot = join(tmpdir(), 'bizar-memlight-test-cfg-' + Date.now());
+    mkdirSync(join(fakeRoot, '.bizar'), { recursive: true });
+    writeFileSync(join(fakeRoot, '.bizar', 'memory.json'), JSON.stringify({
+      lightrag: { enabled: false, port: 9999, host: '0.0.0.0' },
+    }));
+    try {
+      const cfg = resolveLightRAGConfig(fakeRoot);
+      assert.equal(cfg.enabled, false);
+      assert.equal(cfg.port, 9999);
+      assert.equal(cfg.host, '0.0.0.0');
+    } finally {
+      rmSync(fakeRoot, { recursive: true, force: true });
+    }
+  });
+});
+
+describe('memory-lightrag — reindex (live)', { skip: !lightragAvailable }, () => {
+  let tmpRoot;
+  let noteCount = 0;
+
+  before(async () => {
+    tmpRoot = join(tmpdir(), 'bizar-memlight-test-' + Date.now());
+    const bizarDir = join(tmpRoot, '.bizar');
+    mkdirSync(join(bizarDir, 'memory'), { recursive: true });
+    mkdirSync(join(bizarDir, 'memory', 'projects', 'testproj'), { recursive: true });
+
+    // Write a minimal memory.json (managed mode).
+    writeFileSync(join(bizarDir, 'memory.json'), JSON.stringify({
+      version: 1,
+      backend: 'bizar-local',
+      projectId: 'testproj',
+      memoryRepo: {
+        mode: 'managed',
+        path: join(bizarDir, 'memory'),
+        remote: null,
+        branch: 'main',
+        namespace: 'projects/testproj',
+      },
+      namespaces: {
+        project: 'projects/testproj',
+        global: 'global/bizar',
+        user: 'users/local',
+      },
+      lightrag: {
+        enabled: true,
+        host: '127.0.0.1',
+        port: 9621,
+        workingDir: join(bizarDir, 'lightrag'),
+      },
+    }));
+
+    // Write a couple of test notes.
+    const noteA = `---
+memory_id: mem_test_a
+type: architecture_decision
+project_id: testproj
+status: active
+confidence: verified
+created: 2026-06-29T00:00:00Z
+updated: 2026-06-29T00:00:00Z
+tags: [test]
+---
+
+# Test decision A
+
+LightRAG should be reachable.`;
+    writeFileSync(join(bizarDir, 'memory', 'projects', 'testproj', 'a.md'), noteA);
+    noteCount = 1;
+  });
+
+  test('reindexVault writes a marker file', async () => {
+    const result = await reindexVault(tmpRoot, {});
+    // LightRAG server may not start if no LLM creds are present (default
+    // binding is ollama). We assert the orchestrator produced a result
+    // and wrote a marker file regardless of insert success.
+    assert.ok(result, 'reindexVault returned a result');
+    assert.ok(result.noteCount >= 1, `should report at least one note, got ${result.noteCount}`);
+    assert.ok(result.markerPath, 'markerPath must be set');
+    assert.ok(existsSync(result.markerPath), 'marker file must exist on disk');
+    const marker = JSON.parse(readFileSync(result.markerPath, 'utf8'));
+    assert.ok(marker.attemptedAt, 'marker has attemptedAt');
+    assert.equal(marker.noteCount, noteCount, 'marker counts all notes');
+    assert.equal(typeof marker.durationMs, 'number');
+    assert.equal(typeof marker.inserted, 'number');
+    assert.equal(typeof marker.failed, 'number');
+  }, { timeout: 60_000 });
+
+  test('isRunning reports server health', async () => {
+    const cfg = resolveLightRAGConfig(tmpRoot);
+    const running = await isRunning(cfg);
+    // We don't assert running=true — the server may not be up in CI.
+    assert.equal(typeof running, 'boolean');
+  });
+});