@polderlabs/bizar 3.23.1 → 4.2.0

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');
+  });
+});

package/bizar-dash/tests/memory-protocol-drift.test.mjs

@@ -0,0 +1,45 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const REPO_ROOT = resolve(__dirname, '..', '..');
+
+function read(rel) {
+  return readFileSync(resolve(REPO_ROOT, rel), 'utf8');
+}
+
+test('memory-protocol SKILL.md has MANDATORY framing at the top', () => {
+  const skill = read('config/skills/memory-protocol/SKILL.md');
+  // The "MANDATORY" badge must appear in the first 10 lines
+  const head = skill.split('\n').slice(0, 10).join('\n');
+  assert.match(head, /MANDATORY/, 'memory-protocol/SKILL.md must mark the protocol as MANDATORY in the first 10 lines');
+});
+
+test('AGENT_BASELINE.md section 5 has MANDATORY marker', () => {
+  const baseline = read('config/agents/_shared/AGENT_BASELINE.md');
+  // Find section 5 header and the next 20 lines
+  const section5Idx = baseline.indexOf('## 5.');
+  assert.ok(section5Idx >= 0, 'AGENT_BASELINE.md must have a section 5');
+  const section5Head = baseline.slice(section5Idx, section5Idx + 600);
+  assert.match(section5Head, /MANDATORY/, 'AGENT_BASELINE.md section 5 must mark memory check as MANDATORY');
+});
+
+test('AGENT_BASELINE.md section 13 has mandatory language', () => {
+  const baseline = read('config/agents/_shared/AGENT_BASELINE.md');
+  const section13Idx = baseline.indexOf('## 13.');
+  assert.ok(section13Idx >= 0, 'AGENT_BASELINE.md must have a section 13');
+  const section13Head = baseline.slice(section13Idx, section13Idx + 3000);
+  // Either the ⚠️ ENFORCED marker we just added, or the existing "mandatory, not optional" line
+  const hasMandatory = /MANDATORY/.test(section13Head) || /mandatory, not optional/i.test(section13Head);
+  assert.ok(hasMandatory, 'AGENT_BASELINE.md section 13 must contain MANDATORY framing or the existing "mandatory, not optional" language');
+});
+
+test('AGENT_BASELINE.md session-start bootstrap commands are present', () => {
+  const baseline = read('config/agents/_shared/AGENT_BASELINE.md');
+  // The actual commands agents must run
+  assert.match(baseline, /bizar memory search/, 'AGENT_BASELINE.md must reference `bizar memory search`');
+  assert.match(baseline, /bizar memory status/, 'AGENT_BASELINE.md must reference `bizar memory status`');
+});

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

