@webgrow/skillhub 0.1.0

package/convex/runs.ts

@@ -0,0 +1,183 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+const activeStatuses = ["running", "waiting", "paused"] as const;
+
+async function nextRunEventSequence(ctx: any, runId: any) {
+  const latest = await ctx.db
+    .query("runEvents")
+    .withIndex("by_run_sequence", (q: any) => q.eq("runId", runId))
+    .order("desc")
+    .first();
+
+  return (latest?.sequence ?? 0) + 1;
+}
+
+export const createRun = mutation({
+  args: {
+    loopSlug: v.string(),
+    loopVersionId: v.optional(v.id("loopVersions")),
+    prompt: v.optional(v.string()),
+    graph: v.optional(v.any()),
+    controls: v.optional(v.any()),
+    context: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const runId = await ctx.db.insert("loopRuns", {
+      loopSlug: args.loopSlug,
+      loopVersionId: args.loopVersionId,
+      status: "running",
+      activeNodeId: args.graph?.entryNodeId,
+      prompt: args.prompt,
+      graph: args.graph,
+      controls: args.controls,
+      context: args.context,
+      transitionCount: 0,
+      startedAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("runEvents", {
+      runId,
+      sequence: 1,
+      eventType: "run.created",
+      level: "info",
+      message: `Run created for ${args.loopSlug}`,
+      payload: {
+        loopSlug: args.loopSlug,
+        prompt: args.prompt,
+      },
+      createdAt: now,
+    });
+
+    return runId;
+  },
+});
+
+export const getRun = query({
+  args: {
+    runId: v.id("loopRuns"),
+    eventLimit: v.optional(v.number()),
+    logLimit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.db.get(args.runId);
+    if (!run) {
+      return null;
+    }
+
+    const eventLimit = Math.min(args.eventLimit ?? 100, 500);
+    const logLimit = Math.min(args.logLimit ?? 100, 500);
+
+    const [events, hostActions, logs, artifacts] = await Promise.all([
+      ctx.db
+        .query("runEvents")
+        .withIndex("by_run_sequence", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(eventLimit),
+      ctx.db
+        .query("hostActions")
+        .withIndex("by_run_createdAt", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(100),
+      ctx.db
+        .query("bridgeLogs")
+        .withIndex("by_run_createdAt", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(logLimit),
+      ctx.db
+        .query("artifacts")
+        .withIndex("by_run_createdAt", (q) => q.eq("runId", args.runId))
+        .order("desc")
+        .take(100),
+    ]);
+
+    return {
+      run,
+      events: events.reverse(),
+      hostActions: hostActions.reverse(),
+      logs: logs.reverse(),
+      artifacts: artifacts.reverse(),
+    };
+  },
+});
+
+export const listActive = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 50, 200);
+    const batches = await Promise.all(
+      activeStatuses.map((status) =>
+        ctx.db
+          .query("loopRuns")
+          .withIndex("by_status_updatedAt", (q) => q.eq("status", status))
+          .order("desc")
+          .take(limit),
+      ),
+    );
+
+    return batches
+      .flat()
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, limit);
+  },
+});
+
+export const listRecent = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 20, 100);
+    return await ctx.db
+      .query("loopRuns")
+      .withIndex("by_updatedAt")
+      .order("desc")
+      .take(limit);
+  },
+});
+
+export const appendEvent = mutation({
+  args: {
+    runId: v.id("loopRuns"),
+    eventType: v.string(),
+    level: v.union(
+      v.literal("debug"),
+      v.literal("info"),
+      v.literal("warn"),
+      v.literal("error"),
+    ),
+    message: v.optional(v.string()),
+    nodeId: v.optional(v.string()),
+    edgeId: v.optional(v.string()),
+    payload: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const run = await ctx.db.get(args.runId);
+    if (!run) {
+      throw new Error(`Run not found: ${args.runId}`);
+    }
+
+    const now = Date.now();
+    const sequence = await nextRunEventSequence(ctx, args.runId);
+
+    await ctx.db.insert("runEvents", {
+      runId: args.runId,
+      sequence,
+      eventType: args.eventType,
+      level: args.level,
+      message: args.message,
+      nodeId: args.nodeId,
+      edgeId: args.edgeId,
+      payload: args.payload,
+      createdAt: now,
+    });
+
+    await ctx.db.patch(args.runId, { updatedAt: now });
+
+    return sequence;
+  },
+});

