@stevederico/dotbot 0.19.0 → 0.20.1

package/storage/MongoAdapter.js

@@ -1,291 +0,0 @@
-import crypto from 'crypto';
-import { SessionStore } from './SessionStore.js';
-import { toStandardFormat } from '../core/normalize.js';
-
-/**
- * Default system prompt builder for DotBot agent
- *
- * @param {Object} options - Agent identity overrides
- * @param {string} [options.agentName='Dottie'] - Display name
- * @param {string} [options.agentPersonality=''] - Personality/tone
- * @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.`;
-}
-
-/**
- * MongoDB-backed SessionStore implementation
- */
-export class MongoSessionStore extends SessionStore {
-  constructor() {
-    super();
-    this.collection = null;
-    this.prefsFetcher = null;
-    this.systemPromptBuilder = defaultSystemPrompt;
-    this.heartbeatEnsurer = null;
-  }
-
-  /**
-   * Initialize MongoDB session store
-   *
-   * @param {import('mongodb').Db} db - MongoDB database instance
-   * @param {Object} [options={}] - Initialization options
-   * @param {Function} [options.prefsFetcher] - Async function (userId) => { agentName, agentPersonality }
-   * @param {Function} [options.systemPromptBuilder] - Function ({ agentName, agentPersonality }) => string
-   * @param {Function} [options.heartbeatEnsurer] - Async function (userId) => Promise<Object|null>
-   */
-  async init(db, options = {}) {
-    this.collection = db.collection('sessions');
-    this.prefsFetcher = options.prefsFetcher || null;
-    this.systemPromptBuilder = options.systemPromptBuilder || defaultSystemPrompt;
-    this.heartbeatEnsurer = options.heartbeatEnsurer || null;
-
-    await this.collection.createIndex({ id: 1 }, { unique: true }).catch(() => {});
-    await this.collection.createIndex({ owner: 1, updatedAt: -1 }).catch(() => {});
-
-    // Migrate legacy sessions: documents without an `owner` field
-    const legacy = await this.collection.find({ owner: { $exists: false } }).toArray();
-    for (const doc of legacy) {
-      const oldId = doc.id;
-      const newId = crypto.randomUUID();
-      const firstUserMsg = doc.messages?.find((m) => m.role === 'user');
-      const title = firstUserMsg ? firstUserMsg.content.slice(0, 60) : '';
-      await this.collection.updateOne(
-        { _id: doc._id },
-        { $set: { id: newId, owner: oldId, title, updatedAt: doc.updatedAt || new Date() } }
-      );
-    }
-
-    if (legacy.length > 0) {
-      console.log(`[sessions] migrated ${legacy.length} legacy session(s)`);
-    }
-
-    // Migrate existing sessions to standard message format.
-    // Detects provider-specific messages by checking for Anthropic content arrays
-    // or OpenAI tool_calls properties, then normalizes them. Idempotent — already
-    // normalized sessions pass through unchanged.
-    const allSessions = await this.collection.find({}).toArray();
-    let migrated = 0;
-    for (const doc of allSessions) {
-      if (!Array.isArray(doc.messages) || doc.messages.length === 0) continue;
-
-      const needsNormalization = doc.messages.some(
-        (m) => (m.role === 'assistant' && Array.isArray(m.content)) ||
-               (m.role === 'assistant' && m.tool_calls) ||
-               (m.role === 'tool') ||
-               (m.role === 'user' && Array.isArray(m.content) && m.content.some(b => b.type === 'tool_result'))
-      );
-
-      if (needsNormalization) {
-        const normalized = toStandardFormat(doc.messages);
-        await this.collection.updateOne(
-          { _id: doc._id },
-          { $set: { messages: normalized } }
-        );
-        migrated++;
-      }
-    }
-
-    if (migrated > 0) {
-      console.log(`[sessions] normalized messages in ${migrated} session(s)`);
-    }
-
-    console.log('[sessions] initialized with MongoDB (multi-session)');
-  }
-
-  /**
-   * Build system prompt with current timestamp
-   *
-   * @param {string} owner - User ID
-   * @returns {Promise<string>} System prompt
-   */
-  async buildSystemPrompt(owner) {
-    const prefs = this.prefsFetcher ? await this.prefsFetcher(owner) : {};
-    return this.systemPromptBuilder(prefs);
-  }
-
-  async createSession(owner, model = 'gpt-oss:20b', provider = 'ollama') {
-    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
-
-    const session = {
-      id: crypto.randomUUID(),
-      owner,
-      title: '',
-      messages: [{ role: 'system', content: await this.buildSystemPrompt(owner) }],
-      model,
-      provider,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-    await this.collection.insertOne(session);
-    return session;
-  }
-
-  async getOrCreateDefaultSession(owner) {
-    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
-
-    let session = await this.collection.findOne({ owner }, { sort: { updatedAt: -1 } });
-    if (!session) {
-      session = await this.createSession(owner);
-    } else {
-      // Refresh system prompt timestamp
-      session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(owner) };
-    }
-    if (this.heartbeatEnsurer) {
-      this.heartbeatEnsurer(owner).catch((err) => {
-        console.error(`[session] failed to ensure heartbeat for ${owner}:`, err.message);
-      });
-    }
-    return session;
-  }
-
-  async getSession(sessionId, owner) {
-    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
-
-    const session = await this.collection.findOne({ id: sessionId, owner });
-    if (!session) return null;
-
-    // Refresh system prompt timestamp
-    session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(owner) };
-    return session;
-  }
-
-  async getSessionInternal(sessionId) {
-    if (!this.collection) throw new Error('Sessions not initialized. Call init() first.');
-
-    const session = await this.collection.findOne({ id: sessionId });
-    if (!session) return null;
-
-    session.messages[0] = { role: 'system', content: await this.buildSystemPrompt(session.owner) };
-    return session;
-  }
-
-  /**
-   * Save session with normalized messages.
-   * Converts any provider-specific message formats to standard format before persisting.
-   *
-   * @param {string} sessionId - Session UUID
-   * @param {Array} messages - Messages (provider-specific or standard format)
-   * @param {string} model - Model identifier
-   * @param {string} [provider] - Provider name
-   */
-  async saveSession(sessionId, messages, model, provider) {
-    const update = {
-      messages: toStandardFormat(messages),
-      model,
-      updatedAt: new Date(),
-    };
-
-    if (provider) {
-      update.provider = provider;
-    }
-
-    // Auto-populate title from first user message if empty
-    const session = await this.collection.findOne({ id: sessionId });
-    if (session && !session.title) {
-      const firstUserMsg = update.messages.find((m) => m.role === 'user');
-      if (firstUserMsg && typeof firstUserMsg.content === 'string') {
-        update.title = firstUserMsg.content.slice(0, 60);
-      }
-    }
-
-    await this.collection.updateOne({ id: sessionId }, { $set: update });
-  }
-
-  /**
-   * Add a message to a session, normalizing to standard format before saving.
-   *
-   * @param {string} sessionId - Session UUID
-   * @param {Object} message - Message object (any provider format)
-   * @returns {Promise<Object>} Updated session
-   */
-  async addMessage(sessionId, message) {
-    const session = await this.getSessionInternal(sessionId);
-    if (!session) throw new Error(`Session ${sessionId} not found`);
-    if (!message._ts) message._ts = Date.now();
-    // Normalize the single message by running it through toStandardFormat,
-    // then append all resulting messages (may be 0 if it was a bare tool_result)
-    const normalized = toStandardFormat([message]);
-    session.messages.push(...normalized);
-    await this.saveSession(sessionId, session.messages, session.model);
-    return session;
-  }
-
-  async setModel(sessionId, model) {
-    await this.collection.updateOne({ id: sessionId }, { $set: { model, updatedAt: new Date() } });
-  }
-
-  async setProvider(sessionId, provider) {
-    await this.collection.updateOne({ id: sessionId }, { $set: { provider, updatedAt: new Date() } });
-  }
-
-  async clearSession(sessionId) {
-    const session = await this.collection.findOne({ id: sessionId });
-    const messages = [{ role: 'system', content: await this.buildSystemPrompt(session?.owner) }];
-    await this.collection.updateOne(
-      { id: sessionId },
-      { $set: { messages, updatedAt: new Date() } }
-    );
-  }
-
-  async listSessions(owner) {
-    return await this.collection
-      .aggregate([
-        { $match: { owner } },
-        { $sort: { updatedAt: -1 } },
-        { $limit: 50 },
-        {
-          $project: {
-            id: 1,
-            title: 1,
-            model: 1,
-            provider: 1,
-            createdAt: 1,
-            updatedAt: 1,
-            messageCount: { $size: { $ifNull: ['$messages', []] } }
-          }
-        }
-      ])
-      .toArray()
-      .then((docs) =>
-        docs.map((d) => ({
-          id: d.id,
-          title: d.title || '',
-          model: d.model,
-          provider: d.provider || 'ollama',
-          createdAt: d.createdAt,
-          updatedAt: d.updatedAt,
-          messageCount: d.messageCount || 0,
-        }))
-      );
-  }
-
-  async deleteSession(sessionId, owner) {
-    return await this.collection.deleteOne({ id: sessionId, owner });
-  }
-}

