create-walle 0.1.0

package/template/wall-e/tests/mcp-client.test.js

@@ -0,0 +1,71 @@
+'use strict';
+const { describe, it } = require('node:test');
+const assert = require('node:assert');
+
+const {
+  loadMcpConfigs,
+  StdioTransport,
+  HttpTransport,
+  getConnection,
+  disconnectAll,
+  listAllTools,
+} = require('../skills/mcp-client');
+
+describe('mcp-client', () => {
+  describe('loadMcpConfigs', () => {
+    it('returns an object with server names as keys', () => {
+      const configs = loadMcpConfigs();
+      assert.strictEqual(typeof configs, 'object');
+      assert.ok(configs !== null);
+      // Each value should have a name property
+      for (const [key, cfg] of Object.entries(configs)) {
+        assert.strictEqual(cfg.name, key);
+      }
+    });
+  });
+
+  describe('StdioTransport', () => {
+    it('stores config on construction', () => {
+      const config = { name: 'test-server', command: 'node', args: ['--version'] };
+      const transport = new StdioTransport(config);
+      assert.strictEqual(transport.config.name, 'test-server');
+      assert.strictEqual(transport.config.command, 'node');
+      assert.strictEqual(transport.initialized, false);
+      assert.strictEqual(transport.nextId, 1);
+    });
+  });
+
+  describe('HttpTransport', () => {
+    it('stores URL from config', () => {
+      const config = { name: 'http-server', url: 'https://example.com/mcp', type: 'http' };
+      const transport = new HttpTransport(config);
+      assert.strictEqual(transport.url, 'https://example.com/mcp');
+      assert.strictEqual(transport.initialized, false);
+      assert.strictEqual(transport.nextId, 1);
+      assert.deepStrictEqual(transport.authHeaders, {});
+    });
+  });
+
+  describe('getConnection', () => {
+    it('throws for unknown server name', async () => {
+      await assert.rejects(
+        () => getConnection('nonexistent-server-xyz-999'),
+        /not found in config/
+      );
+    });
+  });
+
+  describe('disconnectAll', () => {
+    it('clears connections without error', () => {
+      // Should not throw even when there are no connections
+      assert.doesNotThrow(() => disconnectAll());
+    });
+  });
+
+  describe('listAllTools', () => {
+    it('returns an array (may be empty if no servers reachable)', async () => {
+      const tools = await listAllTools();
+      assert.ok(Array.isArray(tools));
+    });
+  });
+});

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

