@polderlabs/bizar 3.23.0 → 4.0.0

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