create-walle 0.1.0

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

@@ -0,0 +1,435 @@
+const { describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { buildExtractionPrompt, parseExtractionResponse } = require('../extraction/knowledge-extractor.js');
+
+// ── Task 9: Knowledge Extractor ─────────────────────────────────────────
+
+describe('buildExtractionPrompt', () => {
+  const memories = [
+    { id: 'm1', source: 'slack', timestamp: '2026-03-22T10:00:00Z', content: 'I prefer SQLite for small projects' },
+    { id: 'm2', source: 'email', timestamp: '2026-03-22T11:00:00Z', content: 'Alice is my colleague on the infra team' },
+  ];
+
+  it('includes owner name in prompt', () => {
+    const prompt = buildExtractionPrompt(memories, 'Test Owner');
+    assert.ok(prompt.includes('Test Owner'), 'prompt should include owner name');
+  });
+
+  it('includes memory content', () => {
+    const prompt = buildExtractionPrompt(memories, 'Test Owner');
+    assert.ok(prompt.includes('I prefer SQLite for small projects'), 'prompt should include memory content');
+    assert.ok(prompt.includes('Alice is my colleague on the infra team'), 'prompt should include all memory content');
+  });
+
+  it('includes memory IDs', () => {
+    const prompt = buildExtractionPrompt(memories, 'Test Owner');
+    assert.ok(prompt.includes('m1'), 'prompt should include memory id m1');
+    assert.ok(prompt.includes('m2'), 'prompt should include memory id m2');
+  });
+});
+
+describe('parseExtractionResponse', () => {
+  const validResponse = JSON.stringify([
+    { category: 'technical', subject: 'Test Owner', predicate: 'prefers', object: 'SQLite', confidence: 0.85, source_memory_ids: ['m1'] },
+    { category: 'relationship', subject: 'Alice', predicate: 'is', object: 'colleague', confidence: 0.6, source_memory_ids: ['m2'] },
+  ]);
+
+  it('parses valid JSON array and returns knowledge entries', () => {
+    const result = parseExtractionResponse(validResponse);
+    assert.equal(result.length, 2);
+    assert.equal(result[0].category, 'technical');
+    assert.equal(result[0].subject, 'Test Owner');
+    assert.equal(result[0].predicate, 'prefers');
+    assert.equal(result[0].object, 'SQLite');
+    assert.equal(result[0].confidence, 0.85);
+    assert.deepEqual(result[0].source_memory_ids, ['m1']);
+    assert.equal(result[1].category, 'relationship');
+  });
+
+  it('returns empty array for invalid JSON', () => {
+    const result = parseExtractionResponse('not valid json');
+    assert.deepEqual(result, []);
+  });
+
+  it('handles JSON wrapped in markdown code fences', () => {
+    const wrapped = '```json\n' + validResponse + '\n```';
+    const result = parseExtractionResponse(wrapped);
+    assert.equal(result.length, 2);
+    assert.equal(result[0].category, 'technical');
+    assert.equal(result[1].subject, 'Alice');
+  });
+
+  it('filters entries missing required fields', () => {
+    const partial = JSON.stringify([
+      { category: 'technical', subject: 'Test Owner', predicate: 'prefers', object: 'SQLite', confidence: 0.85, source_memory_ids: ['m1'] },
+      { category: 'technical', subject: 'Test Owner' }, // missing predicate and object
+    ]);
+    const result = parseExtractionResponse(partial);
+    assert.equal(result.length, 1);
+    assert.equal(result[0].object, 'SQLite');
+  });
+});
+
+// ── Task 10: Think Loop ─────────────────────────────────────────────────
+
+const { before, after } = require('node:test');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const brain = require('../brain');
+const think = require('../loops/think');
+
+describe('think loop', () => {
+  const ownerName = 'TestOwner';
+  let tmpDir;
+
+  const mockExtract = async (memories, ownerName) => [
+    {
+      category: 'technical',
+      subject: ownerName,
+      predicate: 'prefers',
+      object: 'early returns over nested conditionals',
+      confidence: 0.85,
+      source_memory_ids: memories.map(m => m.id),
+    },
+  ];
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-think-test-'));
+    brain.initDb(path.join(tmpDir, 'test.db'));
+    brain.setOwner('name', ownerName);
+  });
+
+  after(() => {
+    brain.closeDb();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('processes pending memories and returns correct counts', async () => {
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'I always use early returns', timestamp: '2026-03-22T10:00:00Z',
+    });
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'Nested conditionals are hard to read', timestamp: '2026-03-22T10:01:00Z',
+    });
+
+    const result = await think.runOnce({ extractFn: mockExtract });
+    assert.equal(result.memoriesProcessed, 2);
+    assert.equal(result.knowledgeExtracted, 1);
+  });
+
+  it('stores extracted knowledge in the brain', () => {
+    const entries = brain.findKnowledge({ subject: ownerName });
+    assert.ok(entries.length > 0, 'should have knowledge entries for owner');
+    const match = entries.find(e => e.predicate === 'prefers' && e.object === 'early returns over nested conditionals');
+    assert.ok(match, 'should find the extracted knowledge entry');
+  });
+
+  it('marks processed memories as done', () => {
+    const done = brain.listMemories({ extractionStatus: 'done' });
+    assert.equal(done.length, 2, 'both memories should be marked done');
+  });
+
+  it('marks memories as failed when extractFn throws', async () => {
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'This will fail extraction', timestamp: '2026-03-22T11:00:00Z',
+    });
+
+    const result = await think.runOnce({
+      extractFn: () => { throw new Error('API down'); },
+    });
+
+    assert.equal(result.memoriesProcessed, 1);
+    assert.equal(result.knowledgeExtracted, 0);
+
+    const failed = brain.listMemories({ extractionStatus: 'failed' });
+    assert.equal(failed.length, 1, 'the memory should be marked failed');
+  });
+
+  it('returns zeros when no pending memories exist', async () => {
+    const result = await think.runOnce({ extractFn: mockExtract });
+    assert.equal(result.memoriesProcessed, 0);
+    assert.equal(result.knowledgeExtracted, 0);
+  });
+});
+
+// ── Task 3: Contradiction Integration ────────────────────────────────────
+
+describe('think loop - contradictions', () => {
+  const ownerName = 'ContraOwner';
+  let tmpDir;
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-contra-test-'));
+    brain.initDb(path.join(tmpDir, 'test.db'));
+    brain.setOwner('name', ownerName);
+  });
+
+  after(() => {
+    brain.closeDb();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('creates pending question and supersedes old knowledge when contradiction detected', async () => {
+    // Insert existing knowledge that will be contradicted
+    const oldK = brain.insertKnowledge({
+      category: 'preference',
+      subject: ownerName,
+      predicate: 'prefers_db',
+      object: 'MySQL',
+      confidence: 0.8,
+    });
+
+    // Insert a pending memory
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'Actually I now prefer SQLite', timestamp: '2026-03-22T12:00:00Z',
+    });
+
+    const mockExtract = async (memories) => [{
+      category: 'preference',
+      subject: ownerName,
+      predicate: 'prefers_db',
+      object: 'SQLite',
+      confidence: 0.9,
+      source_memory_ids: memories.map(m => m.id),
+    }];
+
+    const mockDetectFn = (existing, entries) => {
+      // Find the MySQL entry in existing knowledge
+      const mysqlEntry = existing.find(e => e.object === 'MySQL');
+      if (!mysqlEntry) return [];
+      const newEntry = entries.find(e => e.object === 'SQLite');
+      if (!newEntry) return [];
+      return [{
+        old_id: mysqlEntry.id,
+        new_subject: newEntry.subject,
+        new_predicate: newEntry.predicate,
+        new_object: newEntry.object,
+        explanation: 'Changed database preference from MySQL to SQLite',
+      }];
+    };
+
+    await think.runOnce({ extractFn: mockExtract, detectFn: mockDetectFn });
+
+    // Verify a pending question was created
+    const questions = brain.listQuestions({ question_type: 'contradiction' });
+    assert.ok(questions.length > 0, 'should have created a contradiction question');
+    assert.equal(questions[0].question_type, 'contradiction');
+    assert.ok(questions[0].question.includes('MySQL'), 'question should mention the contradiction');
+
+    // Verify old knowledge was superseded
+    const oldKnowledge = brain.getKnowledge(oldK.id);
+    assert.equal(oldKnowledge.status, 'superseded', 'old knowledge should be superseded');
+    assert.ok(oldKnowledge.superseded_by, 'should have superseded_by set');
+  });
+
+  it('inserts knowledge normally when no contradictions found', async () => {
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'I like hiking', timestamp: '2026-03-22T13:00:00Z',
+    });
+
+    const mockExtract = async (memories) => [{
+      category: 'hobby',
+      subject: ownerName,
+      predicate: 'enjoys',
+      object: 'hiking',
+      confidence: 0.7,
+      source_memory_ids: memories.map(m => m.id),
+    }];
+
+    const mockDetectFn = () => [];
+
+    const questionsBefore = brain.listQuestions({ question_type: 'contradiction' }).length;
+
+    await think.runOnce({ extractFn: mockExtract, detectFn: mockDetectFn });
+
+    const questionsAfter = brain.listQuestions({ question_type: 'contradiction' }).length;
+    assert.equal(questionsAfter, questionsBefore, 'no new contradiction questions should be created');
+
+    const hiking = brain.findKnowledge({ subject: ownerName, predicate: 'enjoys' });
+    assert.ok(hiking.length > 0, 'hiking knowledge should be inserted');
+  });
+
+  it('contradiction creates question with question_type=contradiction', async () => {
+    // Insert existing knowledge
+    const oldK = brain.insertKnowledge({
+      category: 'work',
+      subject: ownerName,
+      predicate: 'works_at',
+      object: 'CompanyA',
+      confidence: 0.9,
+    });
+
+    brain.insertMemory({
+      source: 'test', memory_type: 'observation',
+      content: 'I now work at CompanyB', timestamp: '2026-03-22T14:00:00Z',
+    });
+
+    const mockExtract = async (memories) => [{
+      category: 'work',
+      subject: ownerName,
+      predicate: 'works_at',
+      object: 'CompanyB',
+      confidence: 0.9,
+      source_memory_ids: memories.map(m => m.id),
+    }];
+
+    const mockDetectFn = (existing, entries) => {
+      const old = existing.find(e => e.object === 'CompanyA');
+      const ne = entries.find(e => e.object === 'CompanyB');
+      if (!old || !ne) return [];
+      return [{
+        old_id: old.id,
+        new_subject: ne.subject,
+        new_predicate: ne.predicate,
+        new_object: ne.object,
+        explanation: 'Changed employer from CompanyA to CompanyB',
+      }];
+    };
+
+    await think.runOnce({ extractFn: mockExtract, detectFn: mockDetectFn });
+
+    const questions = brain.listQuestions({ question_type: 'contradiction' });
+    const companyQ = questions.find(q => q.question.includes('CompanyA') || q.question.includes('CompanyB'));
+    assert.ok(companyQ, 'should find the contradiction question');
+    assert.equal(companyQ.question_type, 'contradiction');
+    assert.equal(companyQ.status, 'pending');
+  });
+});
+
+// ── Task 4: Pending Question Self-Resolution ─────────────────────────────
+
+describe('think loop - self-resolution', () => {
+  const ownerName = 'ResolveOwner';
+  let tmpDir;
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-resolve-test-'));
+    brain.initDb(path.join(tmpDir, 'test.db'));
+    brain.setOwner('name', ownerName);
+  });
+
+  after(() => {
+    brain.closeDb();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('resolves pending question when enough new memories exist', async () => {
+    // Insert a pending question (created_at will be "now")
+    const q = brain.insertQuestion({
+      question_type: 'contradiction',
+      question: 'Is SQLite or MySQL preferred?',
+      context: JSON.stringify({ old_id: 'fake-old', new_entry: {} }),
+    });
+
+    // Insert 5 memories with timestamps after the question was created
+    const futureTime = new Date(Date.now() + 60000).toISOString();
+    for (let i = 0; i < 5; i++) {
+      brain.insertMemory({
+        source: 'test', memory_type: 'observation',
+        content: `Memory supporting SQLite preference ${i}`,
+        timestamp: futureTime,
+      });
+    }
+
+    const mockSelfResolve = async (question, memories, owner) => {
+      if (memories.length > 3) {
+        return {
+          resolved: true,
+          answer: 'SQLite is preferred',
+          evidence: ['mem-1', 'mem-2'],
+        };
+      }
+      return { resolved: false };
+    };
+
+    // No pending extraction memories (they all got inserted above with pending status),
+    // but we need to mark them done so they don't go through extraction
+    const pendingMems = brain.listMemories({ extractionStatus: 'pending' });
+    for (const m of pendingMems) {
+      brain.updateMemoryExtraction(m.id, 'done');
+    }
+
+    await think.runOnce({
+      extractFn: async () => [],
+      selfResolveFn: mockSelfResolve,
+    });
+
+    const resolved = brain.listQuestions({ status: 'inferred' });
+    const match = resolved.find(r => r.id === q.id);
+    assert.ok(match, 'question should be resolved');
+    assert.equal(match.status, 'inferred');
+    assert.equal(match.answer, 'SQLite is preferred');
+    assert.equal(match.resolution_type, 'inferred');
+  });
+
+  it('keeps question pending with insufficient memories', async () => {
+    // Insert a question with a far-future created_at so no memories qualify
+    // We do this by inserting directly with a future timestamp
+    const db = brain.getDb();
+    const { v4: uuidv4 } = require('uuid');
+    const qId = uuidv4();
+    db.prepare(`
+      INSERT INTO pending_questions (id, question_type, question, status, created_at)
+      VALUES (?, ?, ?, 'pending', ?)
+    `).run(qId, 'preference', 'What editor does the user prefer?', '2099-01-01T00:00:00Z');
+
+    let selfResolveCalled = false;
+    const mockSelfResolve = async () => {
+      selfResolveCalled = true;
+      return { resolved: true, answer: 'should not be called' };
+    };
+
+    await think.runOnce({
+      extractFn: async () => [],
+      selfResolveFn: mockSelfResolve,
+    });
+
+    assert.equal(selfResolveCalled, false, 'selfResolveFn should not be called with insufficient memories');
+    const question = brain.listQuestions({ status: 'pending' }).find(q => q.id === qId);
+    assert.ok(question, 'question should still be pending');
+    assert.equal(question.status, 'pending');
+  });
+
+  it('keeps question pending when selfResolveFn says not resolved', async () => {
+    const q = brain.insertQuestion({
+      question_type: 'contradiction',
+      question: 'Unresolvable question',
+    });
+
+    // Insert enough memories to trigger self-resolution attempt
+    const futureTime = new Date(Date.now() + 120000).toISOString();
+    for (let i = 0; i < 5; i++) {
+      brain.insertMemory({
+        source: 'test', memory_type: 'observation',
+        content: `Unrelated memory ${i}`,
+        timestamp: futureTime,
+      });
+    }
+
+    // Mark all pending memories done
+    const pendingMems = brain.listMemories({ extractionStatus: 'pending' });
+    for (const m of pendingMems) {
+      brain.updateMemoryExtraction(m.id, 'done');
+    }
+
+    const mockSelfResolve = async () => {
+      return { resolved: false };
+    };
+
+    await think.runOnce({
+      extractFn: async () => [],
+      selfResolveFn: mockSelfResolve,
+    });
+
+    const questions = brain.listQuestions({ status: 'pending' });
+    const match = questions.find(r => r.id === q.id);
+    assert.ok(match, 'question should still be pending');
+  });
+});