@polderlabs/bizar 4.8.0 → 5.0.0

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

@@ -0,0 +1,95 @@
+/**
+ * tests/memory-graph.test.mjs
+ *
+ * Tests for getObsidianLinkGraph in memory-store.mjs
+ * and getLightRAGGraph in memory-lightrag.mjs.
+ */
+
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+
+const TEST_STORE = await import('../src/server/memory-store.mjs').then((m) => m);
+
+describe('getObsidianLinkGraph', () => {
+  let projectRoot;
+
+  beforeEach(() => {
+    projectRoot = join(tmpdir(), `bizar-graph-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+  });
+
+  afterEach(() => {
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  function writeNote(relPath, body) {
+    const full = join(projectRoot, '.obsidian', relPath);
+    mkdirSync(join(projectRoot, '.obsidian', relPath.split('/').slice(0, -1).join('/') || '.'), { recursive: true });
+    const title = relPath.split('/').pop()?.replace(/\.md$/i, '') || relPath;
+    writeFileSync(full, `---\ntitle: ${title}\n---\n\n${body}`, 'utf8');
+  }
+
+  it('extracts wikilinks and builds nodes + edges', () => {
+    writeNote('notes/alpha.md', 'This links to [[Beta Note]] and [[Gamma]].');
+    writeNote('notes/beta.md', 'Back to [[Alpha]].');
+    writeNote('notes/gamma.md', 'No links here.');
+
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+
+    // Should have 3 nodes.
+    assert.ok(nodes.length >= 3, `Expected >= 3 nodes, got ${nodes.length}`);
+
+    // Each node should have required fields.
+    for (const n of nodes) {
+      assert.ok('id' in n, 'node must have id');
+      assert.ok('label' in n, 'node must have label');
+      assert.ok('type' in n, 'node must have type');
+      assert.ok('size' in n, 'node must have size');
+      assert.ok('group' in n, 'node must have group');
+    }
+
+    // Should have edges.
+    assert.ok(edges.length > 0, 'Expected at least 1 edge');
+    for (const e of edges) {
+      assert.ok('source' in e, 'edge must have source');
+      assert.ok('target' in e, 'edge must have target');
+      assert.ok('type' in e, 'edge must have type');
+      assert.ok('weight' in e, 'edge must have weight');
+    }
+  });
+
+  it('handles empty vault gracefully', () => {
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    assert.ok(Array.isArray(nodes), 'nodes must be an array');
+    assert.ok(Array.isArray(edges), 'edges must be an array');
+  });
+
+  it('resolves wikilink targets by basename', () => {
+    writeNote('foo.md', 'See [[Bar]] for details.');
+    writeNote('bar.md', 'Related to [[Foo]].');
+    const { edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    // Should have resolved [[Bar]] -> bar.md and [[Foo]] -> foo.md.
+    assert.ok(edges.length >= 1, 'Expected at least 1 edge from wikilink resolution');
+  });
+
+  it('respects the limit parameter', () => {
+    for (let i = 0; i < 10; i++) {
+      writeNote(`note${i}.md`, i === 0 ? 'Links to [[Note1]].' : '');
+    }
+    const { nodes, edges } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 3 });
+    assert.ok(nodes.length <= 3, `Expected <= 3 nodes, got ${nodes.length}`);
+    assert.ok(edges.length <= 9, `Expected <= 9 edges, got ${edges.length}`);
+  });
+
+  it('node label uses title frontmatter when available', () => {
+    writeNote('mydoc.md', 'Content.');
+    const { nodes } = TEST_STORE.getObsidianLinkGraph({ projectRoot, limit: 200 });
+    const mydoc = nodes.find((n) => n.id === 'mydoc.md');
+    assert.ok(mydoc, 'mydoc.md should be a node');
+    assert.strictEqual(mydoc.label, 'mydoc');
+  });
+});

package/bizar-dash/tests/ocr.test.mjs

@@ -0,0 +1,87 @@
+/**
+ * tests/ocr.test.mjs
+ *
+ * v5.0.0 — Tests for the OCR helper module and routes.
+ *
+ * The extractText tests require tesseract.js to be installed.
+ */
+
+import { describe, it, beforeEach, afterEach, before } from 'node:test';
+import assert from 'node:assert/strict';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { mkdirSync, rmSync } from 'node:fs';
+
+// ── Test OCR helper ────────────────────────────────────────────────────────────
+
+describe('ocr.extractText', () => {
+  let ocrModule;
+
+  before(async () => {
+    try {
+      ocrModule = await import('../src/server/ocr.mjs');
+    } catch {
+      // tesseract.js or its deps not available
+    }
+  });
+
+  it('extractText returns a string for a valid PNG buffer', { skip: !ocrModule }, async () => {
+    const pngBuffer = Buffer.from(
+      'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==',
+      'base64',
+    );
+    const text = await ocrModule.extractText(pngBuffer);
+    assert.strictEqual(typeof text, 'string');
+  });
+
+  it('checkOcrHealth returns ok or error message', { skip: !ocrModule }, async () => {
+    const health = await ocrModule.checkOcrHealth();
+    assert.ok(typeof health.ok === 'boolean');
+    assert.ok(typeof health.message === 'string');
+  });
+});
+
+// ── Test OCR routes ────────────────────────────────────────────────────────────
+
+describe('ocr routes', () => {
+  let projectRoot;
+  let server;
+  let baseUrl;
+  let ocrRouterModule;
+
+  before(async () => {
+    ocrRouterModule = await import('../src/server/routes/ocr.mjs');
+  });
+
+  beforeEach(async () => {
+    projectRoot = join(tmpdir(), `bizar-ocr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(projectRoot, { recursive: true });
+    mkdirSync(join(projectRoot, '.bizar'), { recursive: true });
+
+    const express = (await import('express')).default;
+    const router = await ocrRouterModule.createOcrRouter({ projectRoot });
+    const app = express();
+    app.use(express.json({ limit: '25mb' }));
+    app.use('/api', router);
+
+    await new Promise((resolve) => {
+      server = app.listen(0, () => {
+        const addr = server.address();
+        baseUrl = `http://127.0.0.1:${addr.port}`;
+        resolve();
+      });
+    });
+  });
+
+  afterEach(() => {
+    try { server?.close?.(); } catch { /* ignore */ }
+    try { rmSync(projectRoot, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('GET /api/ocr/list returns entries array', async () => {
+    const r = await fetch(`${baseUrl}/api/ocr/list`);
+    assert.strictEqual(r.status, 200);
+    const data = await r.json();
+    assert.ok(Array.isArray(data.entries));
+  });
+});

package/bizar-dash/tests/otel.test.mjs

@@ -0,0 +1,188 @@
+/**
+ * tests/otel.test.mjs — v4.9.0
+ *
+ * Tests for src/server/otel.mjs. The OpenTelemetry SDK and helpers
+ * must:
+ *   - export a `tracer` that has `startActiveSpan` (works even before
+ *     `initOtel()` is called, because the no-op global tracer covers
+ *     the uninitialised case)
+ *   - return an SDK instance from `initOtel()` and only initialise
+ *     once across repeated calls
+ *   - shut down cleanly via `shutdownOtel()`, even when the OTLP
+ *     endpoint is unreachable
+ *   - tolerate a malformed endpoint / thrown init error without
+ *     crashing the importing module
+ *
+ * Each test loads the module via a fresh URL to defeat Node's ESM
+ * module cache; `otel.mjs` uses module-scoped state (the `sdk` and
+ * `shuttingDown` lets) and we want each test to see its own clean
+ * registry the same way `metrics.test.mjs` does.
+ */
+
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+const OTEL_URL = '../src/server/otel.mjs';
+
+async function loadOtel() {
+  const url = `${OTEL_URL}?v=${Date.now()}-${Math.random()}`;
+  return import(url);
+}
+
+test('tracer is exported and has startActiveSpan', async () => {
+  const otel = await loadOtel();
+  try {
+    assert.equal(typeof otel.tracer, 'object');
+    assert.equal(typeof otel.tracer.startActiveSpan, 'function');
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('initOtel() returns an SDK instance and is idempotent', async () => {
+  const otel = await loadOtel();
+  try {
+    // Before init: isOtelEnabled() is false (fresh module load).
+    assert.equal(otel.isOtelEnabled(), false);
+    const sdk1 = otel.initOtel({
+      // Use an endpoint that won't connect; the test only cares
+      // that the SDK object is returned, not that spans export.
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk1, 'initOtel should return a non-null SDK instance');
+    assert.equal(otel.isOtelEnabled(), true);
+
+    const sdk2 = otel.initOtel({ endpoint: 'http://127.0.0.1:1/v1/traces' });
+    assert.equal(
+      sdk1,
+      sdk2,
+      'a second initOtel() call must return the cached SDK instance',
+    );
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('shutdownOtel() is callable and resets the SDK cache', async () => {
+  const otel = await loadOtel();
+  try {
+    otel.initOtel({ endpoint: 'http://127.0.0.1:1/v1/traces' });
+    assert.equal(otel.isOtelEnabled(), true);
+    await otel.shutdownOtel();
+    assert.equal(otel.isOtelEnabled(), false);
+
+    // Calling shutdownOtel again must be a no-op (does not throw).
+    await otel.shutdownOtel();
+    assert.equal(otel.isOtelEnabled(), false);
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('graceful degradation when OTLP endpoint is unreachable', async () => {
+  // Port 1 on loopback never accepts connections — the exporter will
+  // log batch-send errors internally but must not crash the module.
+  const otel = await loadOtel();
+  try {
+    const sdk = otel.initOtel({
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk, 'initOtel must succeed even with an unreachable endpoint');
+    assert.equal(otel.isOtelEnabled(), true);
+
+    // Spans created on the live tracer must complete without errors.
+    await new Promise((resolve, reject) => {
+      otel.tracer.startActiveSpan('test.unreachable_endpoint', async (span) => {
+        try {
+          span.setAttribute('test.attr', 1);
+          span.setStatus({ code: 1 /* OK */ });
+          await Promise.resolve();
+          resolve();
+        } catch (e) {
+          reject(e);
+        } finally {
+          span.end();
+        }
+      });
+    });
+
+    await otel.shutdownOtel();
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('spans can be created and ended without errors (no SDK initialised)', async () => {
+  // No initOtel call — exercises the no-op tracer path. Route
+  // handlers rely on this when OTEL is disabled (the default).
+  const otel = await loadOtel();
+  assert.equal(otel.isOtelEnabled(), false);
+
+  const result = await new Promise((resolve, reject) => {
+    otel.tracer.startActiveSpan('test.noop', (span) => {
+      try {
+        // Sanity-check that the no-op span still answers every
+        // method without throwing — that's the contract route
+        // handlers rely on.
+        span.setAttribute('a', 1);
+        span.setAttribute('b', 'hello');
+        span.addEvent('event-1');
+        span.setStatus({ code: 1 });
+        resolve('ok');
+      } catch (err) {
+        reject(err);
+      } finally {
+        span.end();
+      }
+    });
+  });
+  assert.equal(result, 'ok');
+
+  await otel.shutdownOtel();
+});
+
+test('tracer.startActiveSpan callback can be async (returns a Promise)', async () => {
+  // The OpenTelemetry spec lets the callback return a Promise;
+  // the tracer awaits it. Make sure the no-op implementation
+  // (used when the SDK is disabled) honors this.
+  const otel = await loadOtel();
+  try {
+    let observed = null;
+    await otel.tracer.startActiveSpan('test.async', async (span) => {
+      try {
+        observed = await Promise.resolve('inside-span');
+      } finally {
+        span.end();
+      }
+    });
+    assert.equal(observed, 'inside-span');
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('initOtel accepts custom serviceName override', async () => {
+  const otel = await loadOtel();
+  try {
+    const sdk = otel.initOtel({
+      serviceName: 'bizar-dash-test',
+      endpoint: 'http://127.0.0.1:1/v1/traces',
+    });
+    assert.ok(sdk, 'initOtel with a custom serviceName should succeed');
+    await otel.shutdownOtel();
+  } finally {
+    await otel.shutdownOtel();
+  }
+});
+
+test('module does not crash when imported (no init, no shutdown)', async () => {
+  // Defensive sanity check — every other test file in this repo
+  // transitively imports dozens of modules. If a syntax/import
+  // error sneaks into otel.mjs, this test catches it before the
+  // larger suite blows up somewhere unrelated.
+  const otel = await loadOtel();
+  assert.equal(typeof otel.initOtel, 'function');
+  assert.equal(typeof otel.shutdownOtel, 'function');
+  assert.equal(typeof otel.tracer, 'object');
+  await otel.shutdownOtel();
+});