@@ -0,0 +1,103 @@
+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');
+const reflect = require('../loops/reflect');
+
+describe('reflect loop', () => {
+  const ownerName = 'ReflectOwner';
+  let tmpDir;
+
+  const mockGenerateFn = async (memories, stats) => {
+    return 'Daily summary: 10 memories ingested, 3 knowledge extracted.';
+  };
+
+  before(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-reflect-test-'));
+    brain.initDb(path.join(tmpDir, 'test.db'));
+    brain.setOwner('name', ownerName);
+
+    // Insert some test memories
+    for (let i = 0; i < 5; i++) {
+      brain.insertMemory({
+        source: 'test',
+        memory_type: 'observation',
+        content: `Test memory ${i}`,
+        timestamp: new Date().toISOString(),
+      });
+    }
+
+    // Insert a pending question
+    brain.insertQuestion({
+      question_type: 'preference',
+      question: 'Does user prefer tabs or spaces?',
+    });
+  });
+
+  after(() => {
+    brain.closeDb();
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it('returns stats object with memoriesSinceLastReflect and pendingQuestions', async () => {
+    const result = await reflect.runOnce({});
+    assert.ok('memoriesSinceLastReflect' in result, 'should have memoriesSinceLastReflect');
+    assert.ok('pendingQuestions' in result, 'should have pendingQuestions');
+    assert.ok('summaryGenerated' in result, 'should have summaryGenerated');
+    assert.ok(result.memoriesSinceLastReflect >= 5, 'should count memories');
+    assert.equal(result.pendingQuestions, 1, 'should count pending questions');
+  });
+
+  it('creates daily summary when forceSummary is true', async () => {
+    const result = await reflect.runOnce({ forceSummary: true, generateFn: mockGenerateFn });
+    assert.equal(result.summaryGenerated, true, 'summary should be generated');
+
+    const today = new Date().toISOString().slice(0, 10);
+    const summary = brain.getDailySummary(today);
+    assert.ok(summary, 'summary should exist in DB');
+    assert.ok(summary.summary.includes('Daily summary'), 'summary text should match');
+  });
+
+  it('generateDailySummary stores summary in DB and returns it', async () => {
+    // Use a different date by creating a fresh DB
+    const tmpDir2 = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-reflect-gen-'));
+    brain.closeDb();
+    brain.initDb(path.join(tmpDir2, 'test.db'));
+    brain.setOwner('name', ownerName);
+
+    const result = await reflect.generateDailySummary({ generateFn: mockGenerateFn });
+    assert.ok(result, 'should return summary');
+    assert.ok(result.summary.includes('Daily summary'), 'summary text should match mock');
+
+    const today = new Date().toISOString().slice(0, 10);
+    const stored = brain.getDailySummary(today);
+    assert.ok(stored, 'summary should be stored in DB');
+    assert.equal(stored.summary, result.summary);
+
+    brain.closeDb();
+    fs.rmSync(tmpDir2, { recursive: true, force: true });
+
+    // Re-init original DB for remaining tests
+    brain.initDb(path.join(tmpDir, 'test.db'));
+  });
+
+  it('returns existing summary without creating duplicate for same day', async () => {
+    // First call should have already created today's summary from the forceSummary test
+    const today = new Date().toISOString().slice(0, 10);
+    const existingBefore = brain.getDailySummary(today);
+    assert.ok(existingBefore, 'summary should already exist from previous test');
+
+    const result = await reflect.generateDailySummary({ generateFn: mockGenerateFn });
+    assert.equal(result.id, existingBefore.id, 'should return same summary, not create new one');
+  });
+
+  it('updates checkpoint after reflect', async () => {
+    await reflect.runOnce({});
+    const checkpoint = brain.getCheckpoint('reflect');
+    assert.ok(checkpoint, 'checkpoint should exist');
+    assert.ok(checkpoint.last_run_at, 'checkpoint should have last_run_at');
+    assert.ok(checkpoint.metadata, 'checkpoint should have metadata');
+  });
+});

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

@@ -0,0 +1,111 @@
+'use strict';
+const { describe, it, before, after } = require('node:test');
+const assert = require('node:assert');
+const http = require('http');
+
+// Use a random high port for testing
+const TEST_PORT = 19000 + Math.floor(Math.random() * 1000);
+process.env.WALL_E_PORT = String(TEST_PORT);
+process.env.WALL_E_HOST = '127.0.0.1';
+
+// We need brain initialized for status endpoint — use a temp db
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'walle-server-test-'));
+process.env.WALL_E_DATA_DIR = tmpDir;
+
+const brain = require('../brain');
+const { _setReadDb, _setBrain } = require('../api-walle');
+
+let server;
+
+function request(urlPath, options = {}) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      hostname: '127.0.0.1',
+      port: TEST_PORT,
+      path: urlPath,
+      method: options.method || 'GET',
+      headers: options.headers || {},
+    }, (res) => {
+      const chunks = [];
+      res.on('data', chunk => chunks.push(chunk));
+      res.on('end', () => {
+        const body = Buffer.concat(chunks).toString();
+        let json = null;
+        try { json = JSON.parse(body); } catch {}
+        resolve({ status: res.statusCode, headers: res.headers, body, json });
+      });
+    });
+    req.on('error', reject);
+    if (options.body) req.write(JSON.stringify(options.body));
+    req.end();
+  });
+}
+
+describe('WALL-E HTTP Server', () => {
+  before(async () => {
+    brain.initDb(path.join(tmpDir, 'test-brain.db'));
+    _setBrain(brain);
+
+    // Open a read-only connection for api-walle
+    const Database = require('better-sqlite3');
+    const readDb = new Database(path.join(tmpDir, 'test-brain.db'), { readonly: true });
+    readDb.pragma('journal_mode = WAL');
+    _setReadDb(readDb);
+
+    const { startServer } = require('../server');
+    server = startServer();
+
+    // Wait for server to be listening
+    await new Promise((resolve) => {
+      if (server.listening) return resolve();
+      server.on('listening', resolve);
+    });
+  });
+
+  after(() => {
+    if (server) server.close();
+    brain.closeDb();
+    // Cleanup temp dir
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch {}
+  });
+
+  it('GET /api/wall-e/health returns {status: "ok"}', async () => {
+    const res = await request('/api/wall-e/health');
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.json.status, 'ok');
+    assert.strictEqual(res.json.version, '0.1.0');
+    assert.strictEqual(typeof res.json.uptime, 'number');
+  });
+
+  it('GET /api/wall-e/status returns enriched status', async () => {
+    const res = await request('/api/wall-e/status');
+    assert.strictEqual(res.status, 200);
+    assert.ok(res.json.data);
+    assert.strictEqual(res.json.data.version, '0.1.0');
+    assert.strictEqual(typeof res.json.data.uptime, 'number');
+    assert.ok(res.json.data.stats);
+    assert.ok('loop_health' in res.json.data);
+    assert.ok('adapters' in res.json.data);
+  });
+
+  it('GET /unknown returns 404', async () => {
+    const res = await request('/unknown');
+    assert.strictEqual(res.status, 404);
+    assert.strictEqual(res.json.error, 'Not found');
+  });
+
+  it('GET /api/wall-e/nonexistent returns 404 from API handler', async () => {
+    const res = await request('/api/wall-e/nonexistent');
+    assert.strictEqual(res.status, 404);
+    assert.strictEqual(res.json.error, 'Not found');
+  });
+
+  it('OPTIONS request returns 204 with CORS headers', async () => {
+    const res = await request('/api/wall-e/health', { method: 'OPTIONS' });
+    assert.strictEqual(res.status, 204);
+    assert.ok(res.headers['access-control-allow-origin']);
+  });
+});

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

