@stevederico/dotbot 0.19.0 → 0.20.1

package/storage/MongoTaskAdapter.js

@@ -1,242 +0,0 @@
-import { TaskStore } from './TaskStore.js';
-
-// Lazy-load mongodb to avoid hard dependency at module evaluation time
-let _ObjectId = null;
-async function getObjectId() {
-  if (!_ObjectId) { _ObjectId = (await import('mongodb')).ObjectId; }
-  return _ObjectId;
-}
-
-/**
- * MongoDB implementation of TaskStore
- */
-export class MongoTaskStore extends TaskStore {
-  constructor() {
-    super();
-    this.collection = null;
-  }
-
-  /**
-   * Initialize MongoDB task store
-   *
-   * @param {import('mongodb').Db} db - MongoDB database instance
-   * @param {Object} options - Optional configuration
-   */
-  async init(db, options = {}) {
-    this.collection = db.collection('tasks');
-
-    // Create indexes
-    await this.collection.createIndex({ userId: 1, status: 1 }).catch(() => {});
-    await this.collection.createIndex({ userId: 1, category: 1 }).catch(() => {});
-    await this.collection.createIndex({ userId: 1, priority: 1 }).catch(() => {});
-    await this.collection.createIndex({ userId: 1, deadline: 1 }).catch(() => {});
-
-    console.log('[tasks] MongoTaskStore initialized');
-  }
-
-  /**
-   * Create a new task
-   */
-  async createTask({ userId, description, steps = [], category = 'general', priority = 'medium', deadline = null, mode = 'auto' }) {
-    // Normalize steps to objects
-    const normalizedSteps = steps.map(step => {
-      if (typeof step === 'string') {
-        return {
-          text: step,
-          action: step,  // Default action is same as text
-          done: false,
-          result: null,
-          startedAt: null,
-          completedAt: null,
-        };
-      }
-      return {
-        text: step.text || step.description || '',
-        action: step.action || step.text || '',
-        done: step.done || false,
-        result: step.result || null,
-        startedAt: step.startedAt || null,
-        completedAt: step.completedAt || null,
-      };
-    });
-
-    const doc = {
-      userId,
-      description,
-      steps: normalizedSteps,
-      category,
-      priority,
-      deadline,
-      mode,  // 'auto' or 'manual'
-      status: 'pending',  // pending, in_progress, completed
-      currentStep: 0,
-      progress: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-      lastWorkedAt: null,
-    };
-
-    const result = await this.collection.insertOne(doc);
-    return { ...doc, _id: result.insertedId };
-  }
-
-  /**
-   * Get tasks for a user
-   */
-  async getTasks(userId, filters = {}) {
-    const query = { userId };
-
-    if (filters.status) query.status = filters.status;
-    if (filters.category) query.category = filters.category;
-    if (filters.priority) query.priority = filters.priority;
-
-    const tasks = await this.collection
-      .find(query)
-      .sort({ createdAt: -1 })
-      .toArray();
-
-    // Calculate progress for each task
-    return tasks.map(task => ({
-      ...task,
-      progress: this._calculateProgress(task),
-    }));
-  }
-
-  /**
-   * Get a single task by ID
-   */
-  async getTask(userId, taskId) {
-    const ObjectId = await getObjectId();
-    const task = await this.collection.findOne({
-      _id: new ObjectId(taskId),
-      userId,
-    });
-
-    if (!task) return null;
-
-    return {
-      ...task,
-      progress: this._calculateProgress(task),
-    };
-  }
-
-  /**
-   * Update a task
-   */
-  async updateTask(userId, taskId, updates) {
-    const ObjectId = await getObjectId();
-    const validUpdates = {};
-    const allowedFields = [
-      'description', 'steps', 'category', 'priority', 'deadline',
-      'mode', 'status', 'currentStep', 'lastWorkedAt'
-    ];
-
-    for (const field of allowedFields) {
-      if (updates[field] !== undefined) {
-        validUpdates[field] = updates[field];
-      }
-    }
-
-    // Recalculate progress if steps changed
-    if (updates.steps) {
-      validUpdates.progress = this._calculateProgressFromSteps(updates.steps);
-    }
-
-    validUpdates.updatedAt = new Date();
-
-    const result = await this.collection.updateOne(
-      { _id: new ObjectId(taskId), userId },
-      { $set: validUpdates }
-    );
-
-    return result;
-  }
-
-  /**
-   * Delete a task
-   */
-  async deleteTask(userId, taskId) {
-    const ObjectId = await getObjectId();
-    const result = await this.collection.deleteOne({
-      _id: new ObjectId(taskId),
-      userId,
-    });
-    return result;
-  }
-
-  /**
-   * Search tasks by text
-   */
-  async searchTasks(userId, query) {
-    const regex = new RegExp(query, 'i');
-    const tasks = await this.collection
-      .find({
-        userId,
-        $or: [
-          { description: regex },
-          { 'steps.text': regex },
-        ],
-      })
-      .sort({ createdAt: -1 })
-      .toArray();
-
-    return tasks.map(task => ({
-      ...task,
-      progress: this._calculateProgress(task),
-    }));
-  }
-
-  /**
-   * Get task statistics
-   */
-  async getTaskStats(userId) {
-    const tasks = await this.collection.find({ userId }).toArray();
-
-    const stats = {
-      total: tasks.length,
-      pending: tasks.filter(g => g.status === 'pending').length,
-      in_progress: tasks.filter(g => g.status === 'in_progress').length,
-      completed: tasks.filter(g => g.status === 'completed').length,
-      by_category: {},
-      by_priority: {},
-      overdue: 0,
-    };
-
-    const now = new Date();
-
-    for (const task of tasks) {
-      // Count by category
-      const cat = task.category || 'general';
-      stats.by_category[cat] = (stats.by_category[cat] || 0) + 1;
-
-      // Count by priority
-      const pri = task.priority || 'medium';
-      stats.by_priority[pri] = (stats.by_priority[pri] || 0) + 1;
-
-      // Count overdue
-      if (task.deadline && new Date(task.deadline) < now && task.status !== 'completed') {
-        stats.overdue++;
-      }
-    }
-
-    return stats;
-  }
-
-  /**
-   * Calculate progress percentage from task
-   * @private
-   */
-  _calculateProgress(task) {
-    return this._calculateProgressFromSteps(task.steps || []);
-  }
-
-  /**
-   * Calculate progress percentage from steps array
-   * @private
-   */
-  _calculateProgressFromSteps(steps) {
-    if (!steps || steps.length === 0) return 0;
-    const doneCount = steps.filter(s => s.done).length;
-    return Math.round((doneCount / steps.length) * 100);
-  }
-}

