@stevederico/dotbot 0.18.0 → 0.19.0

package/.claude/settings.local.json

@@ -0,0 +1,7 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(grep -r \"grok-3\" /Users/sd/Desktop/projects/dotbot --include=\"*.js\" --include=\"*.md\" 2>/dev/null | grep -v node_modules)"
+    ]
+  }
+}

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+0.19
+
+  Add test suite (node:test)
+  Zero test dependencies
+
 0.18
 
   Add --verbose flag

package/README.md

@@ -12,7 +12,7 @@
       <img src="https://img.shields.io/github/stars/stevederico/dotbot?style=social" alt="GitHub stars">
     </a>
     <a href="https://github.com/stevederico/dotbot">
-      <img src="https://img.shields.io/badge/version-0.18-green" alt="version">
+      <img src="https://img.shields.io/badge/version-0.19-green" alt="version">
     </a>
     <img src="https://img.shields.io/badge/LOC-11k-orange" alt="Lines of Code">
   </p>
@@ -147,7 +147,7 @@ for await (const event of agent.chat({
 ## CLI Reference
 
 ```
-dotbot v0.18 — AI agent CLI
+dotbot v0.19 — AI agent CLI
 
 Usage:
   dotbot "message"            Send a message (default)

package/bin/dotbot.js

@@ -50,7 +50,7 @@ async function loadModules() {
   agentLoop = mod.agentLoop;
 }
 
-const VERSION = '0.18';
+const VERSION = '0.19';
 const DEFAULT_PORT = 3000;
 const DEFAULT_DB = './dotbot.db';
 

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@stevederico/dotbot",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "AI agent CLI and library for Node.js — streaming, multi-provider, tool execution, autonomous tasks",
   "type": "module",
   "main": "index.js",
   "bin": {
     "dotbot": "./bin/dotbot.js"
   },
+  "scripts": {
+    "test": "node --test test/*.test.js"
+  },
   "exports": {
     ".": "./index.js",
     "./core/*": "./core/*.js",

package/test/events.test.js

@@ -0,0 +1,75 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { validateEvent } from '../core/events.js';
+
+describe('validateEvent', () => {
+  test('rejects non-object events', () => {
+    assert.throws(() => validateEvent(null), /must be an object/);
+    assert.throws(() => validateEvent('string'), /must be an object/);
+  });
+
+  test('rejects events without type', () => {
+    assert.throws(() => validateEvent({}), /must have a type/);
+  });
+
+  test('validates text_delta event', () => {
+    assert.ok(validateEvent({ type: 'text_delta', text: 'hello' }));
+    assert.throws(
+      () => validateEvent({ type: 'text_delta', text: 123 }),
+      /must have text string/
+    );
+  });
+
+  test('validates thinking event', () => {
+    assert.ok(validateEvent({ type: 'thinking', text: 'reasoning', hasNativeThinking: true }));
+    assert.throws(
+      () => validateEvent({ type: 'thinking', text: 'hi' }),
+      /must have hasNativeThinking/
+    );
+  });
+
+  test('validates tool_start event', () => {
+    assert.ok(validateEvent({ type: 'tool_start', name: 'web_search', input: { query: 'test' } }));
+    assert.throws(
+      () => validateEvent({ type: 'tool_start', name: 'test' }),
+      /must have input object/
+    );
+  });
+
+  test('validates tool_result event', () => {
+    assert.ok(validateEvent({
+      type: 'tool_result',
+      name: 'web_search',
+      input: { query: 'test' },
+      result: 'found it'
+    }));
+    assert.throws(
+      () => validateEvent({ type: 'tool_result', name: 'test', input: {} }),
+      /must have result string/
+    );
+  });
+
+  test('validates tool_error event', () => {
+    assert.ok(validateEvent({ type: 'tool_error', name: 'test', error: 'failed' }));
+    assert.throws(
+      () => validateEvent({ type: 'tool_error', name: 'test' }),
+      /must have error string/
+    );
+  });
+
+  test('validates done event', () => {
+    assert.ok(validateEvent({ type: 'done', content: 'finished' }));
+    assert.throws(
+      () => validateEvent({ type: 'done' }),
+      /must have content string/
+    );
+  });
+
+  test('validates error event', () => {
+    assert.ok(validateEvent({ type: 'error', error: 'something broke' }));
+    assert.throws(
+      () => validateEvent({ type: 'error' }),
+      /must have error string/
+    );
+  });
+});

package/test/normalize.test.js

@@ -0,0 +1,79 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { toStandardFormat, toProviderFormat } from '../core/normalize.js';
+
+describe('toStandardFormat', () => {
+  test('normalizes simple user message', () => {
+    const messages = [{ role: 'user', content: 'hello' }];
+    const result = toStandardFormat(messages);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].role, 'user');
+    assert.strictEqual(result[0].content, 'hello');
+  });
+
+  test('normalizes system message', () => {
+    const messages = [{ role: 'system', content: 'You are helpful' }];
+    const result = toStandardFormat(messages);
+    assert.strictEqual(result[0].role, 'system');
+    assert.strictEqual(result[0].content, 'You are helpful');
+  });
+
+  test('normalizes assistant message with text', () => {
+    const messages = [{ role: 'assistant', content: 'Hi there' }];
+    const result = toStandardFormat(messages);
+    assert.strictEqual(result[0].role, 'assistant');
+    assert.strictEqual(result[0].content, 'Hi there');
+  });
+
+  test('handles Anthropic tool_use blocks', () => {
+    const messages = [{
+      role: 'assistant',
+      content: [
+        { type: 'text', text: 'Let me search' },
+        { type: 'tool_use', id: 'tool1', name: 'web_search', input: { query: 'test' } }
+      ]
+    }];
+    const result = toStandardFormat(messages);
+    assert.strictEqual(result[0].role, 'assistant');
+    assert.strictEqual(result[0].content, 'Let me search');
+    assert.ok(result[0].toolCalls);
+    assert.strictEqual(result[0].toolCalls[0].name, 'web_search');
+  });
+
+  test('skips tool-result-only messages', () => {
+    const messages = [
+      { role: 'user', content: 'hello' },
+      { role: 'user', content: [{ type: 'tool_result', tool_use_id: 't1', content: 'result' }] }
+    ];
+    const result = toStandardFormat(messages);
+    assert.strictEqual(result.length, 1);
+    assert.strictEqual(result[0].content, 'hello');
+  });
+});
+
+describe('toProviderFormat', () => {
+  test('converts standard user message to Anthropic', () => {
+    const messages = [{ role: 'user', content: 'hello' }];
+    const result = toProviderFormat(messages, 'anthropic');
+    assert.strictEqual(result[0].role, 'user');
+    assert.strictEqual(result[0].content, 'hello');
+  });
+
+  test('converts standard user message to OpenAI', () => {
+    const messages = [{ role: 'user', content: 'hello' }];
+    const result = toProviderFormat(messages, 'openai');
+    assert.strictEqual(result[0].role, 'user');
+    assert.strictEqual(result[0].content, 'hello');
+  });
+
+  test('converts assistant with toolCalls to Anthropic format', () => {
+    const messages = [{
+      role: 'assistant',
+      content: 'Searching...',
+      toolCalls: [{ id: 't1', name: 'web_search', input: { q: 'test' }, result: 'found', status: 'done' }]
+    }];
+    const result = toProviderFormat(messages, 'anthropic');
+    assert.strictEqual(result[0].role, 'assistant');
+    assert.ok(Array.isArray(result[0].content));
+  });
+});

package/test/storage.test.js

@@ -0,0 +1,93 @@
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert';
+import { unlink } from 'node:fs/promises';
+import { SQLiteSessionStore } from '../storage/SQLiteAdapter.js';
+import { SQLiteMemoryStore } from '../storage/SQLiteMemoryAdapter.js';
+
+const TEST_DB = './test/test.db';
+
+describe('SQLiteSessionStore', () => {
+  let store;
+
+  before(async () => {
+    store = new SQLiteSessionStore();
+    await store.init(TEST_DB);
+  });
+
+  after(async () => {
+    if (store?.db) store.db.close();
+    await unlink(TEST_DB).catch(() => {});
+  });
+
+  test('creates a session', async () => {
+    const session = await store.createSession('user1', 'grok-4-1-fast-reasoning', 'xai');
+    assert.ok(session.id);
+    assert.strictEqual(session.owner, 'user1');
+    assert.strictEqual(session.model, 'grok-4-1-fast-reasoning');
+    assert.strictEqual(session.provider, 'xai');
+  });
+
+  test('retrieves session by id', async () => {
+    const created = await store.createSession('user2', 'gpt-4o', 'openai');
+    const fetched = await store.getSessionInternal(created.id);
+    assert.strictEqual(fetched.id, created.id);
+    assert.strictEqual(fetched.owner, 'user2');
+  });
+
+  test('lists sessions for user', async () => {
+    await store.createSession('user3', 'grok-4-1-fast-reasoning', 'xai');
+    await store.createSession('user3', 'grok-4-1-fast-reasoning', 'xai');
+    const sessions = await store.listSessions('user3');
+    assert.ok(sessions.length >= 2);
+  });
+
+  test('adds message to session', async () => {
+    const session = await store.createSession('user4', 'grok-4-1-fast-reasoning', 'xai');
+    await store.addMessage(session.id, { role: 'user', content: 'hello' });
+    const fetched = await store.getSessionInternal(session.id);
+    const userMsg = fetched.messages.find(m => m.role === 'user' && m.content === 'hello');
+    assert.ok(userMsg);
+  });
+
+  test('deletes session', async () => {
+    const session = await store.createSession('user5', 'grok-4-1-fast-reasoning', 'xai');
+    await store.deleteSession(session.id, 'user5');
+    const fetched = await store.getSessionInternal(session.id);
+    assert.strictEqual(fetched, null);
+  });
+});
+
+describe('SQLiteMemoryStore', () => {
+  let store;
+
+  before(async () => {
+    store = new SQLiteMemoryStore();
+    await store.init(TEST_DB);
+  });
+
+  after(async () => {
+    if (store?.db) store.db.close();
+    await unlink(TEST_DB).catch(() => {});
+  });
+
+  test('saves and retrieves memory', async () => {
+    await store.writeMemory('memuser1', 'favorite_color', 'blue');
+    const memories = await store.getAllMemories('memuser1');
+    const found = memories.find(m => m.key === 'favorite_color');
+    assert.ok(found);
+    assert.strictEqual(found.value, 'blue');
+  });
+
+  test('reads memory by key', async () => {
+    await store.writeMemory('memuser2', 'pet', 'dog named Max');
+    const result = await store.readMemory('memuser2', 'pet');
+    assert.strictEqual(result.value, 'dog named Max');
+  });
+
+  test('deletes memory', async () => {
+    await store.writeMemory('memuser3', 'temp', 'delete me');
+    await store.deleteMemory('memuser3', 'temp');
+    const result = await store.readMemory('memuser3', 'temp');
+    assert.strictEqual(result, null);
+  });
+});

package/test/tools.test.js

@@ -0,0 +1,43 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import { coreTools } from '../tools/index.js';
+
+describe('coreTools', () => {
+  test('exports an array of tools', () => {
+    assert.ok(Array.isArray(coreTools));
+    assert.ok(coreTools.length > 0);
+  });
+
+  test('all tools have required properties', () => {
+    for (const tool of coreTools) {
+      assert.ok(tool.name, `Tool missing name`);
+      assert.ok(tool.description, `Tool ${tool.name} missing description`);
+      assert.ok(tool.parameters, `Tool ${tool.name} missing parameters`);
+      assert.strictEqual(tool.parameters.type, 'object', `Tool ${tool.name} parameters.type must be object`);
+    }
+  });
+
+  test('tool names are unique', () => {
+    const names = coreTools.map(t => t.name);
+    const unique = new Set(names);
+    assert.strictEqual(names.length, unique.size, 'Duplicate tool names found');
+  });
+
+  test('tool names are snake_case', () => {
+    for (const tool of coreTools) {
+      assert.ok(/^[a-z][a-z0-9_]*$/.test(tool.name), `Tool ${tool.name} should be snake_case`);
+    }
+  });
+
+  test('contains expected core tools', () => {
+    const names = coreTools.map(t => t.name);
+    assert.ok(names.includes('memory_save'), 'Missing memory_save');
+    assert.ok(names.includes('web_search'), 'Missing web_search');
+    assert.ok(names.includes('file_read'), 'Missing file_read');
+    assert.ok(names.includes('weather_get'), 'Missing weather_get');
+  });
+
+  test('has at least 40 tools', () => {
+    assert.ok(coreTools.length >= 40, `Expected 40+ tools, got ${coreTools.length}`);
+  });
+});