@@ -0,0 +1,198 @@
+'use strict';
+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-skills-test-'));
+  testDbPath = path.join(testDir, 'test-brain.db');
+  brain.initDb(testDbPath);
+  brain.setOwner('name', 'Test User');
+}
+
+function teardownTestDb() {
+  try { brain.closeDb(); } catch (_) {}
+  if (testDir && fs.existsSync(testDir)) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+}
+
+// ── Brain Skills CRUD ────────────────────────────────────────────
+
+describe('Skills CRUD', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('insertSkill creates a skill and returns id', () => {
+    const result = brain.insertSkill({
+      name: 'test-skill',
+      description: 'A test skill',
+      trigger_type: 'interval',
+      trigger_config: JSON.stringify({ interval_ms: 60000 }),
+      prompt_template: 'Do something',
+    });
+    assert.ok(result.id, 'should return an id');
+  });
+
+  it('getSkill retrieves the created skill', () => {
+    const skill = brain.getSkillByName('test-skill');
+    assert.ok(skill);
+    assert.equal(skill.name, 'test-skill');
+    assert.equal(skill.description, 'A test skill');
+    assert.equal(skill.enabled, 1);
+    assert.equal(skill.success_count, 0);
+    assert.equal(skill.failure_count, 0);
+  });
+
+  it('listSkills returns all skills', () => {
+    const skills = brain.listSkills({});
+    assert.ok(skills.length >= 1);
+  });
+
+  it('listSkills filters by enabled', () => {
+    brain.insertSkill({ name: 'disabled-skill', description: 'disabled' });
+    const skill = brain.getSkillByName('disabled-skill');
+    brain.updateSkill(skill.id, { enabled: 0 });
+
+    const enabled = brain.listSkills({ enabled: 1 });
+    const disabled = brain.listSkills({ enabled: 0 });
+    assert.ok(enabled.every(s => s.enabled === 1));
+    assert.ok(disabled.every(s => s.enabled === 0));
+    assert.ok(disabled.length >= 1);
+  });
+
+  it('updateSkillStats increments success_count', () => {
+    const skill = brain.getSkillByName('test-skill');
+    brain.updateSkillStats(skill.id, true);
+    const updated = brain.getSkill(skill.id);
+    assert.equal(updated.success_count, 1);
+    assert.equal(updated.last_result, 'success');
+    assert.ok(updated.last_run);
+  });
+
+  it('updateSkillStats increments failure_count', () => {
+    const skill = brain.getSkillByName('test-skill');
+    brain.updateSkillStats(skill.id, false);
+    const updated = brain.getSkill(skill.id);
+    assert.equal(updated.failure_count, 1);
+    assert.equal(updated.last_result, 'failure');
+  });
+
+  it('insertSkillExecution creates an execution record', () => {
+    const skill = brain.getSkillByName('test-skill');
+    const result = brain.insertSkillExecution({
+      skill_id: skill.id,
+      status: 'success',
+      tool_calls: '[]',
+      tool_results: '[]',
+      memories_created: 3,
+      duration_ms: 1500,
+    });
+    assert.ok(result.id);
+  });
+
+  it('listSkillExecutions returns executions for a skill', () => {
+    const skill = brain.getSkillByName('test-skill');
+    const execs = brain.listSkillExecutions({ skill_id: skill.id, limit: 10 });
+    assert.ok(execs.length >= 1);
+    assert.equal(execs[0].status, 'success');
+    assert.equal(execs[0].memories_created, 3);
+  });
+
+  it('insertSkill with duplicate name throws', () => {
+    assert.throws(() => brain.insertSkill({ name: 'test-skill', description: 'dup' }));
+  });
+
+  it('updateSkill rejects invalid fields', () => {
+    const skill = brain.getSkillByName('test-skill');
+    assert.throws(() => brain.updateSkill(skill.id, { id: 'evil' }), /Invalid update fields/);
+  });
+});
+
+// ── Tool Executor ────────────────────────────────────────────────
+
+describe('Tool Executor', () => {
+  const { executeTool, getToolDefinitions } = require('../skills/tool-executor');
+
+  it('getToolDefinitions returns array of tools', () => {
+    const defs = getToolDefinitions();
+    assert.ok(defs.length >= 3, `Expected at least 3 tools, got ${defs.length}`);
+    const names = defs.map(d => d.name);
+    assert.ok(names.includes('http_fetch'));
+    assert.ok(names.includes('read_file'));
+    assert.ok(names.includes('shell_exec'));
+  });
+
+  it('executeTool returns error for unknown tool', async () => {
+    const result = await executeTool('nonexistent', {});
+    assert.equal(result.success, false);
+    assert.ok(result.error.includes('Unknown tool'));
+  });
+
+  it('executeTool read_file returns error for nonexistent file', async () => {
+    const result = await executeTool('read_file', { file_path: '/nonexistent/path/file.txt' });
+    assert.equal(result.success, false);
+    assert.ok(result.error);
+  });
+
+  it('executeTool shell_exec with echo returns stdout', async () => {
+    const result = await executeTool('shell_exec', { command: 'echo', args: ['hello'] });
+    assert.equal(result.success, true);
+    assert.ok(result.result.stdout.includes('hello'));
+  });
+
+  it('executeTool shell_exec rejects disallowed command', async () => {
+    const result = await executeTool('shell_exec', { command: 'rm', args: ['-rf', '/'] });
+    assert.equal(result.success, false);
+    assert.ok(result.error.includes('not allowed'));
+  });
+
+  it('executeTool shell_exec rejects command without name', async () => {
+    const result = await executeTool('shell_exec', { command: '' });
+    assert.equal(result.success, false);
+    assert.ok(result.error.includes('required'));
+  });
+
+  it('executeTool http_fetch rejects non-http URLs', async () => {
+    const result = await executeTool('http_fetch', { url: 'file:///etc/passwd' });
+    assert.equal(result.success, false);
+    assert.ok(result.error.includes('Only http/https'));
+  });
+
+  it('executeTool read_file rejects paths outside home', async () => {
+    const result = await executeTool('read_file', { file_path: '/etc/passwd' });
+    assert.equal(result.success, false);
+    assert.ok(result.error.includes('home directory'));
+  });
+});
+
+// ── Claude Code Reader ────────────────────────────────────────────
+
+describe('Claude Code Reader', () => {
+  const { readMcpConfig, readClaudeSkills, suggestSkillsFromClaudeCode } = require('../skills/claude-code-reader');
+
+  it('readMcpConfig returns an array', () => {
+    const configs = readMcpConfig();
+    assert.ok(Array.isArray(configs));
+  });
+
+  it('readClaudeSkills returns an array', () => {
+    const skills = readClaudeSkills();
+    assert.ok(Array.isArray(skills));
+  });
+
+  it('suggestSkillsFromClaudeCode returns object with expected keys', () => {
+    const result = suggestSkillsFromClaudeCode();
+    assert.ok(result);
+    assert.ok(Array.isArray(result.mcpServers));
+    assert.ok(Array.isArray(result.claudeSkills));
+    assert.ok(Array.isArray(result.suggestions));
+  });
+});

