@stevederico/dotbot 0.17.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,14 @@
+0.19
+
+  Add test suite (node:test)
+  Zero test dependencies
+
+0.18
+
+  Add --verbose flag
+  Hide init logs by default
+  Add publishConfig for npm
+
 0.17
 
   Default model grok-4-1-fast-reasoning

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.17-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.17 — 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.17';
+const VERSION = '0.19';
 const DEFAULT_PORT = 3000;
 const DEFAULT_DB = './dotbot.db';
 
@@ -71,6 +71,7 @@ Options:
   --model, -m      Model name (default: grok-4-1-fast-reasoning)
   --db             SQLite database path (default: ${DEFAULT_DB})
   --port           Server port for 'serve' command (default: ${DEFAULT_PORT})
+  --verbose        Show initialization logs
   --help, -h       Show this help
   --version, -v    Show version
 
@@ -98,6 +99,7 @@ function parseCliArgs() {
       options: {
         help: { type: 'boolean', short: 'h', default: false },
         version: { type: 'boolean', short: 'v', default: false },
+        verbose: { type: 'boolean', default: false },
         provider: { type: 'string', short: 'p', default: 'xai' },
         model: { type: 'string', short: 'm', default: 'grok-4-1-fast-reasoning' },
         db: { type: 'string', default: DEFAULT_DB },
@@ -149,11 +151,18 @@ async function getProviderConfig(providerId) {
  * Initialize stores.
  *
  * @param {string} dbPath - Path to SQLite database
+ * @param {boolean} verbose - Show initialization logs
  * @returns {Promise<Object>} Initialized stores
  */
-async function initStores(dbPath) {
+async function initStores(dbPath, verbose = false) {
   await loadModules();
 
+  // Suppress init logs unless verbose
+  const originalLog = console.log;
+  if (!verbose) {
+    console.log = () => {};
+  }
+
   const sessionStore = new stores.SQLiteSessionStore();
   await sessionStore.init(dbPath, {
     prefsFetcher: async () => ({ agentName: 'Dotbot', agentPersonality: '' }),
@@ -174,6 +183,9 @@ async function initStores(dbPath) {
   const eventStore = new stores.SQLiteEventStore();
   await eventStore.init(dbPath);
 
+  // Restore console.log
+  console.log = originalLog;
+
   return { sessionStore, cronStore, taskStore, triggerStore, memoryStore, eventStore };
 }
 
@@ -184,7 +196,7 @@ async function initStores(dbPath) {
  * @param {Object} options - CLI options
  */
 async function runChat(message, options) {
-  const storesObj = await initStores(options.db);
+  const storesObj = await initStores(options.db, options.verbose);
   const provider = await getProviderConfig(options.provider);
 
   const session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
@@ -238,7 +250,7 @@ async function runChat(message, options) {
  * @param {Object} options - CLI options
  */
 async function runRepl(options) {
-  const storesObj = await initStores(options.db);
+  const storesObj = await initStores(options.db, options.verbose);
   const provider = await getProviderConfig(options.provider);
 
   const session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
@@ -338,7 +350,7 @@ async function runRepl(options) {
  */
 async function runServer(options) {
   const port = parseInt(options.port, 10);
-  const storesObj = await initStores(options.db);
+  const storesObj = await initStores(options.db, options.verbose);
 
   const server = createServer(async (req, res) => {
     // CORS headers

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@stevederico/dotbot",
-  "version": "0.17.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",
@@ -38,5 +41,8 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/stevederico/dotbot.git"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

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