@agentforge-ai/cli 0.4.2 → 0.5.0

package/dist/default/convex/heartbeat.ts

@@ -0,0 +1,371 @@
+import { v } from "convex/values";
+import { mutation, query, action } from "./_generated/server";
+import { api } from "./_generated/api";
+
+/**
+ * HEARTBEAT System
+ * 
+ * Similar to OpenClaw's HEARTBEAT.md, this system allows agents to:
+ * 1. Check on ongoing conversations
+ * 2. Continue unfinished tasks
+ * 3. Perform scheduled tasks
+ * 4. Maintain context across sessions
+ * 
+ * The heartbeat table stores the current state of each agent's awareness
+ * of ongoing tasks, pending actions, and conversation context.
+ */
+
+// Add heartbeat table to schema (this will need to be added to schema.ts)
+// heartbeats: defineTable({
+//   agentId: v.string(),
+//   threadId: v.optional(v.id("threads")),
+//   status: v.string(), // "active", "waiting", "completed", "error"
+//   currentTask: v.optional(v.string()),
+//   pendingTasks: v.array(v.string()),
+//   context: v.string(), // Markdown-formatted context
+//   lastCheck: v.number(),
+//   nextCheck: v.number(),
+//   metadata: v.optional(v.any()),
+// })
+
+// Query: Get heartbeat for an agent
+export const get = query({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+  },
+  handler: async (ctx, args) => {
+    const heartbeats = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .take(100).collect();
+    
+    if (args.threadId) {
+      return heartbeats.find((h) => h.threadId === args.threadId);
+    }
+    
+    return heartbeats[0]; // Return the most recent one
+  },
+});
+
+// Query: Get all active heartbeats
+export const listActive = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const heartbeats = await ctx.db
+      .query("heartbeats")
+      .withIndex("byStatus", (q) => q.eq("status", "active"))
+      .take(100).collect();
+    
+    if (args.userId) {
+      // Filter by userId if provided
+      const userAgents = await ctx.db
+        .query("agents")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+      
+      const userAgentIds = new Set(userAgents.map((a) => a.id));
+      return heartbeats.filter((h) => userAgentIds.has(h.agentId));
+    }
+    
+    return heartbeats;
+  },
+});
+
+// Query: Get heartbeats due for check
+export const getDueForCheck = query({
+  args: {},
+  handler: async (ctx) => {
+    const now = Date.now();
+    const heartbeats = await ctx.db
+      .query("heartbeats")
+      .withIndex("byNextCheck")
+      .take(100).collect();
+    
+    return heartbeats.filter((h) => h.nextCheck <= now && h.status === "active");
+  },
+});
+
+// Mutation: Create or update heartbeat
+export const upsert = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+    status: v.string(),
+    currentTask: v.optional(v.string()),
+    pendingTasks: v.array(v.string()),
+    context: v.string(),
+    checkIntervalMs: v.optional(v.number()), // How often to check (default: 5 minutes)
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { checkIntervalMs = 5 * 60 * 1000, ...data } = args;
+    const now = Date.now();
+    
+    // Check if heartbeat exists
+    const existing = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (existing) {
+      // Update existing heartbeat
+      await ctx.db.patch(existing._id, {
+        ...data,
+        lastCheck: now,
+        nextCheck: now + checkIntervalMs,
+      });
+      return existing._id;
+    } else {
+      // Create new heartbeat
+      const heartbeatId = await ctx.db.insert("heartbeats", {
+        ...data,
+        lastCheck: now,
+        nextCheck: now + checkIntervalMs,
+      });
+      return heartbeatId;
+    }
+  },
+});
+
+// Mutation: Update heartbeat status
+export const updateStatus = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+    status: v.string(),
+    currentTask: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const heartbeat = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (!heartbeat) {
+      throw new Error(`Heartbeat not found for agent ${args.agentId}`);
+    }
+    
+    await ctx.db.patch(heartbeat._id, {
+      status: args.status,
+      currentTask: args.currentTask,
+      lastCheck: Date.now(),
+    });
+    
+    return heartbeat._id;
+  },
+});
+
+// Mutation: Add pending task
+export const addPendingTask = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+    task: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const heartbeat = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (!heartbeat) {
+      throw new Error(`Heartbeat not found for agent ${args.agentId}`);
+    }
+    
+    const updatedTasks = [...heartbeat.pendingTasks, args.task];
+    
+    await ctx.db.patch(heartbeat._id, {
+      pendingTasks: updatedTasks,
+    });
+    
+    return heartbeat._id;
+  },
+});
+
+// Mutation: Remove pending task
+export const removePendingTask = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+    task: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const heartbeat = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (!heartbeat) {
+      throw new Error(`Heartbeat not found for agent ${args.agentId}`);
+    }
+    
+    const updatedTasks = heartbeat.pendingTasks.filter((t) => t !== args.task);
+    
+    await ctx.db.patch(heartbeat._id, {
+      pendingTasks: updatedTasks,
+    });
+    
+    return heartbeat._id;
+  },
+});
+
+// Mutation: Update context
+export const updateContext = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+    context: v.string(),
+  },
+  handler: async (ctx, args) => {
+    const heartbeat = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (!heartbeat) {
+      throw new Error(`Heartbeat not found for agent ${args.agentId}`);
+    }
+    
+    await ctx.db.patch(heartbeat._id, {
+      context: args.context,
+      lastCheck: Date.now(),
+    });
+    
+    return heartbeat._id;
+  },
+});
+
+// Action: Generate heartbeat context from thread
+export const generateContext = action({
+  args: {
+    agentId: v.string(),
+    threadId: v.id("threads"),
+  },
+  handler: async (ctx, args) => {
+    // Get thread and messages
+    const thread = await ctx.runQuery(api.threads.get, { id: args.threadId });
+    const messages = await ctx.runQuery(api.messages.list, {
+      threadId: args.threadId,
+    });
+    
+    if (!thread) {
+      throw new Error(`Thread ${args.threadId} not found`);
+    }
+    
+    // Generate markdown context
+    let context = `# Heartbeat Context\n\n`;
+    context += `**Agent ID:** ${args.agentId}\n`;
+    context += `**Thread:** ${thread.name || "Unnamed"}\n`;
+    context += `**Last Updated:** ${new Date().toISOString()}\n\n`;
+    
+    context += `## Recent Conversation\n\n`;
+    
+    // Include last 10 messages
+    const recentMessages = messages.slice(-10);
+    for (const msg of recentMessages) {
+      const timestamp = new Date(msg.createdAt).toLocaleString();
+      context += `### ${msg.role.toUpperCase()} (${timestamp})\n`;
+      context += `${msg.content}\n\n`;
+    }
+    
+    context += `## Status\n\n`;
+    context += `- Total messages: ${messages.length}\n`;
+    context += `- Last activity: ${new Date(thread.updatedAt).toLocaleString()}\n`;
+    
+    return context;
+  },
+});
+
+// Action: Process heartbeat check
+export const processCheck = action({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+  },
+  handler: async (ctx, args) => {
+    // Get heartbeat
+    const heartbeat = await ctx.runQuery(api.heartbeat.get, {
+      agentId: args.agentId,
+      threadId: args.threadId,
+    });
+    
+    if (!heartbeat) {
+      return { success: false, message: "Heartbeat not found" };
+    }
+    
+    // Check if there are pending tasks
+    if (heartbeat.pendingTasks.length > 0) {
+      // TODO: Integrate with Mastra to execute pending tasks
+      // For now, just log
+      console.log(`Agent ${args.agentId} has ${heartbeat.pendingTasks.length} pending tasks`);
+    }
+    
+    // Update last check time
+    await ctx.runMutation(api.heartbeat.updateStatus, {
+      agentId: args.agentId,
+      threadId: args.threadId,
+      status: heartbeat.status,
+      currentTask: heartbeat.currentTask,
+    });
+    
+    return {
+      success: true,
+      pendingTasks: heartbeat.pendingTasks.length,
+      status: heartbeat.status,
+    };
+  },
+});
+
+// Mutation: Delete heartbeat
+export const remove = mutation({
+  args: {
+    agentId: v.string(),
+    threadId: v.optional(v.id("threads")),
+  },
+  handler: async (ctx, args) => {
+    const heartbeat = await ctx.db
+      .query("heartbeats")
+      .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+      .filter((q) =>
+        args.threadId
+          ? q.eq(q.field("threadId"), args.threadId)
+          : q.eq(q.field("threadId"), undefined)
+      )
+      .first();
+    
+    if (!heartbeat) {
+      throw new Error(`Heartbeat not found for agent ${args.agentId}`);
+    }
+    
+    await ctx.db.delete(heartbeat._id);
+    return { success: true };
+  },
+});

