@agentforge-ai/cli 0.4.3 → 0.5.0

package/templates/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",
+    };
+  },
+});

package/templates/default/convex/mcpConnections.ts

@@ -0,0 +1,127 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List MCP connections
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    isEnabled: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    if (args.isEnabled !== undefined) {
+      const connections = await ctx.db
+        .query("mcpConnections")
+        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return connections.filter((c) => c.userId === args.userId);
+      }
+      return connections;
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("mcpConnections")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("mcpConnections").take(100).collect();
+  },
+});
+
+// Query: Get MCP connection by ID
+export const get = query({
+  args: { id: v.id("mcpConnections") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Mutation: Create MCP connection
+export const create = mutation({
+  args: {
+    name: v.string(),
+    serverUrl: v.string(),
+    protocol: v.string(),
+    credentials: v.optional(v.any()),
+    capabilities: v.optional(v.any()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const connectionId = await ctx.db.insert("mcpConnections", {
+      ...args,
+      isConnected: false,
+      isEnabled: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return connectionId;
+  },
+});
+
+// Mutation: Update MCP connection
+export const update = mutation({
+  args: {
+    id: v.id("mcpConnections"),
+    name: v.optional(v.string()),
+    serverUrl: v.optional(v.string()),
+    credentials: v.optional(v.any()),
+    capabilities: v.optional(v.any()),
+    isEnabled: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    await ctx.db.patch(id, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+    return id;
+  },
+});
+
+// Mutation: Update connection status
+export const updateStatus = mutation({
+  args: {
+    id: v.id("mcpConnections"),
+    isConnected: v.boolean(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      isConnected: args.isConnected,
+      lastConnectedAt: args.isConnected ? Date.now() : undefined,
+      updatedAt: Date.now(),
+    });
+    return args.id;
+  },
+});
+
+// Mutation: Toggle MCP connection enabled status
+export const toggleEnabled = mutation({
+  args: { id: v.id("mcpConnections") },
+  handler: async (ctx, args) => {
+    const connection = await ctx.db.get(args.id);
+    
+    if (!connection) {
+      throw new Error(`MCP connection not found`);
+    }
+    
+    await ctx.db.patch(args.id, {
+      isEnabled: !connection.isEnabled,
+      updatedAt: Date.now(),
+    });
+    
+    return { success: true, isEnabled: !connection.isEnabled };
+  },
+});
+
+// Mutation: Delete MCP connection
+export const remove = mutation({
+  args: { id: v.id("mcpConnections") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/templates/default/convex/messages.ts

@@ -0,0 +1,90 @@
+import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+
+// Mutation: Add a message to a thread
+export const add = mutation({
+  args: {
+    threadId: v.id("threads"),
+    role: v.union(
+      v.literal("user"),
+      v.literal("assistant"),
+      v.literal("system"),
+      v.literal("tool")
+    ),
+    content: v.string(),
+    tool_calls: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const messageId = await ctx.db.insert("messages", {
+      ...args,
+      createdAt: Date.now(),
+    });
+    
+    // Update thread's updatedAt timestamp
+    await ctx.db.patch(args.threadId, {
+      updatedAt: Date.now(),
+    });
+    
+    return messageId;
+  },
+});
+
+// Mutation: Create a message (alias for add)
+export const create = mutation({
+  args: {
+    threadId: v.id("threads"),
+    role: v.union(
+      v.literal("user"),
+      v.literal("assistant"),
+      v.literal("system"),
+      v.literal("tool")
+    ),
+    content: v.string(),
+    tool_calls: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const messageId = await ctx.db.insert("messages", {
+      ...args,
+      createdAt: Date.now(),
+    });
+    return messageId;
+  },
+});
+
+// Query: Get messages by thread
+export const list = query({
+  args: { threadId: v.id("threads") },
+  handler: async (ctx, args) => {
+    const messages = await ctx.db
+      .query("messages")
+      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
+      .take(100).collect();
+    return messages;
+  },
+});
+
+// Mutation: Delete a message
+export const remove = mutation({
+  args: { id: v.id("messages") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});
+
+// Mutation: Clear all messages in a thread
+export const clearThread = mutation({
+  args: { threadId: v.id("threads") },
+  handler: async (ctx, args) => {
+    const messages = await ctx.db
+      .query("messages")
+      .withIndex("by_thread", (q) => q.eq("threadId", args.threadId))
+      .take(100).collect();
+    
+    for (const message of messages) {
+      await ctx.db.delete(message._id);
+    }
+    
+    return { success: true, deleted: messages.length };
+  },
+});

package/templates/default/convex/projects.ts

@@ -0,0 +1,114 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List projects
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.userId) {
+      return await ctx.db
+        .query("projects")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("projects").take(100).collect();
+  },
+});
+
+// Query: Get project by ID
+export const get = query({
+  args: { id: v.id("projects") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Mutation: Create project
+export const create = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+    userId: v.optional(v.string()),
+    settings: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const projectId = await ctx.db.insert("projects", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return projectId;
+  },
+});
+
+// Mutation: Update project
+export const update = mutation({
+  args: {
+    id: v.id("projects"),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    settings: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    await ctx.db.patch(id, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+    return id;
+  },
+});
+
+// Mutation: Delete project
+export const remove = mutation({
+  args: { id: v.id("projects") },
+  handler: async (ctx, args) => {
+    // Delete all threads in the project
+    const threads = await ctx.db
+      .query("threads")
+      .withIndex("byProjectId", (q) => q.eq("projectId", args.id))
+      .take(100).collect();
+    
+    for (const thread of threads) {
+      // Delete messages in thread
+      const messages = await ctx.db
+        .query("messages")
+        .withIndex("byThread", (q) => q.eq("threadId", thread._id))
+        .take(100).collect();
+      
+      for (const message of messages) {
+        await ctx.db.delete(message._id);
+      }
+      
+      await ctx.db.delete(thread._id);
+    }
+    
+    // Delete all files in the project
+    const files = await ctx.db
+      .query("files")
+      .withIndex("byProjectId", (q) => q.eq("projectId", args.id))
+      .take(100).collect();
+    
+    for (const file of files) {
+      await ctx.db.delete(file._id);
+    }
+    
+    // Delete all folders in the project
+    const folders = await ctx.db
+      .query("folders")
+      .withIndex("byProjectId", (q) => q.eq("projectId", args.id))
+      .take(100).collect();
+    
+    for (const folder of folders) {
+      await ctx.db.delete(folder._id);
+    }
+    
+    // Delete the project itself
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/templates/default/convex/sessions.ts

@@ -0,0 +1,174 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: Get all sessions
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    agentId: v.optional(v.string()),
+    status: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.status) {
+      const sessions = await ctx.db
+        .query("sessions")
+        .withIndex("byStatus", (q) => q.eq("status", args.status as any))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return sessions.filter((s) => s.userId === args.userId);
+      }
+      if (args.agentId) {
+        return sessions.filter((s) => s.agentId === args.agentId);
+      }
+      return sessions;
+    }
+    
+    if (args.agentId) {
+      return await ctx.db
+        .query("sessions")
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+        .take(100).collect();
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("sessions")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("sessions").take(100).collect();
+  },
+});
+
+// Query: Get session by ID
+export const get = query({
+  args: { sessionId: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("sessions")
+      .withIndex("bySessionId", (q) => q.eq("sessionId", args.sessionId))
+      .first();
+  },
+});
+
+// Query: Get active sessions
+export const listActive = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const sessions = await ctx.db
+      .query("sessions")
+      .withIndex("byStatus", (q) => q.eq("status", "active"))
+      .take(100).collect();
+    
+    if (args.userId) {
+      return sessions.filter((s) => s.userId === args.userId);
+    }
+    
+    return sessions;
+  },
+});
+
+// Mutation: Create a new session
+export const create = mutation({
+  args: {
+    sessionId: v.string(),
+    threadId: v.id("threads"),
+    agentId: v.string(),
+    userId: v.optional(v.string()),
+    channel: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const sessionId = await ctx.db.insert("sessions", {
+      ...args,
+      status: "active",
+      startedAt: now,
+      lastActivityAt: now,
+    });
+    return sessionId;
+  },
+});
+
+// Mutation: Update session activity
+export const updateActivity = mutation({
+  args: {
+    sessionId: v.string(),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const session = await ctx.db
+      .query("sessions")
+      .withIndex("bySessionId", (q) => q.eq("sessionId", args.sessionId))
+      .first();
+    
+    if (!session) {
+      throw new Error(`Session ${args.sessionId} not found`);
+    }
+    
+    await ctx.db.patch(session._id, {
+      lastActivityAt: Date.now(),
+      ...(args.metadata && { metadata: args.metadata }),
+    });
+    
+    return session._id;
+  },
+});
+
+// Mutation: Update session status
+export const updateStatus = mutation({
+  args: {
+    sessionId: v.string(),
+    status: v.union(
+      v.literal("active"),
+      v.literal("paused"),
+      v.literal("completed"),
+      v.literal("error")
+    ),
+  },
+  handler: async (ctx, args) => {
+    const session = await ctx.db
+      .query("sessions")
+      .withIndex("bySessionId", (q) => q.eq("sessionId", args.sessionId))
+      .first();
+    
+    if (!session) {
+      throw new Error(`Session ${args.sessionId} not found`);
+    }
+    
+    const updates: any = {
+      status: args.status,
+      lastActivityAt: Date.now(),
+    };
+    
+    if (args.status === "completed" || args.status === "error") {
+      updates.completedAt = Date.now();
+    }
+    
+    await ctx.db.patch(session._id, updates);
+    
+    return session._id;
+  },
+});
+
+// Mutation: Delete session
+export const remove = mutation({
+  args: { sessionId: v.string() },
+  handler: async (ctx, args) => {
+    const session = await ctx.db
+      .query("sessions")
+      .withIndex("bySessionId", (q) => q.eq("sessionId", args.sessionId))
+      .first();
+    
+    if (!session) {
+      throw new Error(`Session ${args.sessionId} not found`);
+    }
+    
+    await ctx.db.delete(session._id);
+    return { success: true };
+  },
+});