@agentforge-ai/cli 0.4.2 → 0.5.0

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

package/templates/default/convex/folders.ts

@@ -0,0 +1,110 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List folders
+export const list = query({
+  args: {
+    parentId: v.optional(v.id("folders")),
+    projectId: v.optional(v.id("projects")),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.projectId) {
+      return await ctx.db
+        .query("folders")
+        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId))
+        .take(100).collect();
+    }
+    
+    if (args.parentId) {
+      return await ctx.db
+        .query("folders")
+        .withIndex("byParentId", (q) => q.eq("parentId", args.parentId))
+        .take(100).collect();
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("folders")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("folders").take(100).collect();
+  },
+});
+
+// Query: Get folder by ID
+export const get = query({
+  args: { id: v.id("folders") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Mutation: Create folder
+export const create = mutation({
+  args: {
+    name: v.string(),
+    parentId: v.optional(v.id("folders")),
+    projectId: v.optional(v.id("projects")),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const folderId = await ctx.db.insert("folders", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return folderId;
+  },
+});
+
+// Mutation: Update folder
+export const update = mutation({
+  args: {
+    id: v.id("folders"),
+    name: v.optional(v.string()),
+    parentId: v.optional(v.id("folders")),
+  },
+  handler: async (ctx, args) => {
+    const { id, ...updates } = args;
+    await ctx.db.patch(id, {
+      ...updates,
+      updatedAt: Date.now(),
+    });
+    return id;
+  },
+});
+
+// Mutation: Delete folder
+export const remove = mutation({
+  args: { id: v.id("folders") },
+  handler: async (ctx, args) => {
+    // Delete all files in the folder
+    const files = await ctx.db
+      .query("files")
+      .withIndex("byFolderId", (q) => q.eq("folderId", args.id))
+      .take(100).collect();
+    
+    for (const file of files) {
+      await ctx.db.delete(file._id);
+    }
+    
+    // Delete all subfolders recursively
+    const subfolders = await ctx.db
+      .query("folders")
+      .withIndex("byParentId", (q) => q.eq("parentId", args.id))
+      .take(100).collect();
+    
+    for (const subfolder of subfolders) {
+      // Recursive delete (will be called via mutation)
+      await ctx.db.delete(subfolder._id);
+    }
+    
+    // Delete the folder itself
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});