@agentforge-ai/cli 0.4.3 → 0.5.0

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

package/dist/default/convex/skills.ts

@@ -0,0 +1,178 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: List skills
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    category: v.optional(v.string()),
+    isInstalled: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    if (args.category) {
+      const skills = await ctx.db
+        .query("skills")
+        .withIndex("byCategory", (q) => q.eq("category", args.category))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return skills.filter((s) => s.userId === args.userId);
+      }
+      if (args.isInstalled !== undefined) {
+        return skills.filter((s) => s.isInstalled === args.isInstalled);
+      }
+      return skills;
+    }
+    
+    if (args.isInstalled !== undefined) {
+      const skills = await ctx.db
+        .query("skills")
+        .withIndex("byIsInstalled", (q) => q.eq("isInstalled", args.isInstalled))
+        .take(100).collect();
+      
+      if (args.userId) {
+        return skills.filter((s) => s.userId === args.userId);
+      }
+      return skills;
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("skills")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("skills").take(100).collect();
+  },
+});
+
+// Query: Get skill by ID
+export const get = query({
+  args: { id: v.id("skills") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Query: Get installed skills
+export const listInstalled = query({
+  args: {
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const skills = await ctx.db
+      .query("skills")
+      .withIndex("byIsInstalled", (q) => q.eq("isInstalled", true))
+      .take(100).collect();
+    
+    if (args.userId) {
+      return skills.filter((s) => s.userId === args.userId);
+    }
+    
+    return skills;
+  },
+});
+
+// Mutation: Create skill
+export const create = mutation({
+  args: {
+    name: v.string(),
+    displayName: v.string(),
+    description: v.string(),
+    category: v.string(),
+    version: v.string(),
+    author: v.optional(v.string()),
+    repository: v.optional(v.string()),
+    documentation: v.optional(v.string()),
+    code: v.string(),
+    schema: v.optional(v.any()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const skillId = await ctx.db.insert("skills", {
+      ...args,
+      isInstalled: false,
+      isEnabled: false,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return skillId;
+  },
+});
+
+// Mutation: Install skill
+export const install = mutation({
+  args: { id: v.id("skills") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      isInstalled: true,
+      isEnabled: true,
+      installedAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+    return args.id;
+  },
+});
+
+// Mutation: Uninstall skill
+export const uninstall = mutation({
+  args: { id: v.id("skills") },
+  handler: async (ctx, args) => {
+    await ctx.db.patch(args.id, {
+      isInstalled: false,
+      isEnabled: false,
+      updatedAt: Date.now(),
+    });
+    return args.id;
+  },
+});
+
+// Mutation: Toggle skill enabled status
+export const toggleEnabled = mutation({
+  args: { id: v.id("skills") },
+  handler: async (ctx, args) => {
+    const skill = await ctx.db.get(args.id);
+    
+    if (!skill) {
+      throw new Error(`Skill not found`);
+    }
+    
+    await ctx.db.patch(args.id, {
+      isEnabled: !skill.isEnabled,
+      updatedAt: Date.now(),
+    });
+    
+    return { success: true, isEnabled: !skill.isEnabled };
+  },
+});
+
+// Mutation: Update skill
+export const update = mutation({
+  args: {
+    id: v.id("skills"),
+    displayName: v.optional(v.string()),
+    description: v.optional(v.string()),
+    version: v.optional(v.string()),
+    code: v.optional(v.string()),
+    schema: 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 skill
+export const remove = mutation({
+  args: { id: v.id("skills") },
+  handler: async (ctx, args) => {
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/dist/default/convex/threads.ts

@@ -0,0 +1,100 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: Get all threads
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    agentId: v.optional(v.string()),
+    projectId: v.optional(v.id("projects")),
+  },
+  handler: async (ctx, args) => {
+    if (args.projectId) {
+      return await ctx.db
+        .query("threads")
+        .withIndex("byProjectId", (q) => q.eq("projectId", args.projectId))
+        .take(100).collect();
+    }
+    
+    if (args.agentId) {
+      return await ctx.db
+        .query("threads")
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+        .take(100).collect();
+    }
+    
+    if (args.userId) {
+      return await ctx.db
+        .query("threads")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    }
+    
+    return await ctx.db.query("threads").take(100).collect();
+  },
+});
+
+// Query: Get thread by ID
+export const get = query({
+  args: { id: v.id("threads") },
+  handler: async (ctx, args) => {
+    return await ctx.db.get(args.id);
+  },
+});
+
+// Mutation: Create a new thread
+export const create = mutation({
+  args: {
+    name: v.optional(v.string()),
+    agentId: v.string(),
+    userId: v.optional(v.string()),
+    projectId: v.optional(v.id("projects")),
+    metadata: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const threadId = await ctx.db.insert("threads", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+    });
+    return threadId;
+  },
+});
+
+// Mutation: Update thread
+export const update = mutation({
+  args: {
+    id: v.id("threads"),
+    name: v.optional(v.string()),
+    metadata: 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 thread
+export const remove = mutation({
+  args: { id: v.id("threads") },
+  handler: async (ctx, args) => {
+    // Delete all messages in the thread
+    const messages = await ctx.db
+      .query("messages")
+      .withIndex("byThread", (q) => q.eq("threadId", args.id))
+      .take(100).collect();
+    
+    for (const message of messages) {
+      await ctx.db.delete(message._id);
+    }
+    
+    // Delete the thread
+    await ctx.db.delete(args.id);
+    return { success: true };
+  },
+});

package/dist/default/convex/usage.ts

@@ -0,0 +1,195 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+// Query: Get usage records
+export const list = query({
+  args: {
+    userId: v.optional(v.string()),
+    agentId: v.optional(v.string()),
+    provider: v.optional(v.string()),
+    startTime: v.optional(v.number()),
+    endTime: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let records;
+    
+    if (args.provider) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byProvider", (q) => q.eq("provider", args.provider))
+        .take(100).collect();
+    } else if (args.agentId) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+        .take(100).collect();
+    } else if (args.userId) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    } else {
+      records = await ctx.db.query("usage").take(100).collect();
+    }
+    
+    // Filter by time range if provided
+    if (args.startTime) {
+      records = records.filter((r) => r.timestamp >= args.startTime!);
+    }
+    if (args.endTime) {
+      records = records.filter((r) => r.timestamp <= args.endTime!);
+    }
+    
+    return records;
+  },
+});
+
+// Query: Get usage statistics
+export const getStats = query({
+  args: {
+    userId: v.optional(v.string()),
+    agentId: v.optional(v.string()),
+    startTime: v.optional(v.number()),
+    endTime: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    let records;
+    
+    if (args.agentId) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byAgentId", (q) => q.eq("agentId", args.agentId))
+        .take(100).collect();
+    } else if (args.userId) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    } else {
+      records = await ctx.db.query("usage").take(100).collect();
+    }
+    
+    // Filter by time range
+    if (args.startTime) {
+      records = records.filter((r) => r.timestamp >= args.startTime!);
+    }
+    if (args.endTime) {
+      records = records.filter((r) => r.timestamp <= args.endTime!);
+    }
+    
+    // Calculate statistics
+    const totalTokens = records.reduce((sum, r) => sum + r.totalTokens, 0);
+    const totalCost = records.reduce((sum, r) => sum + (r.cost || 0), 0);
+    const totalRequests = records.length;
+    
+    const byProvider: Record<string, { tokens: number; cost: number; requests: number }> = {};
+    const byModel: Record<string, { tokens: number; cost: number; requests: number }> = {};
+    
+    for (const record of records) {
+      // By provider
+      if (!byProvider[record.provider]) {
+        byProvider[record.provider] = { tokens: 0, cost: 0, requests: 0 };
+      }
+      byProvider[record.provider].tokens += record.totalTokens;
+      byProvider[record.provider].cost += record.cost || 0;
+      byProvider[record.provider].requests += 1;
+      
+      // By model
+      if (!byModel[record.model]) {
+        byModel[record.model] = { tokens: 0, cost: 0, requests: 0 };
+      }
+      byModel[record.model].tokens += record.totalTokens;
+      byModel[record.model].cost += record.cost || 0;
+      byModel[record.model].requests += 1;
+    }
+    
+    return {
+      totalTokens,
+      totalCost,
+      totalRequests,
+      byProvider,
+      byModel,
+    };
+  },
+});
+
+// Query: Get usage by time period
+export const getByTimePeriod = query({
+  args: {
+    userId: v.optional(v.string()),
+    period: v.union(v.literal("day"), v.literal("week"), v.literal("month")),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    let startTime: number;
+    
+    switch (args.period) {
+      case "day":
+        startTime = now - 24 * 60 * 60 * 1000;
+        break;
+      case "week":
+        startTime = now - 7 * 24 * 60 * 60 * 1000;
+        break;
+      case "month":
+        startTime = now - 30 * 24 * 60 * 60 * 1000;
+        break;
+    }
+    
+    let records;
+    if (args.userId) {
+      records = await ctx.db
+        .query("usage")
+        .withIndex("byUserId", (q) => q.eq("userId", args.userId))
+        .take(100).collect();
+    } else {
+      records = await ctx.db.query("usage").take(100).collect();
+    }
+    
+    records = records.filter((r) => r.timestamp >= startTime);
+    
+    return records;
+  },
+});
+
+// Mutation: Record usage
+export const record = mutation({
+  args: {
+    agentId: v.string(),
+    sessionId: v.optional(v.string()),
+    provider: v.string(),
+    model: v.string(),
+    promptTokens: v.number(),
+    completionTokens: v.number(),
+    totalTokens: v.number(),
+    cost: v.optional(v.number()),
+    userId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const usageId = await ctx.db.insert("usage", {
+      ...args,
+      timestamp: Date.now(),
+    });
+    return usageId;
+  },
+});
+
+// Mutation: Delete old usage records
+export const cleanup = mutation({
+  args: {
+    olderThan: v.number(), // Timestamp
+  },
+  handler: async (ctx, args) => {
+    const records = await ctx.db
+      .query("usage")
+      .withIndex("byTimestamp")
+      .take(100).collect();
+    
+    const toDelete = records.filter((r) => r.timestamp < args.olderThan);
+    
+    for (const record of toDelete) {
+      await ctx.db.delete(record._id);
+    }
+    
+    return { deleted: toDelete.length };
+  },
+});