@agentforge-ai/cli 0.4.3 → 0.5.0

package/dist/default/convex/agents.ts

@@ -0,0 +1,204 @@
+import { v } from "convex/values";
+import { mutation, query, action } from "./_generated/server";
+import { api } from "./_generated/api";
+
+// Query: Get all agents
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.userId) {
+      return await ctx.db
+        .query("agents")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    return await ctx.db.query("agents").take(100).collect();
+  },
+});
+
+// Query: Get agent by ID
+export const get = query({
+  args: { id: v.string() },
+  handler: async (ctx, args) => {
+    return await ctx.db
+      .query("agents")
+      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .first();
+  },
+});
+
+// Query: Get active agents
+export const listActive = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    let query = ctx.db
+      .query("agents")
+      .withIndex("byIsActive", (q) => q.eq("isActive", true));
+    
+    const agents = await query.take(100).collect();
+    
+    if (args.userId) {
+      return agents.filter((agent) => agent.userId === args.userId);
+    }
+    
+    return agents;
+  },
+});
+
+// Mutation: Create a new agent
+export const create = mutation({
+  args: {
+    id: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    instructions: v.string(),
+    model: v.string(),
+    provider: v.string(),
+    tools: v.optional(v.any()),
+    temperature: v.optional(v.number()),
+    maxTokens: v.optional(v.number()),
+    topP: v.optional(v.number()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const agentId = await ctx.db.insert("agents", {
+      ...args,
+      isActive: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return agentId;
+  },
+});
+
+// Mutation: Update an agent
+export const update = mutation({
+  args: {
+    id: v.string(),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    instructions: v.optional(v.string()),
+    model: v.optional(v.string()),
+    provider: v.optional(v.string()),
+    tools: v.optional(v.any()),
+    temperature: v.optional(v.number()),
+    maxTokens: v.optional(v.number()),
+    topP: v.optional(v.number()),
+    isActive: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    const agent = await ctx.db
+      .query("agents")
+      .withIndex("byAgentId", (q) => q.eq("id", id))
+      .first();
+
+    if (!agent) {
+      throw new Error(`Agent with id ${id} not found`);
+    }
+
+    await ctx.db.patch(agent._id, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+
+    return agent._id;
+  },
+});
+
+// Mutation: Delete an agent
+export const remove = mutation({
+  args: { id: v.string() },
+  handler: async (ctx, args) => {
+    const agent = await ctx.db
+      .query("agents")
+      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .first();
+
+    if (!agent) {
+      throw new Error(`Agent with id ${args.id} not found`);
+    }
+
+    await ctx.db.delete(agent._id);
+    return { success: true };
+  },
+});
+
+// Mutation: Toggle agent active status
+export const toggleActive = mutation({
+  args: { id: v.string() },
+  handler: async (ctx, args) => {
+    const agent = await ctx.db
+      .query("agents")
+      .withIndex("byAgentId", (q) => q.eq("id", args.id))
+      .first();
+
+    if (!agent) {
+      throw new Error(`Agent with id ${args.id} not found`);
+    }
+
+    await ctx.db.patch(agent._id, {
+      isActive: !agent.isActive,
+      updatedAt: Date.now(),
+    });
+
+    return { success: true, isActive: !agent.isActive };
+  },
+});
+
+// Action: Run agent with Mastra (to be implemented with Mastra integration)
+export const run = action({
+  args: {
+    agentId: v.string(),
+    prompt: v.string(),
+    threadId: v.optional(v.id("threads")),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    // Get agent configuration
+    const agent = await ctx.runQuery(api.agents.get, { id: args.agentId });
+    
+    if (!agent) {
+      throw new Error(`Agent with id ${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
+    await ctx.runMutation(api.messages.add, {
+      threadId,
+      role: "user",
+      content: args.prompt,
+    });
+
+    // TODO: Integrate with Mastra to run the agent
+    // This will be implemented in the Mastra integration phase
+    // For now, return a placeholder response
+    const response = {
+      threadId,
+      message: "Agent execution will be implemented with Mastra integration",
+      agentId: args.agentId,
+    };
+
+    // Add assistant message placeholder
+    await ctx.runMutation(api.messages.add, {
+      threadId,
+      role: "assistant",
+      content: response.message,
+    });
+
+    return response;
+  },
+});

package/dist/default/convex/apiKeys.ts

@@ -0,0 +1,133 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List API keys
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    provider: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.provider) {
+      const keys = await ctx.db
+        .query("apiKeys")
+        .withIndex("byProvider", (q) => q.eq("provider", args.provider))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return keys.filter((k) => k.userId === args.userId);
+      }
+      return keys;
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("apiKeys")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("apiKeys").take(100).collect();
+  },
+});
+
+// Query: Get API key by ID
+export const get = query({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Query: Get active API key for provider
+export const getActiveForProvider = query({
+  args: {
+    provider: v.string(),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const keys = await ctx.db
+      .query("apiKeys")
+      .withIndex("byProvider", (q) => q.eq("provider", args.provider))
+      .take(100).collect();
+    
+    const activeKeys = keys.filter((k) => k.isActive);
+    
+    if (args.userId) {
+      return activeKeys.find((k) => k.userId === args.userId);
+    }
+    
+    return activeKeys[0];
+  },
+});
+
+// Mutation: Create API key
+export const create = mutation({
+  args: {
+    provider: v.string(),
+    keyName: v.string(),
+    encryptedKey: v.string(),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const keyId = await ctx.db.insert("apiKeys", {
+      ...args,
+      isActive: true,
+      createdAt: Date.now(),
+    });
+    return keyId;
+  },
+});
+
+// Mutation: Update API key
+export const update = mutation({
+  args: {
+    id: v.id("apiKeys"),
+    keyName: v.optional(v.string()),
+    encryptedKey: v.optional(v.string()),
+    isActive: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    await ctx.db.patch(id, updates);
+    return id;
+  },
+});
+
+// Mutation: Toggle API key active status
+export const toggleActive = mutation({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    const key = await ctx.db.get(args.id);
+    
+    if (!key) {
+      throw new Error(`API key not found`);
+    }
+    
+    await ctx.db.patch(args.id, {
+      isActive: !key.isActive,
+    });
+    
+    return { success: true, isActive: !key.isActive };
+  },
+});
+
+// Mutation: Update last used timestamp
+export const updateLastUsed = mutation({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      lastUsedAt: Date.now(),
+    });
+    return args.id;
+  },
+});
+
+// Mutation: Delete API key
+export const remove = mutation({
+  args: { id: v.id("apiKeys") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/dist/default/convex/cronJobs.ts

@@ -0,0 +1,224 @@
+import { v } from "convex/values";
+import { mutation, query, action } from "./_generated/server";
+
+// Query: List cron jobs
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    agentId: v.optional(v.string()),
+    isEnabled: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    if (args.isEnabled !== undefined) {
+      const jobs = await ctx.db
+        .query("cronJobs")
+        .withIndex("byIsEnabled", (q) => q.eq("isEnabled", args.isEnabled))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return jobs.filter((j) => j.userId === args.userId);
+      }
+      if (args.agentId) {
+        return jobs.filter((j) => j.agentId === args.agentId);
+      }
+      return jobs;
+    }
+    
+    if (args.agentId) {
+      return await ctx.db
+        .query("cronJobs")
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+        .take(100).collect();
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("cronJobs")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("cronJobs").take(100).collect();
+  },
+});
+
+// Query: Get cron job by ID
+export const get = query({
+  args: { id: v.id("cronJobs") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Query: Get jobs due to run
+export const getDueJobs = query({
+  args: {},
+  handler: async (ctx) => {
+    const now = Date.now();
+    const jobs = await ctx.db
+      .query("cronJobs")
+      .withIndex("byNextRun")
+      .take(100).collect();
+    
+    return jobs.filter((j) => j.isEnabled && j.nextRun && j.nextRun <= now);
+  },
+});
+
+// Mutation: Create cron job
+export const create = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+    schedule: v.string(),
+    agentId: v.string(),
+    prompt: v.string(),
+    userId: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    
+    // TODO: Parse cron expression to calculate nextRun
+    // For now, set it to 1 hour from now
+    const nextRun = now + 60 * 60 * 1000;
+    
+    const jobId = await ctx.db.insert("cronJobs", {
+      ...args,
+      isEnabled: true,
+      nextRun,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return jobId;
+  },
+});
+
+// Mutation: Update cron job
+export const update = mutation({
+  args: {
+    id: v.id("cronJobs"),
+    name: v.optional(v.string()),
+    description: v.optional(v.string()),
+    schedule: v.optional(v.string()),
+    prompt: v.optional(v.string()),
+    isEnabled: v.optional(v.boolean()),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    
+    // If schedule changed, recalculate nextRun
+    if (updates.schedule) {
+      const now = Date.now();
+      (updates as any).nextRun = now + 60 * 60 * 1000; // TODO: Parse cron
+    }
+    
+    await ctx.db.patch(id, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+    return id;
+  },
+});
+
+// Mutation: Toggle cron job enabled status
+export const toggleEnabled = mutation({
+  args: { id: v.id("cronJobs") },
+  handler: async (ctx, args) => {
+    const job = await ctx.db.get(args.id);
+    
+    if (!job) {
+      throw new Error(`Cron job not found`);
+    }
+    
+    await ctx.db.patch(args.id, {
+      isEnabled: !job.isEnabled,
+      updatedAt: Date.now(),
+    });
+    
+    return { success: true, isEnabled: !job.isEnabled };
+  },
+});
+
+// Mutation: Update last run time
+export const updateLastRun = mutation({
+  args: {
+    id: v.id("cronJobs"),
+    nextRun: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      lastRun: Date.now(),
+      nextRun: args.nextRun,
+    });
+    return args.id;
+  },
+});
+
+// Mutation: Delete cron job
+export const remove = mutation({
+  args: { id: v.id("cronJobs") },
+  handler: async (ctx, args) => {
+    // Delete all run history
+    const runs = await ctx.db
+      .query("cronJobRuns")
+      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.id))
+      .take(100).collect();
+    
+    for (const run of runs) {
+      await ctx.db.delete(run._id);
+    }
+    
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});
+
+// Mutation: Record cron job run
+export const recordRun = mutation({
+  args: {
+    cronJobId: v.id("cronJobs"),
+    status: v.union(
+      v.literal("success"),
+      v.literal("failed"),
+      v.literal("running")
+    ),
+    output: v.optional(v.string()),
+    error: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const runId = await ctx.db.insert("cronJobRuns", {
+      cronJobId: args.cronJobId,
+      status: args.status,
+      startedAt: now,
+      ...(args.status !== "running" && { completedAt: now }),
+      ...(args.output && { output: args.output }),
+      ...(args.error && { error: args.error }),
+    });
+    return runId;
+  },
+});
+
+// Query: Get run history for a cron job
+export const getRunHistory = query({
+  args: {
+    cronJobId: v.id("cronJobs"),
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const runs = await ctx.db
+      .query("cronJobRuns")
+      .withIndex("byCronJobId", (q) => q.eq("cronJobId", args.cronJobId))
+      .take(100).collect();
+    
+    // Sort by startedAt descending
+    runs.sort((a, b) => b.startedAt - a.startedAt);
+    
+    if (args.limit) {
+      return runs.slice(0, args.limit);
+    }
+    
+    return runs;
+  },
+});

package/dist/default/convex/files.ts

@@ -0,0 +1,103 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List files
+export const list = query({
+  args: {
+    folderId: v.optional(v.id("folders")),
+    projectId: v.optional(v.id("projects")),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.folderId) {
+      return await ctx.db
+        .query("files")
+        .withIndex("byFolderId", (q) => q.eq("folderId", args.folderId))
+        .take(100).collect();
+    }
+    
+    if (args.projectId) {
+      return await ctx.db
+        .query("files")
+        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId))
+        .take(100).collect();
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("files")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("files").take(100).collect();
+  },
+});
+
+// Query: Get file by ID
+export const get = query({
+  args: { id: v.id("files") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Mutation: Create file metadata (file stored in Cloudflare R2)
+export const create = mutation({
+  args: {
+    name: v.string(),
+    originalName: v.string(),
+    mimeType: v.string(),
+    size: v.number(),
+    url: v.string(),
+    folderId: v.optional(v.id("folders")),
+    projectId: v.optional(v.id("projects")),
+    userId: v.optional(v.string()),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const fileId = await ctx.db.insert("files", {
+      ...args,
+      uploadedAt: Date.now(),
+    });
+    return fileId;
+  },
+});
+
+// Mutation: Update file metadata
+export const update = mutation({
+  args: {
+    id: v.id("files"),
+    name: v.optional(v.string()),
+    folderId: v.optional(v.id("folders")),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    await ctx.db.patch(id, updates);
+    return id;
+  },
+});
+
+// Mutation: Delete file
+export const remove = mutation({
+  args: { id: v.id("files") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});
+
+// Mutation: Move file to folder
+export const moveToFolder = mutation({
+  args: {
+    id: v.id("files"),
+    folderId: v.optional(v.id("folders")),
+  },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      folderId: args.folderId,
+    });
+    return args.id;
+  },
+});