package/convex/schema.ts

@@ -0,0 +1,220 @@
+import { defineSchema, defineTable } from "convex/server";
+import { v } from "convex/values";
+
+const runStatus = v.union(
+  v.literal("running"),
+  v.literal("waiting"),
+  v.literal("paused"),
+  v.literal("completed"),
+  v.literal("failed"),
+  v.literal("canceled"),
+);
+
+const actionStatus = v.union(
+  v.literal("pending"),
+  v.literal("claimed"),
+  v.literal("applying"),
+  v.literal("completed"),
+  v.literal("failed"),
+  v.literal("skipped"),
+  v.literal("expired"),
+);
+
+const leaseStatus = v.union(
+  v.literal("active"),
+  v.literal("released"),
+  v.literal("completed"),
+  v.literal("expired"),
+  v.literal("failed"),
+);
+
+const logLevel = v.union(
+  v.literal("debug"),
+  v.literal("info"),
+  v.literal("warn"),
+  v.literal("error"),
+);
+
+const skillVersionStatus = v.union(
+  v.literal("draft"),
+  v.literal("published"),
+  v.literal("archived"),
+);
+
+const loopVersionStatus = v.union(
+  v.literal("draft"),
+  v.literal("published"),
+  v.literal("archived"),
+);
+
+export default defineSchema({
+  skills: defineTable({
+    slug: v.string(),
+    name: v.string(),
+    summary: v.optional(v.string()),
+    tags: v.array(v.string()),
+    latestVersionId: v.optional(v.id("skillVersions")),
+    draftVersionId: v.optional(v.id("skillVersions")),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_slug", ["slug"])
+    .index("by_updatedAt", ["updatedAt"]),
+
+  skillVersions: defineTable({
+    skillId: v.id("skills"),
+    version: v.string(),
+    status: skillVersionStatus,
+    instructions: v.string(),
+    inputSpec: v.optional(v.string()),
+    outputSpec: v.optional(v.string()),
+    testPrompt: v.optional(v.string()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    publishedAt: v.optional(v.number()),
+  })
+    .index("by_skill_status", ["skillId", "status"])
+    .index("by_skill_version", ["skillId", "version"])
+    .index("by_status_updatedAt", ["status", "updatedAt"]),
+
+  loops: defineTable({
+    slug: v.string(),
+    name: v.string(),
+    description: v.optional(v.string()),
+    primarySkill: v.optional(v.string()),
+    tags: v.array(v.string()),
+    latestVersionId: v.optional(v.id("loopVersions")),
+    draftVersionId: v.optional(v.id("loopVersions")),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_slug", ["slug"])
+    .index("by_updatedAt", ["updatedAt"]),
+
+  loopVersions: defineTable({
+    loopId: v.id("loops"),
+    version: v.string(),
+    status: loopVersionStatus,
+    manifest: v.any(),
+    contentHash: v.string(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+    publishedAt: v.optional(v.number()),
+  })
+    .index("by_loop_status", ["loopId", "status"])
+    .index("by_loop_version", ["loopId", "version"])
+    .index("by_content_hash", ["contentHash"]),
+
+  loopRuns: defineTable({
+    loopSlug: v.string(),
+    loopVersionId: v.optional(v.id("loopVersions")),
+    status: runStatus,
+    activeNodeId: v.optional(v.string()),
+    prompt: v.optional(v.string()),
+    summary: v.optional(v.string()),
+    graph: v.optional(v.any()),
+    controls: v.optional(v.any()),
+    context: v.optional(v.any()),
+    transitionCount: v.number(),
+    startedAt: v.number(),
+    completedAt: v.optional(v.number()),
+    updatedAt: v.number(),
+  })
+    .index("by_status_updatedAt", ["status", "updatedAt"])
+    .index("by_loop_status", ["loopSlug", "status"])
+    .index("by_updatedAt", ["updatedAt"]),
+
+  runEvents: defineTable({
+    runId: v.id("loopRuns"),
+    sequence: v.number(),
+    eventType: v.string(),
+    nodeId: v.optional(v.string()),
+    edgeId: v.optional(v.string()),
+    level: logLevel,
+    message: v.optional(v.string()),
+    payload: v.optional(v.any()),
+    createdAt: v.number(),
+  })
+    .index("by_run_sequence", ["runId", "sequence"])
+    .index("by_run_createdAt", ["runId", "createdAt"])
+    .index("by_type_createdAt", ["eventType", "createdAt"]),
+
+  hostActions: defineTable({
+    runId: v.id("loopRuns"),
+    loopSlug: v.string(),
+    nodeId: v.optional(v.string()),
+    actionType: v.string(),
+    title: v.string(),
+    status: actionStatus,
+    idempotencyKey: v.string(),
+    payload: v.any(),
+    codexTool: v.optional(v.any()),
+    claimId: v.optional(v.string()),
+    claimedBy: v.optional(v.string()),
+    claimedAt: v.optional(v.number()),
+    leaseExpiresAt: v.optional(v.number()),
+    result: v.optional(v.any()),
+    error: v.optional(v.string()),
+    completedAt: v.optional(v.number()),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_status_createdAt", ["status", "createdAt"])
+    .index("by_run_status", ["runId", "status"])
+    .index("by_run_createdAt", ["runId", "createdAt"])
+    .index("by_claim", ["claimId"])
+    .index("by_idempotency", ["idempotencyKey"]),
+
+  bridgeSessions: defineTable({
+    name: v.string(),
+    kind: v.string(),
+    status: v.union(v.literal("online"), v.literal("offline"), v.literal("draining")),
+    capabilities: v.array(v.string()),
+    lastSeenAt: v.number(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_status", ["status"])
+    .index("by_lastSeenAt", ["lastSeenAt"]),
+
+  bridgeLeases: defineTable({
+    actionId: v.id("hostActions"),
+    sessionId: v.optional(v.id("bridgeSessions")),
+    claimId: v.string(),
+    status: leaseStatus,
+    leaseExpiresAt: v.number(),
+    heartbeatAt: v.number(),
+    createdAt: v.number(),
+    updatedAt: v.number(),
+  })
+    .index("by_claim", ["claimId"])
+    .index("by_action_status", ["actionId", "status"])
+    .index("by_session_status", ["sessionId", "status"])
+    .index("by_expiry", ["leaseExpiresAt"]),
+
+  bridgeLogs: defineTable({
+    runId: v.optional(v.id("loopRuns")),
+    actionId: v.optional(v.id("hostActions")),
+    claimId: v.optional(v.string()),
+    source: v.string(),
+    level: logLevel,
+    message: v.string(),
+    data: v.optional(v.any()),
+    createdAt: v.number(),
+  })
+    .index("by_run_createdAt", ["runId", "createdAt"])
+    .index("by_action_createdAt", ["actionId", "createdAt"])
+    .index("by_claim_createdAt", ["claimId", "createdAt"]),
+
+  artifacts: defineTable({
+    runId: v.id("loopRuns"),
+    actionId: v.optional(v.id("hostActions")),
+    kind: v.string(),
+    label: v.string(),
+    uri: v.optional(v.string()),
+    data: v.optional(v.any()),
+    createdAt: v.number(),
+  })
+    .index("by_run_createdAt", ["runId", "createdAt"])
+    .index("by_action_createdAt", ["actionId", "createdAt"]),
+});