@stevederico/dotbot 0.18.0 → 0.20.0

package/storage/SQLiteAdapter.js

@@ -1,9 +1,44 @@
 import crypto from 'crypto';
 import { DatabaseSync } from 'node:sqlite';
 import { SessionStore } from './SessionStore.js';
-import { defaultSystemPrompt } from './MongoAdapter.js';
 import { toStandardFormat } from '../core/normalize.js';
 
+/**
+ * Default system prompt builder for the agent.
+ *
+ * @param {Object} options - Prompt options
+ * @param {string} options.agentName - Agent display name
+ * @param {string} options.agentPersonality - Personality description
+ * @returns {string} System prompt
+ */
+export function defaultSystemPrompt({ agentName = 'Dottie', agentPersonality = '' } = {}) {
+  const now = new Date().toISOString();
+  return `You are a helpful personal AI assistant called ${agentName}.${agentPersonality ? `\nYour personality and tone: ${agentPersonality}. Embody this in all responses.` : ''}
+You have access to tools for searching the web, reading/writing files, fetching URLs, running code, long-term memory, and scheduled tasks.
+The current date and time is ${now}.
+
+Use tools when they would help answer the user's question — don't guess when you can look things up.
+Keep responses concise and useful. When you use a tool, explain what you found.
+
+Memory guidelines:
+- When the user shares personal info (name, preferences, projects, goals), save it with memory_save.
+- When the user references past conversations or asks "do you remember", search with memory_search.
+- When the user asks to forget something, use memory_search to find the key, then memory_delete to remove it.
+- Be selective — only save things worth recalling in future conversations.
+- Don't announce every memory save unless the user would want to know.
+
+Scheduling guidelines:
+- When the user asks for a reminder, periodic check, or recurring job, use schedule_job.
+- Write the prompt as if the user is asking you to do something when the job fires.
+- For recurring jobs, suggest a reasonable interval if the user doesn't specify one.
+
+Follow-up suggestions:
+- At the end of every response, suggest one natural follow-up question the user might ask next.
+- Format: <followup>Your suggested question here</followup>
+- Keep it short, specific to the conversation context, and genuinely useful.
+- Do not include the followup tag when using tools or in error responses.`;
+}
+
 /**
  * SQLite-backed SessionStore implementation
  *

package/storage/index.js

@@ -1,19 +1,14 @@
 export { SessionStore } from './SessionStore.js';
-export { MongoSessionStore, defaultSystemPrompt } from './MongoAdapter.js';
-export { SQLiteSessionStore } from './SQLiteAdapter.js';
+export { SQLiteSessionStore, defaultSystemPrompt } from './SQLiteAdapter.js';
 export { MemorySessionStore } from './MemoryStore.js';
 export { CronStore } from './CronStore.js';
-export { MongoCronStore, parseInterval, HEARTBEAT_INTERVAL_MS, HEARTBEAT_PROMPT } from './MongoCronAdapter.js';
-export { SQLiteCronStore } from './SQLiteCronAdapter.js';
+export { SQLiteCronStore, parseInterval, HEARTBEAT_INTERVAL_MS, HEARTBEAT_PROMPT } from './SQLiteCronAdapter.js';
 export { TaskStore } from './TaskStore.js';
-export { MongoTaskStore } from './MongoTaskAdapter.js';
 export { SQLiteTaskStore } from './SQLiteTaskAdapter.js';
 // Backwards compatibility aliases
 export { TaskStore as GoalStore } from './TaskStore.js';
-export { MongoTaskStore as MongoGoalStore } from './MongoTaskAdapter.js';
 export { SQLiteTaskStore as SQLiteGoalStore } from './SQLiteTaskAdapter.js';
 export { TriggerStore } from './TriggerStore.js';
-export { MongoTriggerStore } from './MongoTriggerAdapter.js';
 export { SQLiteTriggerStore } from './SQLiteTriggerAdapter.js';
 export { SQLiteMemoryStore } from './SQLiteMemoryAdapter.js';
 export { EventStore } from './EventStore.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}`);
+  });
+});