@webgrow/skillhub 0.1.0

package/convex/http.ts

@@ -0,0 +1,37 @@
+import { httpRouter } from "convex/server";
+import { api } from "./_generated/api";
+import { httpAction } from "./_generated/server";
+
+const http = httpRouter();
+
+function json(data: unknown, status = 200) {
+  return new Response(JSON.stringify(data), {
+    status,
+    headers: {
+      "content-type": "application/json; charset=utf-8",
+    },
+  });
+}
+
+http.route({
+  path: "/bridge/health",
+  method: "GET",
+  handler: httpAction(async () =>
+    json({
+      ok: true,
+      service: "skillhub-convex-bridge",
+    }),
+  ),
+});
+
+http.route({
+  path: "/bridge/log",
+  method: "POST",
+  handler: httpAction(async (ctx, request) => {
+    const body = await request.json();
+    const logId = await ctx.runMutation(api.bridge.emitLog, body);
+    return json({ ok: true, logId });
+  }),
+});
+
+export default http;

package/convex/loops.ts

@@ -0,0 +1,546 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+const defaultSteps = [
+  {
+    id: "step-1",
+    label: "Plan the work",
+    actionType: "codex.cli",
+    skillSlug: "",
+    instructions: "Read the objective, identify risks, and produce a short plan.",
+  },
+  {
+    id: "step-2",
+    label: "Execute the work",
+    actionType: "codex.cli",
+    skillSlug: "",
+    instructions: "Carry out the plan, report changes, verification, and blockers.",
+  },
+];
+
+export const list = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 50, 200);
+    const loops = await ctx.db
+      .query("loops")
+      .withIndex("by_updatedAt")
+      .order("desc")
+      .take(limit);
+
+    return await Promise.all(
+      loops.map(async (loop) => ({
+        loop,
+        latestVersion: loop.latestVersionId
+          ? await ctx.db.get(loop.latestVersionId)
+          : null,
+        draftVersion: loop.draftVersionId
+          ? await ctx.db.get(loop.draftVersionId)
+          : null,
+      })),
+    );
+  },
+});
+
+export const get = query({
+  args: {
+    loopId: v.id("loops"),
+  },
+  handler: async (ctx, args) => {
+    const loop = await ctx.db.get(args.loopId);
+    if (!loop) {
+      return null;
+    }
+
+    const versions = await ctx.db
+      .query("loopVersions")
+      .withIndex("by_loop_version", (q) => q.eq("loopId", args.loopId))
+      .order("desc")
+      .take(30);
+
+    return {
+      loop,
+      versions,
+      latestVersion: loop.latestVersionId
+        ? await ctx.db.get(loop.latestVersionId)
+        : null,
+      draftVersion: loop.draftVersionId
+        ? await ctx.db.get(loop.draftVersionId)
+        : null,
+    };
+  },
+});
+
+export const createDraft = mutation({
+  args: {
+    name: v.string(),
+    description: v.optional(v.string()),
+    objective: v.optional(v.string()),
+    trigger: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    primarySkill: v.optional(v.string()),
+    steps: v.optional(v.array(v.any())),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const name = requireText(args.name, "Loop name");
+    const slug = await uniqueSlug(ctx, slugify(name));
+    const steps = normalizeSteps(args.steps ?? defaultSteps);
+    const manifest = buildManifest({
+      name,
+      description: cleanOptional(args.description),
+      objective: cleanOptional(args.objective) || `Run ${name}`,
+      trigger: cleanOptional(args.trigger) || "manual",
+      primarySkill: cleanOptional(args.primarySkill),
+      tags: normalizeTags(args.tags ?? []),
+      steps,
+    });
+
+    const loopId = await ctx.db.insert("loops", {
+      slug,
+      name,
+      description: cleanOptional(args.description),
+      primarySkill: cleanOptional(args.primarySkill),
+      tags: normalizeTags(args.tags ?? []),
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const draftVersionId = await ctx.db.insert("loopVersions", {
+      loopId,
+      version: "draft",
+      status: "draft",
+      manifest,
+      contentHash: contentHash(manifest),
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.patch(loopId, {
+      draftVersionId,
+      updatedAt: now,
+    });
+
+    return loopId;
+  },
+});
+
+export const saveDraft = mutation({
+  args: {
+    loopId: v.id("loops"),
+    name: v.string(),
+    description: v.optional(v.string()),
+    objective: v.string(),
+    trigger: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    primarySkill: v.optional(v.string()),
+    steps: v.array(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const loop = await requireLoop(ctx, args.loopId);
+    const now = Date.now();
+    const name = requireText(args.name, "Loop name");
+    const steps = normalizeSteps(args.steps);
+    const tags = normalizeTags(args.tags ?? []);
+    const manifest = buildManifest({
+      name,
+      description: cleanOptional(args.description),
+      objective: requireText(args.objective, "Objective"),
+      trigger: cleanOptional(args.trigger) || "manual",
+      primarySkill: cleanOptional(args.primarySkill),
+      tags,
+      steps,
+    });
+    const draftVersionId = await ensureDraftVersion(ctx, loop, now);
+    const loopPatch: any = {
+      name,
+      description: cleanOptional(args.description),
+      primarySkill: cleanOptional(args.primarySkill),
+      tags,
+      updatedAt: now,
+    };
+
+    if (!loop.latestVersionId || loop.slug.startsWith("untitled-loop")) {
+      loopPatch.slug = await uniqueSlugForLoop(ctx, slugify(name), args.loopId);
+    }
+
+    await ctx.db.patch(args.loopId, loopPatch);
+    await ctx.db.patch(draftVersionId, {
+      manifest,
+      contentHash: contentHash(manifest),
+      updatedAt: now,
+    });
+
+    return draftVersionId;
+  },
+});
+
+export const publishDraft = mutation({
+  args: {
+    loopId: v.id("loops"),
+  },
+  handler: async (ctx, args) => {
+    const loop = await requireLoop(ctx, args.loopId);
+    if (!loop.draftVersionId) {
+      throw new Error("No draft exists to publish.");
+    }
+
+    const draft = await ctx.db.get(loop.draftVersionId);
+    if (!draft) {
+      throw new Error("Draft version not found.");
+    }
+
+    validateManifest(draft.manifest);
+    const now = Date.now();
+    const version = await nextPublishedVersion(ctx, args.loopId);
+
+    await ctx.db.patch(draft._id, {
+      version,
+      status: "published",
+      publishedAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.patch(args.loopId, {
+      latestVersionId: draft._id,
+      draftVersionId: undefined,
+      updatedAt: now,
+    });
+
+    return draft._id;
+  },
+});
+
+export const run = mutation({
+  args: {
+    loopId: v.id("loops"),
+    promptOverride: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const loop = await requireLoop(ctx, args.loopId);
+    const versionId = loop.latestVersionId ?? loop.draftVersionId;
+    if (!versionId) {
+      throw new Error("Save a loop draft before running it.");
+    }
+
+    const version = await ctx.db.get(versionId);
+    if (!version) {
+      throw new Error("Loop version not found.");
+    }
+
+    validateManifest(version.manifest);
+    const now = Date.now();
+    const steps = version.manifest.steps;
+    const firstStep = steps[0];
+    const prompt = cleanOptional(args.promptOverride) || version.manifest.objective;
+
+    const runId = await ctx.db.insert("loopRuns", {
+      loopSlug: loop.slug,
+      loopVersionId: version._id,
+      status: "running",
+      activeNodeId: firstStep.id,
+      prompt,
+      graph: version.manifest.graph,
+      controls: {
+        source: "loop-authoring",
+        mode: "loop",
+        loopId: loop._id,
+        loopVersionId: version._id,
+      },
+      context: {
+        loop: {
+          name: loop.name,
+          slug: loop.slug,
+          version: version.version,
+          status: version.status,
+        },
+      },
+      transitionCount: 0,
+      startedAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("runEvents", {
+      runId,
+      sequence: 1,
+      eventType: "loop.started",
+      level: "info",
+      nodeId: firstStep.id,
+      message: `Loop started: ${loop.name}`,
+      payload: {
+        loopId: loop._id,
+        loopVersionId: version._id,
+        steps: steps.length,
+        prompt,
+      },
+      createdAt: now,
+    });
+
+    const actionId = await enqueueLoopStep(ctx, {
+      runId,
+      loop,
+      version,
+      prompt,
+      steps,
+      stepIndex: 0,
+      now,
+    });
+
+    return { runId, actionId };
+  },
+});
+
+async function enqueueLoopStep(ctx: any, { runId, loop, version, prompt, steps, stepIndex, now }: any) {
+  const step = steps[stepIndex];
+  const nextStep = steps[stepIndex + 1] ?? null;
+  const actionId = await ctx.db.insert("hostActions", {
+    runId,
+    loopSlug: loop.slug,
+    nodeId: step.id,
+    actionType: step.actionType || "codex.cli",
+    title: `${loop.name}: ${step.label}`,
+    status: "pending",
+    idempotencyKey: `loop-step:${runId}:${step.id}`,
+    payload: {
+      prompt: renderStepPrompt({ loop, version, prompt, step, stepIndex, steps }),
+      loopStep: {
+        loopId: loop._id,
+        loopVersionId: version._id,
+        stepIndex,
+        totalSteps: steps.length,
+        steps,
+        nextStep,
+      },
+      loop: {
+        name: loop.name,
+        slug: loop.slug,
+        version: version.version,
+      },
+      step,
+    },
+    codexTool: {
+      adapter: "codex-cli",
+      safeDefault: "dry-run",
+    },
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  await ctx.db.insert("runEvents", {
+    runId,
+    sequence: stepIndex + 2,
+    eventType: "loop.step.enqueued",
+    level: "info",
+    nodeId: step.id,
+    message: `Queued step ${stepIndex + 1}: ${step.label}`,
+    payload: {
+      actionId,
+      stepIndex,
+      totalSteps: steps.length,
+    },
+    createdAt: now,
+  });
+
+  return actionId;
+}
+
+async function requireLoop(ctx: any, loopId: any) {
+  const loop = await ctx.db.get(loopId);
+  if (!loop) {
+    throw new Error(`Loop not found: ${loopId}`);
+  }
+  return loop;
+}
+
+async function ensureDraftVersion(ctx: any, loop: any, now: number) {
+  if (loop.draftVersionId) {
+    return loop.draftVersionId;
+  }
+
+  const latest = loop.latestVersionId ? await ctx.db.get(loop.latestVersionId) : null;
+  const manifest = latest?.manifest ?? buildManifest({
+    name: loop.name,
+    description: loop.description,
+    objective: `Run ${loop.name}`,
+    trigger: "manual",
+    primarySkill: loop.primarySkill,
+    tags: loop.tags,
+    steps: defaultSteps,
+  });
+  const draftVersionId = await ctx.db.insert("loopVersions", {
+    loopId: loop._id,
+    version: "draft",
+    status: "draft",
+    manifest,
+    contentHash: contentHash(manifest),
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  await ctx.db.patch(loop._id, {
+    draftVersionId,
+    updatedAt: now,
+  });
+
+  return draftVersionId;
+}
+
+async function nextPublishedVersion(ctx: any, loopId: any) {
+  const published = await ctx.db
+    .query("loopVersions")
+    .withIndex("by_loop_status", (q: any) =>
+      q.eq("loopId", loopId).eq("status", "published"),
+    )
+    .collect();
+
+  return `v${published.length + 1}`;
+}
+
+async function uniqueSlug(ctx: any, base: string) {
+  const existing = await ctx.db
+    .query("loops")
+    .withIndex("by_slug", (q: any) => q.eq("slug", base))
+    .unique();
+
+  if (!existing) {
+    return base;
+  }
+
+  return `${base}-${Date.now().toString(36)}`;
+}
+
+async function uniqueSlugForLoop(ctx: any, base: string, loopId: any) {
+  const existing = await ctx.db
+    .query("loops")
+    .withIndex("by_slug", (q: any) => q.eq("slug", base))
+    .unique();
+
+  if (!existing || existing._id === loopId) {
+    return base;
+  }
+
+  return `${base}-${Date.now().toString(36)}`;
+}
+
+function buildManifest({ name, description, objective, trigger, primarySkill, tags, steps }: any) {
+  const normalizedSteps = normalizeSteps(steps);
+  return {
+    name,
+    description,
+    objective,
+    trigger,
+    primarySkill,
+    tags,
+    steps: normalizedSteps,
+    graph: linearGraphFromSteps(normalizedSteps),
+  };
+}
+
+function validateManifest(manifest: any) {
+  if (!manifest?.steps?.length) {
+    throw new Error("Loop needs at least one step.");
+  }
+  if (!cleanOptional(manifest.objective)) {
+    throw new Error("Loop objective is required.");
+  }
+}
+
+function linearGraphFromSteps(steps: any[]) {
+  return {
+    layout: "linear",
+    entryNodeId: steps[0]?.id ?? null,
+    nodes: steps.map((step, index) => ({
+      id: step.id,
+      type: step.actionType || "codex.cli",
+      label: step.label,
+      prompt: step.instructions,
+      skillRefs: step.skillSlug ? [step.skillSlug] : [],
+      x: 120 + index * 260,
+      y: 120,
+    })),
+    edges: steps.slice(0, -1).map((step, index) => ({
+      id: `edge-${index + 1}`,
+      from: step.id,
+      to: steps[index + 1].id,
+      condition: "completed",
+    })),
+  };
+}
+
+function normalizeSteps(steps: any[]) {
+  const normalized = steps
+    .map((step, index) => ({
+      id: cleanOptional(step.id) || `step-${index + 1}`,
+      label: cleanOptional(step.label) || `Step ${index + 1}`,
+      actionType: cleanOptional(step.actionType) || "codex.cli",
+      skillSlug: cleanOptional(step.skillSlug) || "",
+      instructions: cleanOptional(step.instructions) || `Complete step ${index + 1}.`,
+    }))
+    .slice(0, 12);
+
+  if (!normalized.length) {
+    throw new Error("Loop needs at least one step.");
+  }
+
+  return normalized.map((step, index) => ({
+    ...step,
+    id: slugify(step.id) || `step-${index + 1}`,
+  }));
+}
+
+function renderStepPrompt({ loop, version, prompt, step, stepIndex, steps }: any) {
+  return [
+    `Loop: ${loop.name}`,
+    `Version: ${version.version}`,
+    `Step ${stepIndex + 1} of ${steps.length}: ${step.label}`,
+    step.skillSlug ? `Skill reference: ${step.skillSlug}` : null,
+    "",
+    "Loop objective:",
+    prompt,
+    "",
+    "Step instructions:",
+    step.instructions,
+    "",
+    "All loop steps:",
+    ...steps.map((item: any, index: number) => `${index + 1}. ${item.label}`),
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function contentHash(manifest: any) {
+  const text = JSON.stringify(manifest);
+  let hash = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    hash = (hash * 31 + text.charCodeAt(index)) >>> 0;
+  }
+  return hash.toString(36);
+}
+
+function slugify(value: string) {
+  const slug = value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return slug || "loop";
+}
+
+function normalizeTags(tags: string[]) {
+  return [...new Set(tags.map((tag) => tag.trim()).filter(Boolean))].slice(0, 12);
+}
+
+function cleanOptional(value?: string) {
+  const cleaned = value?.trim();
+  return cleaned ? cleaned : undefined;
+}
+
+function requireText(value: string | undefined, label: string) {
+  const cleaned = cleanOptional(value);
+  if (!cleaned) {
+    throw new Error(`${label} is required.`);
+  }
+  return cleaned;
+}