@agentforge-ai/cli 0.4.2 → 0.5.0

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

package/dist/default/convex/settings.ts

@@ -0,0 +1,79 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: Get a setting by key
+export const get = query({
+  args: { userId: v.string(), key: v.string() },
+  handler: async (ctx, args) => {
+    const setting = await ctx.db
+      .query("settings")
+      .withIndex("byUserIdAndKey", (q) =>
+        q.eq("userId", args.userId).eq("key", args.key)
+      )
+      .first();
+    return setting;
+  },
+});
+
+// Query: List all settings for a user
+export const list = query({
+  args: { userId: v.optional(v.string()) },
+  handler: async (ctx, args) => {
+    if (args.userId) {
+      return await ctx.db
+        .query("settings")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId!))
+        .collect();
+    }
+    return await ctx.db.query("settings").collect();
+  },
+});
+
+// Mutation: Set a setting (upsert)
+export const set = mutation({
+  args: {
+    userId: v.string(),
+    key: v.string(),
+    value: v.any(),
+  },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("settings")
+      .withIndex("byUserIdAndKey", (q) =>
+        q.eq("userId", args.userId).eq("key", args.key)
+      )
+      .first();
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        value: args.value,
+        updatedAt: Date.now(),
+      });
+      return existing._id;
+    }
+
+    return await ctx.db.insert("settings", {
+      userId: args.userId,
+      key: args.key,
+      value: args.value,
+      updatedAt: Date.now(),
+    });
+  },
+});
+
+// Mutation: Delete a setting
+export const remove = mutation({
+  args: { userId: v.string(), key: v.string() },
+  handler: async (ctx, args) => {
+    const existing = await ctx.db
+      .query("settings")
+      .withIndex("byUserIdAndKey", (q) =>
+        q.eq("userId", args.userId).eq("key", args.key)
+      )
+      .first();
+
+    if (existing) {
+      await ctx.db.delete(existing._id);
+    }
+  },
+});