package/storage/MongoCronAdapter.js

@@ -1,347 +0,0 @@
-import { CronStore } from './CronStore.js';
-import {
-  HEARTBEAT_INTERVAL_MS,
-  HEARTBEAT_CONCURRENCY,
-  HEARTBEAT_PROMPT,
-  runWithConcurrency,
-  parseInterval,
-} from './cron_constants.js';
-
-/**
- * MongoDB-backed CronStore implementation
- */
-export class MongoCronStore extends CronStore {
-  constructor() {
-    super();
-    this.collection = null;
-    this.onTaskFire = null;
-    this.pollInterval = null;
-  }
-
-  /**
-   * Initialize MongoDB cron store
-   *
-   * @param {import('mongodb').Db} db - MongoDB database instance
-   * @param {Object} options
-   * @param {Function} options.onTaskFire - Callback when a task fires: (task) => Promise<void>
-   */
-  async init(db, options = {}) {
-    this.collection = db.collection('cron_tasks');
-    this.onTaskFire = options.onTaskFire;
-
-    await this.collection.createIndex({ nextRunAt: 1 }).catch(() => {});
-    await this.collection.createIndex({ sessionId: 1 }).catch(() => {});
-    await this.collection.createIndex({ userId: 1, name: 1 }).catch(() => {});
-
-    // Deduplicate existing heartbeats before adding the unique index
-    const dupes = await this.collection.aggregate([
-      { $match: { name: 'heartbeat', enabled: true, userId: { $exists: true } } },
-      { $sort: { createdAt: -1 } },
-      { $group: { _id: '$userId', ids: { $push: '$_id' }, count: { $sum: 1 } } },
-      { $match: { count: { $gt: 1 } } },
-    ]).toArray();
-    if (dupes.length > 0) {
-      const idsToRemove = dupes.flatMap(d => d.ids.slice(1));
-      const result = await this.collection.deleteMany({ _id: { $in: idsToRemove } });
-      console.log(`[cron] cleaned up ${result.deletedCount} duplicate heartbeat(s) for ${dupes.length} user(s)`);
-    }
-
-    // One enabled heartbeat per user — enforced at DB level
-    await this.collection.createIndex(
-      { userId: 1, name: 1, enabled: 1 },
-      { unique: true, partialFilterExpression: { name: 'heartbeat', enabled: true } }
-    ).catch(() => {});
-
-    // Start polling every 30 seconds
-    this.pollInterval = setInterval(() => this.checkTasks(), 30 * 1000);
-    // Also check immediately on startup
-    await this.checkTasks();
-
-    console.log('[cron] initialized with MongoDB, polling every 30s');
-  }
-
-  stop() {
-    if (this.pollInterval) clearInterval(this.pollInterval);
-  }
-
-  /**
-   * Check for tasks that are due and fire them
-   */
-  async checkTasks() {
-    if (!this.collection || !this.onTaskFire) return;
-
-    try {
-      const now = new Date();
-
-      const dueTasks = await this.collection
-        .find({ nextRunAt: { $lte: now }, enabled: true })
-        .toArray();
-
-      if (dueTasks.length === 0) return;
-
-      const heartbeats = dueTasks.filter(t => t.name === 'heartbeat');
-      const others = dueTasks.filter(t => t.name !== 'heartbeat');
-
-      /** Process a single task: fire callback, then update schedule */
-      const processTask = async (task) => {
-        try {
-          await this.onTaskFire(task);
-          if (task.recurring && task.intervalMs) {
-            const nextRun = new Date(now.getTime() + task.intervalMs);
-            await this.collection.updateOne(
-              { _id: task._id },
-              { $set: { nextRunAt: nextRun, lastRunAt: now } }
-            );
-          } else {
-            await this.collection.updateOne(
-              { _id: task._id },
-              { $set: { enabled: false, lastRunAt: now } }
-            );
-          }
-        } catch (err) {
-          console.error(`[cron] error firing task ${task.name}:`, err.message);
-        }
-      };
-
-      // Heartbeats run in parallel with a concurrency cap
-      if (heartbeats.length > 0) {
-        console.log(`[cron] firing ${heartbeats.length} heartbeat(s) (concurrency: ${HEARTBEAT_CONCURRENCY})`);
-        await runWithConcurrency(
-          heartbeats.map(t => () => processTask(t)),
-          HEARTBEAT_CONCURRENCY
-        );
-      }
-
-      // Other tasks (user-scheduled) run sequentially
-      for (const task of others) {
-        await processTask(task);
-      }
-    } catch (err) {
-      console.error(`[cron] checkTasks query failed:`, err.message);
-    }
-  }
-
-  async createTask({ name, prompt, sessionId, userId, runAt, intervalMs, recurring, taskId }) {
-    const task = {
-      name,
-      prompt,
-      sessionId: sessionId || 'default',
-      nextRunAt: new Date(runAt),
-      intervalMs: intervalMs || null,
-      recurring: recurring || false,
-      enabled: true,
-      createdAt: new Date(),
-      lastRunAt: null,
-    };
-    if (userId) task.userId = userId;
-    if (taskId) task.taskId = taskId;
-
-    const result = await this.collection.insertOne(task);
-    return { id: result.insertedId, ...task };
-  }
-
-  async listTasks(sessionId) {
-    return await this.collection
-      .find({ sessionId: sessionId || 'default', name: { $ne: 'heartbeat' } })
-      .sort({ nextRunAt: 1 })
-      .toArray()
-      .then((docs) =>
-        docs.map((d) => ({
-          id: d._id.toString(),
-          name: d.name,
-          prompt: d.prompt,
-          nextRunAt: d.nextRunAt,
-          recurring: d.recurring,
-          intervalMs: d.intervalMs,
-          enabled: d.enabled,
-          lastRunAt: d.lastRunAt,
-        }))
-      );
-  }
-
-  async listTasksBySessionIds(sessionIds, userId = null) {
-    if (!this.collection || sessionIds.length === 0) return [];
-    const query = { sessionId: { $in: [...sessionIds, 'default'] }, name: { $ne: 'heartbeat' } };
-    if (userId) {
-      query.$or = [
-        { userId: userId },
-        { userId: { $exists: false } },
-        { userId: null }
-      ];
-    }
-    return await this.collection
-      .find(query)
-      .sort({ nextRunAt: 1 })
-      .toArray()
-      .then(docs => docs.map(d => ({
-        id: d._id.toString(),
-        name: d.name,
-        prompt: d.prompt,
-        sessionId: d.sessionId,
-        nextRunAt: d.nextRunAt,
-        recurring: d.recurring,
-        intervalMs: d.intervalMs,
-        enabled: d.enabled,
-        lastRunAt: d.lastRunAt,
-        createdAt: d.createdAt,
-      })));
-  }
-
-  async getTask(id) {
-    const { ObjectId } = await import('mongodb');
-    const task = await this.collection.findOne({ _id: new ObjectId(id) });
-    if (!task) return null;
-    return {
-      id: task._id.toString(),
-      name: task.name,
-      prompt: task.prompt,
-      sessionId: task.sessionId,
-      nextRunAt: task.nextRunAt,
-      recurring: task.recurring,
-      intervalMs: task.intervalMs,
-      enabled: task.enabled,
-      lastRunAt: task.lastRunAt,
-      createdAt: task.createdAt,
-    };
-  }
-
-  async deleteTask(id) {
-    const { ObjectId } = await import('mongodb');
-    return await this.collection.deleteOne({ _id: new ObjectId(id) });
-  }
-
-  async toggleTask(id, enabled) {
-    const { ObjectId } = await import('mongodb');
-    return await this.collection.updateOne(
-      { _id: new ObjectId(id) },
-      { $set: { enabled } }
-    );
-  }
-
-  async updateTask(id, updates) {
-    const { ObjectId } = await import('mongodb');
-    const updateFields = {};
-    if (updates.name !== undefined) updateFields.name = updates.name;
-    if (updates.prompt !== undefined) updateFields.prompt = updates.prompt;
-    if (updates.runAt !== undefined) updateFields.nextRunAt = new Date(updates.runAt);
-    if (updates.intervalMs !== undefined) updateFields.intervalMs = updates.intervalMs;
-    if (updates.recurring !== undefined) updateFields.recurring = updates.recurring;
-
-    return await this.collection.updateOne(
-      { _id: new ObjectId(id) },
-      { $set: updateFields }
-    );
-  }
-
-  async ensureHeartbeat(userId) {
-    if (!this.collection || !userId) {
-      console.log(`[cron] ensureHeartbeat skipped: collection=${!!this.collection}, userId=${userId}`);
-      return null;
-    }
-
-    const jitter = Math.floor(Math.random() * HEARTBEAT_INTERVAL_MS);
-    const now = new Date();
-
-    // Atomic upsert — eliminates race conditions
-    const result = await this.collection.updateOne(
-      { userId, name: 'heartbeat', enabled: true },
-      {
-        $setOnInsert: {
-          name: 'heartbeat',
-          prompt: HEARTBEAT_PROMPT,
-          userId,
-          sessionId: 'default',
-          nextRunAt: new Date(now.getTime() + jitter),
-          intervalMs: HEARTBEAT_INTERVAL_MS,
-          recurring: true,
-          enabled: true,
-          createdAt: now,
-          lastRunAt: null,
-        },
-      },
-      { upsert: true }
-    );
-
-    if (result.upsertedId) {
-      console.log(`[cron] created heartbeat for user ${userId}, first run in ${Math.round(jitter / 60000)}m`);
-      return { id: result.upsertedId };
-    }
-
-    // Auto-update stale prompt
-    const existing = await this.collection.findOne({ userId, name: 'heartbeat', enabled: true });
-    if (existing && existing.prompt !== HEARTBEAT_PROMPT) {
-      await this.collection.updateOne({ _id: existing._id }, { $set: { prompt: HEARTBEAT_PROMPT } });
-      console.log(`[cron] updated heartbeat prompt for user ${userId}`);
-    }
-
-    return null;
-  }
-
-  async getHeartbeatStatus(userId) {
-    if (!this.collection || !userId) return null;
-    const task = await this.collection.findOne({ userId, name: 'heartbeat' });
-    if (!task) return null;
-    return {
-      id: task._id.toString(),
-      enabled: task.enabled,
-      nextRunAt: task.nextRunAt,
-      lastRunAt: task.lastRunAt,
-      createdAt: task.createdAt,
-      intervalMs: task.intervalMs,
-      prompt: task.prompt,
-    };
-  }
-
-  async resetHeartbeat(userId) {
-    if (!this.collection || !userId) return null;
-
-    // Delete existing heartbeat(s)
-    await this.collection.deleteMany({ userId, name: 'heartbeat' });
-    console.log(`[cron] deleted existing heartbeat(s) for user ${userId}`);
-
-    // Create fresh heartbeat
-    const jitter = Math.floor(Math.random() * HEARTBEAT_INTERVAL_MS);
-    const now = new Date();
-    const task = {
-      name: 'heartbeat',
-      prompt: HEARTBEAT_PROMPT,
-      userId,
-      sessionId: 'default',
-      nextRunAt: new Date(now.getTime() + jitter),
-      intervalMs: HEARTBEAT_INTERVAL_MS,
-      recurring: true,
-      enabled: true,
-      createdAt: now,
-      lastRunAt: null,
-    };
-    const result = await this.collection.insertOne(task);
-    console.log(`[cron] created new heartbeat for user ${userId}, first run in ${Math.round(jitter / 60000)}m`);
-    return { id: result.insertedId, ...task };
-  }
-
-  async triggerHeartbeatNow(userId) {
-    if (!this.collection || !userId || !this.onTaskFire) return false;
-
-    const heartbeat = await this.collection.findOne({ userId, name: 'heartbeat', enabled: true });
-    if (!heartbeat) {
-      console.log(`[cron] manual trigger failed: no enabled heartbeat for user ${userId}`);
-      return false;
-    }
-
-    console.log(`[cron] manually triggering heartbeat for user ${userId}`);
-    try {
-      await this.onTaskFire(heartbeat);
-      await this.collection.updateOne(
-        { _id: heartbeat._id },
-        { $set: { lastRunAt: new Date() } }
-      );
-      return true;
-    } catch (err) {
-      console.error(`[cron] manual trigger error:`, err.message);
-      return false;
-    }
-  }
-}
-
-// Re-export utility functions for tool definitions (from cron_constants.js)
-export { parseInterval, HEARTBEAT_INTERVAL_MS, HEARTBEAT_PROMPT } from './cron_constants.js';