package/dist/default/convex/logs.ts

@@ -0,0 +1,66 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List recent logs
+export const list = query({
+  args: {
+    level: v.optional(v.string()),
+    source: v.optional(v.string()),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let q = ctx.db.query("logs").withIndex("byTimestamp").order("desc");
+
+    const results = await q.collect();
+
+    let filtered = results;
+    if (args.level) {
+      filtered = filtered.filter((l) => l.level === args.level);
+    }
+    if (args.source) {
+      filtered = filtered.filter((l) => l.source === args.source);
+    }
+
+    return filtered.slice(0, args.limit || 100);
+  },
+});
+
+// Mutation: Add a log entry
+export const add = mutation({
+  args: {
+    level: v.union(
+      v.literal("debug"),
+      v.literal("info"),
+      v.literal("warn"),
+      v.literal("error")
+    ),
+    source: v.string(),
+    message: v.string(),
+    metadata: v.optional(v.any()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    return await ctx.db.insert("logs", {
+      ...args,
+      timestamp: Date.now(),
+    });
+  },
+});
+
+// Mutation: Clear logs older than a given timestamp
+export const clearOld = mutation({
+  args: { olderThan: v.number() },
+  handler: async (ctx, args) => {
+    const old = await ctx.db
+      .query("logs")
+      .withIndex("byTimestamp")
+      .filter((q) => q.lt(q.field("timestamp"), args.olderThan))
+      .collect();
+
+    for (const log of old) {
+      await ctx.db.delete(log._id);
+    }
+
+    return old.length;
+  },
+});

package/dist/default/convex/mastraIntegration.ts

@@ -0,0 +1,184 @@
+import { action } from "./_generated/server";
+import { v } from "convex/values";
+import { api } from "./_generated/api";
+
+/**
+ * Mastra Integration Actions for Convex
+ * 
+ * These actions run in the Node.js runtime and can use Mastra
+ * to execute agents and manage workflows.
+ */
+
+// Action: Execute agent with Mastra
+export const executeAgent = action({
+  args: {
+    agentId: v.string(),
+    prompt: v.string(),
+    threadId: v.optional(v.id("threads")),
+    userId: v.optional(v.string()),
+    stream: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    // Get agent configuration from database
+    const agent = await ctx.runQuery(api.agents.get, { id: args.agentId });
+    
+    if (!agent) {
+      throw new Error(`Agent ${args.agentId} not found`);
+    }
+
+    // Create or get thread
+    let threadId = args.threadId;
+    if (!threadId) {
+      threadId = await ctx.runMutation(api.threads.create, {
+        agentId: args.agentId,
+        userId: args.userId,
+      });
+    }
+
+    // Add user message to thread
+    await ctx.runMutation(api.messages.add, {
+      threadId,
+      role: "user",
+      content: args.prompt,
+    });
+
+    // Create session
+    const sessionId = `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    await ctx.runMutation(api.sessions.create, {
+      sessionId,
+      threadId,
+      agentId: args.agentId,
+      userId: args.userId,
+      channel: "dashboard",
+    });
+
+    try {
+      // Import Mastra dynamically (Node.js runtime)
+      const { Agent } = await import("@mastra/core/agent");
+      
+      // Format model string for Mastra
+      const modelString = agent.model.includes("/")
+        ? agent.model
+        : `${agent.provider}/${agent.model}`;
+
+      // Create Mastra agent
+      const mastraAgent = new Agent({
+        id: agent.id,
+        name: agent.name,
+        instructions: agent.instructions,
+        model: modelString,
+        tools: agent.tools || {},
+        ...(agent.temperature && { temperature: agent.temperature }),
+        ...(agent.maxTokens && { maxTokens: agent.maxTokens }),
+        ...(agent.topP && { topP: agent.topP }),
+      });
+
+      // Get conversation history for context
+      const messages = await ctx.runQuery(api.messages.list, { threadId });
+      
+      // Build context from message history
+      const context = messages
+        .slice(-10) // Last 10 messages for context
+        .map((m) => `${m.role}: ${m.content}`)
+        .join("\n");
+
+      // Execute agent
+      const result = await mastraAgent.generate(args.prompt, {
+        ...(args.stream && { stream: args.stream }),
+        context: context || undefined,
+      });
+
+      // Extract response content
+      const responseContent = typeof result === "string" 
+        ? result 
+        : result.text || result.content || JSON.stringify(result);
+
+      // Add assistant message to thread
+      await ctx.runMutation(api.messages.add, {
+        threadId,
+        role: "assistant",
+        content: responseContent,
+      });
+
+      // Update session status
+      await ctx.runMutation(api.sessions.updateStatus, {
+        sessionId,
+        status: "completed",
+      });
+
+      // Record usage (if available in result)
+      if (result.usage) {
+        await ctx.runMutation(api.usage.record, {
+          agentId: args.agentId,
+          sessionId,
+          provider: agent.provider,
+          model: agent.model,
+          promptTokens: result.usage.promptTokens || 0,
+          completionTokens: result.usage.completionTokens || 0,
+          totalTokens: result.usage.totalTokens || 0,
+          cost: result.usage.cost,
+          userId: args.userId,
+        });
+      }
+
+      return {
+        success: true,
+        threadId,
+        sessionId,
+        response: responseContent,
+        usage: result.usage,
+      };
+    } catch (error: any) {
+      // Update session status to error
+      await ctx.runMutation(api.sessions.updateStatus, {
+        sessionId,
+        status: "error",
+      });
+
+      // Add error message
+      await ctx.runMutation(api.messages.add, {
+        threadId,
+        role: "assistant",
+        content: `Error: ${error.message}`,
+      });
+
+      throw error;
+    }
+  },
+});
+
+// Action: Stream agent response
+export const streamAgent = action({
+  args: {
+    agentId: v.string(),
+    prompt: v.string(),
+    threadId: v.id("threads"),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Similar to executeAgent but with streaming support
+    // This would require WebSocket or SSE implementation
+    // For now, return a placeholder
+    return {
+      success: true,
+      message: "Streaming support coming soon",
+    };
+  },
+});
+
+// Action: Execute workflow with multiple agents
+export const executeWorkflow = action({
+  args: {
+    workflowId: v.string(),
+    input: v.any(),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Placeholder for workflow execution
+    // This would orchestrate multiple agents in sequence or parallel
+    return {
+      success: true,
+      message: "Workflow execution coming soon",
+    };
+  },
+});