@@ -0,0 +1,198 @@
+/**
+ * tests/memory-schema.test.mjs
+ *
+ * Tests for the memory schema validator.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { validateNote, defaultFrontmatter, REQUIRED_FIELDS, VALID_TYPES, VALID_STATUSES, VALID_CONFIDENCES } from '../src/server/memory-schema.mjs';
+
+const NOW = new Date().toISOString();
+
+describe('validateNote', () => {
+  it('passes note with all required fields', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: ['arch', 'api'],
+    };
+    const { valid, errors } = validateNote(fm, 'Some body content');
+    assert.strictEqual(valid, true);
+    assert.deepStrictEqual(errors, []);
+  });
+
+  it('fails when memory_id is missing', () => {
+    const fm = {
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: [],
+    };
+    const { valid, errors } = validateNote(fm, 'body');
+    assert.strictEqual(valid, false);
+    assert.ok(errors.some((e) => e.includes('memory_id')));
+  });
+
+  it('fails when type is invalid', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'unknown_type',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: [],
+    };
+    const { valid, errors } = validateNote(fm, 'body');
+    assert.strictEqual(valid, false);
+    assert.ok(errors.some((e) => e.includes('invalid type')));
+  });
+
+  it('fails when status is invalid', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'bogus',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: [],
+    };
+    const { valid, errors } = validateNote(fm, 'body');
+    assert.strictEqual(valid, false);
+    assert.ok(errors.some((e) => e.includes('invalid status')));
+  });
+
+  it('fails when confidence is invalid', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'bogus',
+      created: NOW,
+      updated: NOW,
+      tags: [],
+    };
+    const { valid, errors } = validateNote(fm, 'body');
+    assert.strictEqual(valid, false);
+    assert.ok(errors.some((e) => e.includes('invalid confidence')));
+  });
+
+  it('fails when tags is not an array', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: 'not-an-array',
+    };
+    const { valid, errors } = validateNote(fm, 'body');
+    assert.strictEqual(valid, false);
+    assert.ok(errors.some((e) => e.includes('tags must be an array')));
+  });
+
+  it('warns when body is empty', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: NOW,
+      updated: NOW,
+      tags: [],
+    };
+    const { warnings } = validateNote(fm, '   \n\n  ');
+    assert.ok(warnings.some((w) => w.includes('body is empty')));
+  });
+
+  it('warns when created/updated is not ISO date', () => {
+    const fm = {
+      memory_id: 'test_123',
+      type: 'architecture_decision',
+      project_id: 'my-project',
+      status: 'active',
+      confidence: 'verified',
+      created: 'not-a-date',
+      updated: 'also-not-a-date',
+      tags: [],
+    };
+    const { warnings } = validateNote(fm, 'body');
+    assert.ok(warnings.some((w) => w.includes('created')));
+    assert.ok(warnings.some((w) => w.includes('updated')));
+  });
+});
+
+describe('defaultFrontmatter', () => {
+  it('fills in all missing required fields', () => {
+    const result = defaultFrontmatter({ type: 'bug_pattern' });
+    assert.ok(result.memory_id.startsWith('bug_pattern_'));
+    assert.strictEqual(result.type, 'bug_pattern');
+    assert.strictEqual(result.status, 'draft');
+    assert.strictEqual(result.confidence, 'inferred');
+    assert.ok(Array.isArray(result.tags));
+    assert.ok(result.created);
+    assert.ok(result.updated);
+  });
+
+  it('preserves user-provided values', () => {
+    const result = defaultFrontmatter({
+      type: 'command',
+      project_id: 'my-project',
+      status: 'active',
+      tags: ['cli'],
+    });
+    assert.strictEqual(result.type, 'command');
+    assert.strictEqual(result.project_id, 'my-project');
+    assert.strictEqual(result.status, 'active');
+    assert.deepStrictEqual(result.tags, ['cli']);
+  });
+
+  it('does not overwrite explicit memory_id', () => {
+    const result = defaultFrontmatter({ memory_id: 'my-custom-id', type: 'session_summary' });
+    assert.strictEqual(result.memory_id, 'my-custom-id');
+  });
+});
+
+describe('schema constants', () => {
+  it('REQUIRED_FIELDS has exactly 8 fields', () => {
+    assert.strictEqual(REQUIRED_FIELDS.length, 8);
+    assert.ok(REQUIRED_FIELDS.includes('memory_id'));
+    assert.ok(REQUIRED_FIELDS.includes('type'));
+    assert.ok(REQUIRED_FIELDS.includes('tags'));
+  });
+
+  it('VALID_TYPES has 11 types', () => {
+    assert.strictEqual(VALID_TYPES.length, 11);
+    assert.ok(VALID_TYPES.includes('architecture_decision'));
+    assert.ok(VALID_TYPES.includes('session_summary'));
+  });
+
+  it('VALID_STATUSES has 6 statuses', () => {
+    assert.strictEqual(VALID_STATUSES.length, 6);
+    assert.ok(VALID_STATUSES.includes('active'));
+    assert.ok(VALID_STATUSES.includes('conflict'));
+  });
+
+  it('VALID_CONFIDENCES has 3 values', () => {
+    assert.strictEqual(VALID_CONFIDENCES.length, 3);
+    assert.ok(VALID_CONFIDENCES.includes('verified'));
+    assert.ok(VALID_CONFIDENCES.includes('inferred'));
+    assert.ok(VALID_CONFIDENCES.includes('speculative'));
+  });
+});

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

@@ -0,0 +1,121 @@
+/**
+ * tests/memory-secrets.test.mjs
+ *
+ * Tests for the secret scanner.
+ */
+
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { scan, hasHighFindings, SECRET_PATTERNS } from '../src/server/memory-secrets.mjs';
+
+describe('scan', () => {
+  it('returns safe: true for clean text', () => {
+    const result = scan('This is a normal note about memory architecture and planning.');
+    assert.strictEqual(result.safe, true);
+    assert.deepStrictEqual(result.findings, []);
+  });
+
+  it('detects AWS access key', () => {
+    const result = scan('AWS_KEY=AKIAIOSFODNN7EXAMPLE');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'aws_access_key'));
+  });
+
+  it('detects GitHub PAT classic', () => {
+    const result = scan('ghp_abcdefghijklmnopqrstuvwxyz1234567890ABCD');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'github_pat_classic'));
+  });
+
+  it('detects Stripe live key', () => {
+    const result = scan('sk_live_51234567890abcdefghijklmnop');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'stripe_live'));
+  });
+
+  it('detects Slack token', () => {
+    const result = scan('xoxb-1234567890123-1234567890123-AbCdEfGhIjKlMnOpQrStUvWx');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'slack_token'));
+  });
+
+  it('detects private key PEM', () => {
+    const result = scan('-----BEGIN RSA PRIVATE KEY-----\nMIIE...\n-----END RSA PRIVATE KEY-----');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'private_key_pem'));
+  });
+
+  it('detects bearer token with base64-like value', () => {
+    const result = scan('Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIn0');
+    assert.strictEqual(result.safe, false);
+    assert.ok(result.findings.some((f) => f.id === 'bearer_token'));
+  });
+
+  it('detects api_key_assignment', () => {
+    const result = scan('api_key: abcdefghijklmnopqrstuvwxyz123456');
+    // api_key_assignment is MEDIUM severity — safe stays true
+    assert.strictEqual(result.safe, true);
+    assert.ok(result.findings.some((f) => f.id === 'api_key_assignment'));
+  });
+
+  it('does NOT trigger on "my API is fast"', () => {
+    const result = scan('my API is fast');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('does NOT trigger on "bearer of bad tidings"', () => {
+    const result = scan('bearer of bad tidings');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('does NOT trigger on "172.16 is too low" (incomplete private IP)', () => {
+    const result = scan('172.16 is too low');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('does NOT trigger on "hello world"', () => {
+    const result = scan('hello world');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('does NOT trigger on "the api_keyname is descriptive"', () => {
+    const result = scan('the api_keyname is descriptive');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('does NOT trigger on bare Bearer without long token', () => {
+    const result = scan('Bearer of course');
+    assert.strictEqual(result.safe, true);
+  });
+
+  it('returns line numbers in findings', () => {
+    const text = 'line one\nline two with AKIAIOSFODNN7EXAMPLE key\nline three';
+    const result = scan(text);
+    const aws = result.findings.find((f) => f.id === 'aws_access_key');
+    assert.strictEqual(aws.line, 2);
+  });
+
+  it('hasHighFindings returns true for HIGH severity', () => {
+    const result = scan('AKIAIOSFODNN7EXAMPLE');
+    assert.strictEqual(hasHighFindings(result), true);
+  });
+
+  it('hasHighFindings returns false for MEDIUM-only', () => {
+    const result = scan('api_key: abcdefghijklmnopqrstuvwxyz123456');
+    assert.strictEqual(hasHighFindings(result), false);
+  });
+
+  it('hasHighFindings returns false for no findings', () => {
+    const result = scan('hello world');
+    assert.strictEqual(hasHighFindings(result), false);
+  });
+
+  it('all 12 patterns are defined with severity HIGH or MEDIUM', () => {
+    for (const p of SECRET_PATTERNS) {
+      assert.ok(p.id, `pattern missing id: ${JSON.stringify(p)}`);
+      assert.ok(p.pattern instanceof RegExp, `pattern ${p.id} is not a RegExp`);
+      assert.ok(p.severity === 'HIGH' || p.severity === 'MEDIUM', `invalid severity for ${p.id}`);
+    }
+    assert.strictEqual(SECRET_PATTERNS.length, 12);
+  });
+});