@webgrow/skillhub 0.1.0

package/convex/skills.ts

@@ -0,0 +1,413 @@
+import { v } from "convex/values";
+import { mutation, query } from "./_generated/server";
+
+const defaultInstructions = [
+  "You are running this SkillHub skill as a bounded Codex task.",
+  "Follow the skill instructions, produce a concise result, and call out blockers or missing inputs.",
+].join("\n\n");
+
+export const list = query({
+  args: {
+    limit: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    const limit = Math.min(args.limit ?? 50, 200);
+    const skills = await ctx.db
+      .query("skills")
+      .withIndex("by_updatedAt")
+      .order("desc")
+      .take(limit);
+
+    return await Promise.all(
+      skills.map(async (skill) => ({
+        skill,
+        latestVersion: skill.latestVersionId
+          ? await ctx.db.get(skill.latestVersionId)
+          : null,
+        draftVersion: skill.draftVersionId
+          ? await ctx.db.get(skill.draftVersionId)
+          : null,
+      })),
+    );
+  },
+});
+
+export const get = query({
+  args: {
+    skillId: v.id("skills"),
+  },
+  handler: async (ctx, args) => {
+    const skill = await ctx.db.get(args.skillId);
+    if (!skill) {
+      return null;
+    }
+
+    const versions = await ctx.db
+      .query("skillVersions")
+      .withIndex("by_skill_version", (q) => q.eq("skillId", args.skillId))
+      .order("desc")
+      .take(30);
+
+    return {
+      skill,
+      versions,
+      latestVersion: skill.latestVersionId
+        ? await ctx.db.get(skill.latestVersionId)
+        : null,
+      draftVersion: skill.draftVersionId
+        ? await ctx.db.get(skill.draftVersionId)
+        : null,
+    };
+  },
+});
+
+export const createDraft = mutation({
+  args: {
+    name: v.string(),
+    summary: v.optional(v.string()),
+    instructions: v.optional(v.string()),
+    inputSpec: v.optional(v.string()),
+    outputSpec: v.optional(v.string()),
+    testPrompt: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const name = requireText(args.name, "Skill name");
+    const slug = await uniqueSlug(ctx, slugify(name));
+
+    const skillId = await ctx.db.insert("skills", {
+      slug,
+      name,
+      summary: cleanOptional(args.summary),
+      tags: normalizeTags(args.tags ?? []),
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const draftVersionId = await ctx.db.insert("skillVersions", {
+      skillId,
+      version: "draft",
+      status: "draft",
+      instructions: cleanOptional(args.instructions) || defaultInstructions,
+      inputSpec: cleanOptional(args.inputSpec),
+      outputSpec: cleanOptional(args.outputSpec),
+      testPrompt: cleanOptional(args.testPrompt),
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.patch(skillId, {
+      draftVersionId,
+      updatedAt: now,
+    });
+
+    return skillId;
+  },
+});
+
+export const saveDraft = mutation({
+  args: {
+    skillId: v.id("skills"),
+    name: v.string(),
+    summary: v.optional(v.string()),
+    instructions: v.string(),
+    inputSpec: v.optional(v.string()),
+    outputSpec: v.optional(v.string()),
+    testPrompt: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const skill = await requireSkill(ctx, args.skillId);
+    const now = Date.now();
+    const name = requireText(args.name, "Skill name");
+    const instructions = requireText(args.instructions, "Instructions");
+    const draftVersionId = await ensureDraftVersion(ctx, skill, now);
+    const skillPatch: any = {
+      name,
+      summary: cleanOptional(args.summary),
+      tags: normalizeTags(args.tags ?? []),
+      updatedAt: now,
+    };
+
+    if (!skill.latestVersionId || skill.slug.startsWith("untitled-skill")) {
+      skillPatch.slug = await uniqueSlugForSkill(ctx, slugify(name), args.skillId);
+    }
+
+    await ctx.db.patch(args.skillId, skillPatch);
+
+    await ctx.db.patch(draftVersionId, {
+      instructions,
+      inputSpec: cleanOptional(args.inputSpec),
+      outputSpec: cleanOptional(args.outputSpec),
+      testPrompt: cleanOptional(args.testPrompt),
+      updatedAt: now,
+    });
+
+    return draftVersionId;
+  },
+});
+
+export const publishDraft = mutation({
+  args: {
+    skillId: v.id("skills"),
+  },
+  handler: async (ctx, args) => {
+    const skill = await requireSkill(ctx, args.skillId);
+    if (!skill.draftVersionId) {
+      throw new Error("No draft exists to publish.");
+    }
+
+    const draft = await ctx.db.get(skill.draftVersionId);
+    if (!draft) {
+      throw new Error("Draft version not found.");
+    }
+
+    requireText(draft.instructions, "Instructions");
+    const now = Date.now();
+    const version = await nextPublishedVersion(ctx, args.skillId);
+
+    await ctx.db.patch(draft._id, {
+      version,
+      status: "published",
+      publishedAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.patch(args.skillId, {
+      latestVersionId: draft._id,
+      draftVersionId: undefined,
+      updatedAt: now,
+    });
+
+    return draft._id;
+  },
+});
+
+export const runTest = mutation({
+  args: {
+    skillId: v.id("skills"),
+    promptOverride: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const skill = await requireSkill(ctx, args.skillId);
+    const versionId = skill.latestVersionId ?? skill.draftVersionId;
+    if (!versionId) {
+      throw new Error("Save a skill draft before running a test.");
+    }
+
+    const version = await ctx.db.get(versionId);
+    if (!version) {
+      throw new Error("Skill version not found.");
+    }
+
+    const now = Date.now();
+    const prompt = cleanOptional(args.promptOverride) || version.testPrompt || `Test ${skill.name}`;
+    const loopSlug = `skill:${skill.slug}`;
+
+    const runId = await ctx.db.insert("loopRuns", {
+      loopSlug,
+      status: "running",
+      activeNodeId: "skill.execute",
+      prompt,
+      graph: {
+        entryNodeId: "skill.execute",
+        nodes: [{ id: "skill.execute", type: "hostAction" }],
+      },
+      controls: {
+        source: "skill-authoring",
+        mode: "test",
+        skillId: skill._id,
+        skillVersionId: version._id,
+      },
+      context: {
+        skill: {
+          name: skill.name,
+          slug: skill.slug,
+          version: version.version,
+          status: version.status,
+        },
+      },
+      transitionCount: 0,
+      startedAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("runEvents", {
+      runId,
+      sequence: 1,
+      eventType: "run.created",
+      level: "info",
+      message: `Skill test created for ${skill.name}`,
+      payload: {
+        skillId: skill._id,
+        skillVersionId: version._id,
+        prompt,
+      },
+      createdAt: now,
+    });
+
+    const actionId = await ctx.db.insert("hostActions", {
+      runId,
+      loopSlug,
+      nodeId: "skill.execute",
+      actionType: "codex.cli",
+      title: `Test skill: ${skill.name}`,
+      status: "pending",
+      idempotencyKey: `skill-test:${runId}`,
+      payload: {
+        prompt: renderSkillPrompt({ skill, version, prompt }),
+        skill: {
+          id: skill._id,
+          slug: skill.slug,
+          name: skill.name,
+          summary: skill.summary,
+          tags: skill.tags,
+        },
+        version: {
+          id: version._id,
+          version: version.version,
+          status: version.status,
+        },
+      },
+      codexTool: {
+        adapter: "codex-cli",
+        safeDefault: "dry-run",
+      },
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    await ctx.db.insert("runEvents", {
+      runId,
+      sequence: 2,
+      eventType: "host_action.enqueued",
+      level: "info",
+      nodeId: "skill.execute",
+      message: `Queued skill test for ${skill.name}`,
+      payload: {
+        actionId,
+        actionType: "codex.cli",
+      },
+      createdAt: now,
+    });
+
+    return { runId, actionId };
+  },
+});
+
+async function requireSkill(ctx: any, skillId: any) {
+  const skill = await ctx.db.get(skillId);
+  if (!skill) {
+    throw new Error(`Skill not found: ${skillId}`);
+  }
+  return skill;
+}
+
+async function ensureDraftVersion(ctx: any, skill: any, now: number) {
+  if (skill.draftVersionId) {
+    return skill.draftVersionId;
+  }
+
+  const latest = skill.latestVersionId ? await ctx.db.get(skill.latestVersionId) : null;
+  const draftVersionId = await ctx.db.insert("skillVersions", {
+    skillId: skill._id,
+    version: "draft",
+    status: "draft",
+    instructions: latest?.instructions ?? defaultInstructions,
+    inputSpec: latest?.inputSpec,
+    outputSpec: latest?.outputSpec,
+    testPrompt: latest?.testPrompt,
+    createdAt: now,
+    updatedAt: now,
+  });
+
+  await ctx.db.patch(skill._id, {
+    draftVersionId,
+    updatedAt: now,
+  });
+
+  return draftVersionId;
+}
+
+async function nextPublishedVersion(ctx: any, skillId: any) {
+  const published = await ctx.db
+    .query("skillVersions")
+    .withIndex("by_skill_status", (q: any) =>
+      q.eq("skillId", skillId).eq("status", "published"),
+    )
+    .collect();
+
+  return `v${published.length + 1}`;
+}
+
+async function uniqueSlug(ctx: any, base: string) {
+  const existing = await ctx.db
+    .query("skills")
+    .withIndex("by_slug", (q: any) => q.eq("slug", base))
+    .unique();
+
+  if (!existing) {
+    return base;
+  }
+
+  return `${base}-${Date.now().toString(36)}`;
+}
+
+async function uniqueSlugForSkill(ctx: any, base: string, skillId: any) {
+  const existing = await ctx.db
+    .query("skills")
+    .withIndex("by_slug", (q: any) => q.eq("slug", base))
+    .unique();
+
+  if (!existing || existing._id === skillId) {
+    return base;
+  }
+
+  return `${base}-${Date.now().toString(36)}`;
+}
+
+function renderSkillPrompt({ skill, version, prompt }: any) {
+  return [
+    `Skill: ${skill.name}`,
+    skill.summary ? `Summary: ${skill.summary}` : null,
+    skill.tags?.length ? `Tags: ${skill.tags.join(", ")}` : null,
+    "",
+    "Instructions:",
+    version.instructions,
+    "",
+    version.inputSpec ? `Inputs:\n${version.inputSpec}` : null,
+    version.outputSpec ? `Expected output:\n${version.outputSpec}` : null,
+    "",
+    "Test prompt:",
+    prompt,
+  ]
+    .filter(Boolean)
+    .join("\n");
+}
+
+function slugify(value: string) {
+  const slug = value
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "");
+
+  return slug || "skill";
+}
+
+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;
+}

package/convex/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  /* This TypeScript project config describes the environment that
+   * Convex functions run in and is used to typecheck them.
+   * You can modify it, but some settings are required to use Convex.
+   */
+  "compilerOptions": {
+    /* These settings are not required by Convex and can be modified. */
+    "allowJs": true,
+    "strict": true,
+    "moduleResolution": "Bundler",
+    "jsx": "react-jsx",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+
+    /* These compiler options are required by Convex */
+    "target": "ESNext",
+    "lib": ["ES2023", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "noEmit": true
+  },
+  "include": ["./**/*"],
+  "exclude": ["./_generated"]
+}

package/dashboard/.env.example

@@ -0,0 +1 @@
+VITE_CONVEX_URL=https://your-deployment.convex.cloud

package/dashboard/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>SkillHub Control</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>