create-walle 0.1.0

package/template/wall-e/tests/brain.test.js

@@ -0,0 +1,602 @@
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert/strict');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+const brain = require('../brain.js');
+
+let testDir;
+let testDbPath;
+
+function setupTestDb() {
+  testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'wall-e-test-'));
+  testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+// ── Task 2: Schema and Init ────────────────────────────────────────────
+
+describe('Brain DB Schema and Init', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('creates database with WAL mode', () => {
+    const db = brain.getDb();
+    const row = db.pragma('journal_mode', { simple: true });
+    assert.equal(row, 'wal');
+  });
+
+  it('has foreign keys enabled', () => {
+    const db = brain.getDb();
+    const row = db.pragma('foreign_keys', { simple: true });
+    assert.equal(row, 1);
+  });
+
+  it('has all 19 tables', () => {
+    const db = brain.getDb();
+    const tables = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name"
+    ).all().map(r => r.name);
+
+    const expected = [
+      'agent_actions', 'agent_exchanges', 'briefing_items', 'chat_messages', 'code_identity', 'current_state',
+      'daily_summaries', 'domain_confidence', 'knowledge', 'loop_checkpoints', 'memories',
+      'owner', 'patterns', 'pending_questions', 'people', 'personas',
+      'skill_executions', 'skills', 'tasks'
+    ].sort();
+
+    assert.deepEqual(tables, expected);
+  });
+
+  it('has at least 18 indexes', () => {
+    const db = brain.getDb();
+    const indexes = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name NOT LIKE 'sqlite_%'"
+    ).all();
+    assert.ok(indexes.length >= 18, `Expected >= 18 indexes, got ${indexes.length}`);
+  });
+
+  it('has idx_memories_source index', () => {
+    const db = brain.getDb();
+    const idx = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_memories_source'"
+    ).get();
+    assert.ok(idx, 'idx_memories_source should exist');
+  });
+
+  it('has idx_knowledge_active_subject index', () => {
+    const db = brain.getDb();
+    const idx = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_knowledge_active_subject'"
+    ).get();
+    assert.ok(idx, 'idx_knowledge_active_subject should exist');
+  });
+
+  it('has idx_actions_status index', () => {
+    const db = brain.getDb();
+    const idx = db.prepare(
+      "SELECT name FROM sqlite_master WHERE type='index' AND name='idx_actions_status'"
+    ).get();
+    assert.ok(idx, 'idx_actions_status should exist');
+  });
+});
+
+// ── Task 3: CRUD Helpers ────────────────────────────────────────────────
+
+describe('Owner config', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('setOwner then getOwner returns value', () => {
+    brain.setOwner('name', 'Test Owner');
+    assert.equal(brain.getOwner('name'), 'Test Owner');
+  });
+
+  it('getOwnerName returns name', () => {
+    brain.setOwner('name', 'Test Owner');
+    assert.equal(brain.getOwnerName(), 'Test Owner');
+  });
+
+  it('getOwner for nonexistent key returns null', () => {
+    assert.equal(brain.getOwner('nonexistent'), null);
+  });
+});
+
+describe('Memory CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertMemory returns id and getMemory retrieves it', () => {
+    const result = brain.insertMemory({
+      source: 'slack',
+      source_id: 'msg-001',
+      memory_type: 'message_received',
+      content: 'Can you review?',
+      timestamp: '2026-03-22T10:00:00Z'
+    });
+    assert.ok(result.id, 'should return an id');
+    const mem = brain.getMemory(result.id);
+    assert.equal(mem.source, 'slack');
+    assert.equal(mem.source_id, 'msg-001');
+    assert.equal(mem.content, 'Can you review?');
+  });
+
+  it('inserting same source+source_id twice returns null (dedup)', () => {
+    brain.insertMemory({
+      source: 'slack',
+      source_id: 'msg-dup',
+      memory_type: 'message_received',
+      content: 'first',
+      timestamp: '2026-03-22T10:00:00Z'
+    });
+    const dup = brain.insertMemory({
+      source: 'slack',
+      source_id: 'msg-dup',
+      memory_type: 'message_received',
+      content: 'second',
+      timestamp: '2026-03-22T10:01:00Z'
+    });
+    assert.equal(dup, null);
+  });
+
+  it('listMemories filters by source', () => {
+    brain.insertMemory({
+      source: 'email',
+      source_id: 'em-001',
+      memory_type: 'message_received',
+      content: 'Email content',
+      timestamp: '2026-03-22T10:00:00Z'
+    });
+    const results = brain.listMemories({ source: 'email' });
+    assert.ok(results.length >= 1);
+    assert.ok(results.every(r => r.source === 'email'));
+  });
+
+  it('listMemories filters by since', () => {
+    brain.insertMemory({
+      source: 'slack',
+      source_id: 'msg-old',
+      memory_type: 'message_received',
+      content: 'Old message',
+      timestamp: '2026-03-21T08:00:00Z'
+    });
+    const results = brain.listMemories({ since: '2026-03-22T09:00:00Z' });
+    assert.ok(results.length >= 1);
+    assert.ok(results.every(r => r.timestamp >= '2026-03-22T09:00:00Z'));
+  });
+
+  it('insertMemory with missing source throws', () => {
+    assert.throws(() => {
+      brain.insertMemory({
+        memory_type: 'message_received',
+        content: 'No source',
+        timestamp: '2026-03-22T10:00:00Z'
+      });
+    });
+  });
+});
+
+describe('Knowledge CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertKnowledge returns id', () => {
+    const result = brain.insertKnowledge({
+      category: 'technical',
+      subject: 'TestUser',
+      predicate: 'prefers',
+      object: 'SQLite'
+    });
+    assert.ok(result.id);
+  });
+
+  it('findKnowledge returns matching results', () => {
+    brain.insertKnowledge({
+      category: 'technical',
+      subject: 'TestUser',
+      predicate: 'uses',
+      object: 'Node.js'
+    });
+    const results = brain.findKnowledge({ subject: 'TestUser', status: 'active' });
+    assert.ok(results.length >= 1);
+    assert.ok(results.every(r => r.subject === 'TestUser'));
+  });
+
+  it('insertKnowledge with missing required fields throws', () => {
+    assert.throws(() => {
+      brain.insertKnowledge({
+        category: 'technical',
+        subject: 'TestUser'
+        // missing predicate and object
+      });
+    });
+  });
+});
+
+describe('Checkpoint CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('upsertCheckpoint then getCheckpoint returns it', () => {
+    brain.upsertCheckpoint('ingest', { last_memory_at: '2026-03-22T10:00:00Z' });
+    const cp = brain.getCheckpoint('ingest');
+    assert.ok(cp);
+    assert.equal(cp.loop_name, 'ingest');
+    assert.equal(cp.last_memory_at, '2026-03-22T10:00:00Z');
+  });
+
+  it('upserting again updates existing row', () => {
+    brain.upsertCheckpoint('ingest', { last_memory_at: '2026-03-22T11:00:00Z' });
+    const cp = brain.getCheckpoint('ingest');
+    assert.equal(cp.last_memory_at, '2026-03-22T11:00:00Z');
+
+    // Should still be just one row
+    const db = brain.getDb();
+    const count = db.prepare("SELECT COUNT(*) as cnt FROM loop_checkpoints WHERE loop_name='ingest'").get();
+    assert.equal(count.cnt, 1);
+  });
+});
+
+// ── Task 4: Daily Backup ────────────────────────────────────────────────
+
+describe('backup', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('createBackup returns backupPath and backupName', () => {
+    const result = brain.createBackup('test');
+    assert.ok(result.backupPath, 'should have backupPath');
+    assert.ok(result.backupName, 'should have backupName');
+  });
+
+  it('backup file exists at backupPath', () => {
+    const result = brain.createBackup('test');
+    assert.ok(fs.existsSync(result.backupPath), 'backup file should exist');
+  });
+
+  it('backupName starts with wall-e-brain-', () => {
+    const result = brain.createBackup('test');
+    assert.ok(result.backupName.startsWith('wall-e-brain-'), `Expected backupName to start with 'wall-e-brain-', got '${result.backupName}'`);
+  });
+
+  it('backupName includes -test', () => {
+    const result = brain.createBackup('test');
+    assert.ok(result.backupName.includes('-test'), `Expected backupName to include '-test', got '${result.backupName}'`);
+  });
+});
+
+// ── Phase 2 Task 1: People CRUD ──────────────────────────────────────────
+
+describe('People CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertPerson returns id and getPerson retrieves it', () => {
+    const result = brain.insertPerson({ name: 'Alice', relationship: 'colleague' });
+    assert.ok(result.id);
+    const person = brain.getPerson(result.id);
+    assert.equal(person.name, 'Alice');
+    assert.equal(person.relationship, 'colleague');
+    assert.equal(person.trust_level, 0.5);
+  });
+
+  it('insertPerson with all fields', () => {
+    const result = brain.insertPerson({
+      name: 'Bob',
+      relationship: 'friend',
+      aliases: 'Bobby,Robert',
+      identities: 'bob@example.com',
+      trust_level: 0.9,
+      notes: 'Met at conference'
+    });
+    const person = brain.getPerson(result.id);
+    assert.equal(person.aliases, 'Bobby,Robert');
+    assert.equal(person.trust_level, 0.9);
+    assert.equal(person.notes, 'Met at conference');
+  });
+
+  it('insertPerson with missing name throws', () => {
+    assert.throws(() => brain.insertPerson({ relationship: 'colleague' }), /name/);
+  });
+
+  it('getPerson returns null for nonexistent id', () => {
+    assert.equal(brain.getPerson('nonexistent-id'), null);
+  });
+
+  it('listPeople returns all people', () => {
+    const all = brain.listPeople();
+    assert.ok(all.length >= 2);
+  });
+
+  it('listPeople filters by relationship', () => {
+    const friends = brain.listPeople({ relationship: 'friend' });
+    assert.ok(friends.length >= 1);
+    assert.ok(friends.every(p => p.relationship === 'friend'));
+  });
+
+  it('listPeople respects limit', () => {
+    const limited = brain.listPeople({ limit: 1 });
+    assert.equal(limited.length, 1);
+  });
+
+  it('updatePerson updates allowed fields', () => {
+    const { id } = brain.insertPerson({ name: 'Charlie' });
+    brain.updatePerson(id, { trust_level: 0.8, trust_reason: 'Reliable', notes: 'Updated' });
+    const person = brain.getPerson(id);
+    assert.equal(person.trust_level, 0.8);
+    assert.equal(person.trust_reason, 'Reliable');
+    assert.equal(person.notes, 'Updated');
+  });
+
+  it('updatePerson rejects invalid fields', () => {
+    const { id } = brain.insertPerson({ name: 'Dave' });
+    assert.throws(() => brain.updatePerson(id, { name: 'Evil' }), /Invalid update fields/);
+  });
+
+  it('updatePerson throws for nonexistent person', () => {
+    assert.throws(() => brain.updatePerson('nonexistent', { notes: 'x' }), /Person not found/);
+  });
+
+  it('updatePerson throws with empty updates', () => {
+    const { id } = brain.insertPerson({ name: 'Eve' });
+    assert.throws(() => brain.updatePerson(id, {}), /No updates provided/);
+  });
+});
+
+// ── Phase 2 Task 1: Pending Questions ────────────────────────────────────
+
+describe('Pending Questions', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertQuestion returns id', () => {
+    const result = brain.insertQuestion({
+      question_type: 'clarification',
+      question: 'What timezone do you prefer?',
+      context: 'scheduling',
+      priority: 'high'
+    });
+    assert.ok(result.id);
+  });
+
+  it('insertQuestion with missing question_type throws', () => {
+    assert.throws(() => brain.insertQuestion({ question: 'Hello?' }), /question_type/);
+  });
+
+  it('insertQuestion with missing question throws', () => {
+    assert.throws(() => brain.insertQuestion({ question_type: 'clarification' }), /question/);
+  });
+
+  it('listQuestions returns questions ordered by created_at DESC', () => {
+    brain.insertQuestion({ question_type: 'preference', question: 'First?' });
+    brain.insertQuestion({ question_type: 'preference', question: 'Second?' });
+    const list = brain.listQuestions({ question_type: 'preference' });
+    assert.ok(list.length >= 2);
+    // Most recent first
+    assert.ok(list[0].created_at >= list[list.length - 1].created_at);
+  });
+
+  it('listQuestions filters by status', () => {
+    const pending = brain.listQuestions({ status: 'pending' });
+    assert.ok(pending.length >= 1);
+    assert.ok(pending.every(q => q.status === 'pending'));
+  });
+
+  it('listQuestions respects limit', () => {
+    const limited = brain.listQuestions({ limit: 1 });
+    assert.equal(limited.length, 1);
+  });
+
+  it('answerQuestion updates status and answer', () => {
+    const { id } = brain.insertQuestion({ question_type: 'clarification', question: 'Timezone?' });
+    brain.answerQuestion(id, { answer: 'UTC-5', resolution_type: 'answered', resolution_evidence: 'User said so' });
+    const questions = brain.listQuestions({ status: 'answered' });
+    const q = questions.find(q => q.id === id);
+    assert.ok(q);
+    assert.equal(q.answer, 'UTC-5');
+    assert.equal(q.resolution_type, 'answered');
+    assert.ok(q.answered_at);
+  });
+
+  it('answerQuestion with inferred resolution_type sets status to inferred', () => {
+    const { id } = brain.insertQuestion({ question_type: 'preference', question: 'Theme?' });
+    brain.answerQuestion(id, { answer: 'dark', resolution_type: 'inferred' });
+    const questions = brain.listQuestions({ status: 'inferred' });
+    const q = questions.find(q => q.id === id);
+    assert.ok(q);
+  });
+
+  it('answerQuestion with invalid resolution_type throws', () => {
+    const { id } = brain.insertQuestion({ question_type: 'clarification', question: 'Color?' });
+    assert.throws(() => brain.answerQuestion(id, { answer: 'blue', resolution_type: 'invalid' }), /Invalid resolution_type/);
+  });
+
+  it('answerQuestion with missing answer throws', () => {
+    const { id } = brain.insertQuestion({ question_type: 'clarification', question: 'Size?' });
+    assert.throws(() => brain.answerQuestion(id, { resolution_type: 'answered' }), /Answer is required/);
+  });
+
+  it('answerQuestion for nonexistent question throws', () => {
+    assert.throws(() => brain.answerQuestion('nonexistent', { answer: 'x', resolution_type: 'answered' }), /Question not found/);
+  });
+});
+
+// ── Phase 2 Task 1: Knowledge updates ────────────────────────────────────
+
+describe('Knowledge updates', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('supersedeKnowledge marks old as superseded', () => {
+    const old = brain.insertKnowledge({ category: 'preference', subject: 'TestUser', predicate: 'prefers_editor', object: 'VSCode' });
+    const newer = brain.insertKnowledge({ category: 'preference', subject: 'TestUser', predicate: 'prefers_editor', object: 'Cursor' });
+    brain.supersedeKnowledge(old.id, newer.id);
+    const oldK = brain.getKnowledge(old.id);
+    assert.equal(oldK.status, 'superseded');
+    assert.equal(oldK.superseded_by, newer.id);
+  });
+
+  it('supersedeKnowledge throws for nonexistent id', () => {
+    const { id } = brain.insertKnowledge({ category: 'technical', subject: 'x', predicate: 'y', object: 'z' });
+    assert.throws(() => brain.supersedeKnowledge('nonexistent', id), /Knowledge not found/);
+  });
+
+  it('updateKnowledgeStatus sets valid status', () => {
+    const { id } = brain.insertKnowledge({ category: 'technical', subject: 'a', predicate: 'b', object: 'c' });
+    brain.updateKnowledgeStatus(id, 'disputed');
+    assert.equal(brain.getKnowledge(id).status, 'disputed');
+    brain.updateKnowledgeStatus(id, 'retracted');
+    assert.equal(brain.getKnowledge(id).status, 'retracted');
+  });
+
+  it('updateKnowledgeStatus throws for invalid status', () => {
+    const { id } = brain.insertKnowledge({ category: 'technical', subject: 'd', predicate: 'e', object: 'f' });
+    assert.throws(() => brain.updateKnowledgeStatus(id, 'bogus'), /Invalid knowledge status/);
+  });
+
+  it('updateKnowledgeStatus throws for nonexistent id', () => {
+    assert.throws(() => brain.updateKnowledgeStatus('nonexistent', 'active'), /Knowledge not found/);
+  });
+});
+
+// ── Phase 2 Task 1: Brain Stats ──────────────────────────────────────────
+
+describe('Brain Stats', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('getBrainStats returns all counts', () => {
+    // Seed some data
+    brain.insertMemory({ source: 'test', memory_type: 'note', content: 'hello', timestamp: '2026-01-01T00:00:00Z' });
+    brain.insertKnowledge({ category: 'technical', subject: 'x', predicate: 'y', object: 'z' });
+    brain.insertPerson({ name: 'Stat Person' });
+    brain.insertQuestion({ question_type: 'test', question: 'Q?' });
+
+    const stats = brain.getBrainStats();
+    assert.equal(typeof stats.memory_count, 'number');
+    assert.ok(stats.memory_count >= 1);
+    assert.equal(typeof stats.knowledge_count, 'number');
+    assert.ok(stats.knowledge_count >= 1);
+    assert.equal(typeof stats.people_count, 'number');
+    assert.ok(stats.people_count >= 1);
+    assert.equal(typeof stats.pattern_count, 'number');
+    assert.equal(typeof stats.pending_question_count, 'number');
+    assert.ok(stats.pending_question_count >= 1);
+  });
+});
+
+// ── Phase 2 Task 1: Daily Summaries ──────────────────────────────────────
+
+describe('Daily Summaries', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertDailySummary and getDailySummary', () => {
+    const result = brain.insertDailySummary('2026-03-22', 'Good day', { memories: 10 });
+    assert.ok(result.id);
+    const summary = brain.getDailySummary('2026-03-22');
+    assert.equal(summary.date, '2026-03-22');
+    assert.equal(summary.summary, 'Good day');
+    assert.equal(JSON.parse(summary.stats).memories, 10);
+  });
+
+  it('getDailySummary returns null for nonexistent date', () => {
+    assert.equal(brain.getDailySummary('1999-01-01'), null);
+  });
+
+  it('insertDailySummary with missing date throws', () => {
+    assert.throws(() => brain.insertDailySummary(null, 'summary'), /date/);
+  });
+
+  it('insertDailySummary with missing summary throws', () => {
+    assert.throws(() => brain.insertDailySummary('2026-03-23', null), /summary/);
+  });
+
+  it('insertDailySummary duplicate date throws', () => {
+    brain.insertDailySummary('2026-03-24', 'First');
+    assert.throws(() => brain.insertDailySummary('2026-03-24', 'Second'));
+  });
+
+  it('listDailySummaries returns ordered by date DESC', () => {
+    brain.insertDailySummary('2026-03-25', 'Day 25');
+    brain.insertDailySummary('2026-03-26', 'Day 26');
+    const list = brain.listDailySummaries();
+    assert.ok(list.length >= 2);
+    assert.ok(list[0].date >= list[1].date);
+  });
+
+  it('listDailySummaries respects limit', () => {
+    const limited = brain.listDailySummaries(1);
+    assert.equal(limited.length, 1);
+  });
+});
+
+describe('Briefing Items', () => {
+  before(() => { setupTestDb(); });
+  after(() => { teardownTestDb(); });
+
+  it('insertBriefingItem creates and returns id', () => {
+    const result = brain.insertBriefingItem({
+      task_id: 'task-1', skill: 'morning-briefing', title: 'Test item',
+      category: 'hiring', owner: 'TestUser', urgency: 'today',
+      context: JSON.stringify({ search_queries: ['test query'] }),
+    });
+    assert.ok(result.id);
+  });
+
+  it('getBriefingItem retrieves item', () => {
+    const inserted = brain.insertBriefingItem({
+      skill: 'morning-briefing', title: 'Another item', urgency: 'async',
+    });
+    const item = brain.getBriefingItem(inserted.id);
+    assert.equal(item.title, 'Another item');
+    assert.equal(item.urgency, 'async');
+    assert.equal(item.status, 'open');
+    assert.equal(item.times_seen, 1);
+  });
+
+  it('findBriefingItemByTitle matches open items', () => {
+    const found = brain.findBriefingItemByTitle('morning-briefing', 'Test item');
+    assert.ok(found);
+    assert.equal(found.title, 'Test item');
+  });
+
+  it('findBriefingItemByTitle does not match done items', () => {
+    const item = brain.insertBriefingItem({ skill: 'test', title: 'Done item' });
+    brain.updateBriefingItem(item.id, { status: 'done', resolved_at: new Date().toISOString() });
+    const found = brain.findBriefingItemByTitle('test', 'Done item');
+    assert.equal(found, null);
+  });
+
+  it('updateBriefingItem updates fields', () => {
+    const item = brain.insertBriefingItem({ skill: 'test', title: 'Update me' });
+    brain.updateBriefingItem(item.id, { status: 'snoozed', snooze_until: '2026-04-01T07:00:00Z', notes: 'will check later' });
+    const updated = brain.getBriefingItem(item.id);
+    assert.equal(updated.status, 'snoozed');
+    assert.equal(updated.notes, 'will check later');
+  });
+
+  it('listBriefingItems filters by skill and status', () => {
+    const all = brain.listBriefingItems({ skill: 'morning-briefing' });
+    assert.ok(all.length >= 2);
+    const open = brain.listBriefingItems({ skill: 'morning-briefing', status: 'open' });
+    assert.ok(open.every(function(i) { return i.status === 'open'; }));
+  });
+
+  it('listOpenBriefingItems excludes done and dismissed', () => {
+    const open = brain.listOpenBriefingItems('morning-briefing');
+    assert.ok(open.every(function(i) { return i.status !== 'done' && i.status !== 'dismissed'; }));
+  });
+
+  it('insertBriefingItem requires title', () => {
+    assert.throws(() => brain.insertBriefingItem({ skill: 'test' }), /title/);
+  });
+});