package/template/wall-e/tests/slack-ingest.test.js

@@ -0,0 +1,103 @@
+'use strict';
+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-slack-ingest-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 });
+  }
+}
+
+describe('Slack Ingest Module', () => {
+  before(() => setupTestDb());
+  after(() => teardownTestDb());
+
+  it('getSlackToken() returns a string or null', () => {
+    const slackIngest = require('../skills/slack-ingest');
+    const token = slackIngest.getSlackToken();
+    assert.ok(token === null || typeof token === 'string',
+      'getSlackToken should return null or a string');
+  });
+
+  it('getProgress() returns object with expected fields', () => {
+    const slackIngest = require('../skills/slack-ingest');
+    const progress = slackIngest.getProgress();
+    assert.ok(typeof progress === 'object', 'getProgress should return an object');
+    assert.ok('phase' in progress, 'progress should have phase');
+    assert.ok('conversations_total' in progress, 'progress should have conversations_total');
+    assert.ok('conversations_processed' in progress, 'progress should have conversations_processed');
+    assert.ok('messages_ingested' in progress, 'progress should have messages_ingested');
+    assert.ok('started_at' in progress, 'progress should have started_at');
+    assert.ok('completed_at' in progress, 'progress should have completed_at');
+    assert.ok('percent' in progress, 'progress should have percent');
+  });
+
+  it('getProgress() returns default state when no checkpoint exists', () => {
+    const slackIngest = require('../skills/slack-ingest');
+    const progress = slackIngest.getProgress();
+    assert.equal(progress.phase, 'conversations', 'default phase should be conversations');
+    assert.equal(progress.conversations_total, 0, 'default conversations_total should be 0');
+    assert.equal(progress.conversations_processed, 0, 'default conversations_processed should be 0');
+    assert.equal(progress.messages_ingested, 0, 'default messages_ingested should be 0');
+    assert.equal(progress.completed_at, null, 'default completed_at should be null');
+    assert.equal(progress.percent, 0, 'default percent should be 0');
+  });
+
+  it('resetCheckpoint() clears state back to defaults', () => {
+    const slackIngest = require('../skills/slack-ingest');
+
+    // First save some custom state
+    brain.upsertCheckpoint('slack-ingest', {
+      last_memory_at: new Date().toISOString(),
+      metadata: JSON.stringify({
+        phase: 'history',
+        conversations: [{ id: 'C1', name: 'test', type: 'im' }],
+        current_conv_index: 1,
+        total_messages: 42,
+        total_conversations: 1,
+        started_at: '2024-01-01T00:00:00.000Z',
+      }),
+    });
+
+    // Verify non-default state
+    let progress = slackIngest.getProgress();
+    assert.equal(progress.phase, 'history');
+    assert.equal(progress.messages_ingested, 42);
+
+    // Reset
+    slackIngest.resetCheckpoint();
+
+    // Verify reset
+    progress = slackIngest.getProgress();
+    assert.equal(progress.phase, 'conversations', 'phase should be reset to conversations');
+    assert.equal(progress.conversations_total, 0, 'conversations_total should be reset to 0');
+    assert.equal(progress.messages_ingested, 0, 'messages_ingested should be reset to 0');
+    assert.equal(progress.conversations_processed, 0, 'conversations_processed should be reset to 0');
+  });
+
+  it('runIngestBatch() returns no_token error when no Slack token', async () => {
+    const slackIngest = require('../skills/slack-ingest');
+    // Unless the user happens to have a valid token, this should fail gracefully
+    const result = await slackIngest.runIngestBatch();
+    // Either no_token error or it actually has a token and starts working
+    assert.ok(typeof result === 'object', 'runIngestBatch should return an object');
+    assert.ok('done' in result, 'result should have done field');
+    assert.ok('messagesIngested' in result, 'result should have messagesIngested field');
+    assert.ok('conversationsProcessed' in result, 'result should have conversationsProcessed field');
+  });
+});