package/storage/MongoTriggerAdapter.js

@@ -1,158 +0,0 @@
-import { TriggerStore } from './TriggerStore.js';
-
-// Lazy-load mongodb to avoid hard dependency at module evaluation time
-let _ObjectId = null;
-async function getObjectId() {
-  if (!_ObjectId) { _ObjectId = (await import('mongodb')).ObjectId; }
-  return _ObjectId;
-}
-
-/**
- * MongoDB implementation of TriggerStore
- */
-export class MongoTriggerStore extends TriggerStore {
-  constructor() {
-    super();
-    this.collection = null;
-  }
-
-  /**
-   * Initialize MongoDB trigger store
-   *
-   * @param {import('mongodb').Db} db - MongoDB database instance
-   * @param {Object} options - Optional configuration
-   */
-  async init(db, options = {}) {
-    this.collection = db.collection('triggers');
-
-    // Create indexes
-    await this.collection.createIndex({ userId: 1, eventType: 1 }).catch(() => {});
-    await this.collection.createIndex({ userId: 1, enabled: 1 }).catch(() => {});
-
-    console.log('[triggers] MongoTriggerStore initialized');
-  }
-
-  /**
-   * Create an event trigger
-   */
-  async createTrigger({ userId, eventType, prompt, cooldownMs = 0, metadata = {}, enabled = true }) {
-    const doc = {
-      userId,
-      eventType,
-      prompt,
-      cooldownMs,
-      metadata,
-      enabled,
-      lastFiredAt: null,
-      fireCount: 0,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    const result = await this.collection.insertOne(doc);
-    return { ...doc, _id: result.insertedId };
-  }
-
-  /**
-   * List triggers for a user
-   */
-  async listTriggers(userId, filters = {}) {
-    const query = { userId };
-
-    if (filters.enabled !== undefined) {
-      query.enabled = filters.enabled;
-    }
-    if (filters.eventType) {
-      query.eventType = filters.eventType;
-    }
-
-    return await this.collection
-      .find(query)
-      .sort({ createdAt: -1 })
-      .toArray();
-  }
-
-  /**
-   * Find enabled triggers matching userId and eventType, filtering out
-   * those still within cooldown period
-   */
-  async findMatchingTriggers(userId, eventType, metadata = {}) {
-    const now = Date.now();
-
-    // Find all enabled triggers for this user and event type
-    const triggers = await this.collection
-      .find({ userId, eventType, enabled: true })
-      .toArray();
-
-    // Filter by cooldown
-    const activeTriggers = triggers.filter(trigger => {
-      // No cooldown → always active
-      if (!trigger.cooldownMs) return true;
-
-      // Never fired → active
-      if (!trigger.lastFiredAt) return true;
-
-      // Check if cooldown period has passed
-      const lastFiredTime = new Date(trigger.lastFiredAt).getTime();
-      return (lastFiredTime + trigger.cooldownMs) <= now;
-    });
-
-    // Filter by metadata if trigger has metadata requirements
-    const matchedTriggers = activeTriggers.filter(trigger => {
-      if (!trigger.metadata || Object.keys(trigger.metadata).length === 0) {
-        return true;  // No metadata requirements
-      }
-
-      // Check if event metadata matches trigger metadata
-      for (const [key, value] of Object.entries(trigger.metadata)) {
-        if (metadata[key] !== value) return false;
-      }
-      return true;
-    });
-
-    return matchedTriggers;
-  }
-
-  /**
-   * Toggle a trigger on/off
-   */
-  async toggleTrigger(userId, triggerId, enabled) {
-    const ObjectId = await getObjectId();
-    const result = await this.collection.updateOne(
-      { _id: new ObjectId(triggerId), userId },
-      {
-        $set: {
-          enabled,
-          updatedAt: new Date()
-        }
-      }
-    );
-    return result;
-  }
-
-  /**
-   * Delete a trigger
-   */
-  async deleteTrigger(userId, triggerId) {
-    const ObjectId = await getObjectId();
-    const result = await this.collection.deleteOne({
-      _id: new ObjectId(triggerId),
-      userId,
-    });
-    return result;
-  }
-
-  /**
-   * Record that a trigger has fired
-   */
-  async markTriggerFired(triggerId) {
-    const ObjectId = await getObjectId();
-    await this.collection.updateOne(
-      { _id: new ObjectId(triggerId) },
-      {
-        $set: { lastFiredAt: new Date() },
-        $inc: { fireCount: 1 }
-      }
-    );
-  }
-}