@yattalo/task-system 0.4.0 → 0.5.0

package/templates/uca/skills.ts

@@ -0,0 +1,284 @@
+import { mutation, query } from "../_generated/server";
+import { v } from "convex/values";
+
+function makeId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+async function getSkillById(ctx: any, skillId: string): Promise<any | null> {
+  return await ctx.db
+    .query("skillRegistry")
+    .withIndex("by_skillId", (q: any) => q.eq("skillId", skillId))
+    .first();
+}
+
+async function getAgentById(ctx: any, agentId: string): Promise<any | null> {
+  return await ctx.db
+    .query("agentRegistry")
+    .withIndex("by_agentId", (q: any) => q.eq("agentId", agentId))
+    .first();
+}
+
+export const listSkills = query({
+  args: {
+    status: v.optional(v.union(v.literal("active"), v.literal("deprecated"))),
+    owner: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    let skills = await ctx.db.query("skillRegistry").collect();
+    if (args.status) skills = skills.filter((skill) => skill.status === args.status);
+    if (args.owner) skills = skills.filter((skill) => skill.owner === args.owner);
+    return skills.sort((a, b) => b.updatedAt - a.updatedAt);
+  },
+});
+
+export const upsertSkill = mutation({
+  args: {
+    skillId: v.string(),
+    name: v.string(),
+    version: v.optional(v.string()),
+    description: v.optional(v.string()),
+    promptTemplate: v.string(),
+    tags: v.optional(v.array(v.string())),
+    owner: v.string(),
+    status: v.optional(v.union(v.literal("active"), v.literal("deprecated"))),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    const existing = await getSkillById(ctx, args.skillId);
+
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        name: args.name,
+        version: args.version ?? existing.version,
+        description: args.description,
+        promptTemplate: args.promptTemplate,
+        tags: args.tags ?? existing.tags,
+        owner: args.owner,
+        status: args.status ?? existing.status,
+        updatedAt: now,
+      });
+      return { skillId: args.skillId, updated: true };
+    }
+
+    await ctx.db.insert("skillRegistry", {
+      skillId: args.skillId,
+      name: args.name,
+      version: args.version ?? "1.0.0",
+      description: args.description,
+      promptTemplate: args.promptTemplate,
+      tags: args.tags ?? [],
+      owner: args.owner,
+      status: args.status ?? "active",
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    return { skillId: args.skillId, created: true };
+  },
+});
+
+export const removeSkill = mutation({
+  args: {
+    skillId: v.string(),
+    hardDelete: v.optional(v.boolean()),
+  },
+  handler: async (ctx, { skillId, hardDelete }) => {
+    const existing = await getSkillById(ctx, skillId);
+    if (!existing) return { skillId, removed: false };
+
+    if (hardDelete) {
+      await ctx.db.delete(existing._id);
+      const bindings = await ctx.db
+        .query("agentSkills")
+        .withIndex("by_skillId", (q: any) => q.eq("skillId", skillId))
+        .collect();
+      for (const binding of bindings) {
+        await ctx.db.delete(binding._id);
+      }
+      return { skillId, removed: true, hardDelete: true, detached: bindings.length };
+    }
+
+    await ctx.db.patch(existing._id, { status: "deprecated", updatedAt: Date.now() });
+    return { skillId, removed: true, hardDelete: false };
+  },
+});
+
+export const listAgentSkills = query({
+  args: {
+    agentId: v.string(),
+    enabledOnly: v.optional(v.boolean()),
+  },
+  handler: async (ctx, { agentId, enabledOnly }) => {
+    const bindings = await ctx.db
+      .query("agentSkills")
+      .withIndex("by_agentId", (q: any) => q.eq("agentId", agentId))
+      .collect();
+
+    const filtered = enabledOnly ? bindings.filter((binding) => binding.enabled) : bindings;
+
+    const results = [] as any[];
+    for (const binding of filtered) {
+      const skill = await getSkillById(ctx, binding.skillId);
+      if (!skill) continue;
+      results.push({ binding, skill });
+    }
+
+    return results;
+  },
+});
+
+export const assignSkillToAgent = mutation({
+  args: {
+    agentId: v.string(),
+    skillId: v.string(),
+    enabled: v.optional(v.boolean()),
+    proficiency: v.optional(v.number()),
+    config: v.optional(v.any()),
+  },
+  handler: async (ctx, args) => {
+    const agent = await getAgentById(ctx, args.agentId);
+    if (!agent) throw new Error(`Agent ${args.agentId} not found`);
+
+    const skill = await getSkillById(ctx, args.skillId);
+    if (!skill) throw new Error(`Skill ${args.skillId} not found`);
+
+    const existing = await ctx.db
+      .query("agentSkills")
+      .withIndex("by_agent_skill", (q: any) => q.eq("agentId", args.agentId).eq("skillId", args.skillId))
+      .first();
+
+    const now = Date.now();
+    if (existing) {
+      await ctx.db.patch(existing._id, {
+        enabled: args.enabled ?? existing.enabled,
+        proficiency: args.proficiency ?? existing.proficiency,
+        config: args.config ?? existing.config,
+        updatedAt: now,
+      });
+      return { bindingId: existing.bindingId, updated: true };
+    }
+
+    const bindingId = makeId("as");
+    await ctx.db.insert("agentSkills", {
+      bindingId,
+      agentId: args.agentId,
+      skillId: args.skillId,
+      enabled: args.enabled ?? true,
+      proficiency: args.proficiency,
+      config: args.config,
+      assignedAt: now,
+      updatedAt: now,
+    });
+
+    return { bindingId, created: true };
+  },
+});
+
+export const toggleAgentSkill = mutation({
+  args: {
+    agentId: v.string(),
+    skillId: v.string(),
+    enabled: v.boolean(),
+  },
+  handler: async (ctx, { agentId, skillId, enabled }) => {
+    const binding = await ctx.db
+      .query("agentSkills")
+      .withIndex("by_agent_skill", (q: any) => q.eq("agentId", agentId).eq("skillId", skillId))
+      .first();
+    if (!binding) throw new Error(`Binding not found (${agentId}, ${skillId})`);
+
+    await ctx.db.patch(binding._id, {
+      enabled,
+      updatedAt: Date.now(),
+    });
+
+    return { bindingId: binding.bindingId, enabled };
+  },
+});
+
+export const buildPromptForTask = query({
+  args: {
+    taskId: v.string(),
+    agentId: v.optional(v.string()),
+    contextLimit: v.optional(v.number()),
+  },
+  handler: async (ctx, { taskId, agentId, contextLimit }) => {
+    const task = await ctx.db
+      .query("tasks")
+      .withIndex("by_taskId", (q: any) => q.eq("taskId", taskId))
+      .first();
+    if (!task) throw new Error(`Task ${taskId} not found`);
+
+    const targetAgent = agentId ?? task.agent;
+    const bindings = await ctx.db
+      .query("agentSkills")
+      .withIndex("by_agentId", (q: any) => q.eq("agentId", targetAgent))
+      .collect();
+
+    const enabledBindings = bindings.filter((binding) => binding.enabled);
+    const skills = [] as any[];
+    for (const binding of enabledBindings) {
+      const skill = await getSkillById(ctx, binding.skillId);
+      if (!skill || skill.status !== "active") continue;
+      skills.push({ skill, binding });
+    }
+
+    const curatedContext = await ctx.db
+      .query("contextEntries")
+      .withIndex("by_tier", (q: any) => q.eq("tier", "curated"))
+      .collect();
+
+    const relatedContext = curatedContext
+      .filter((entry) => !entry.taskId || entry.taskId === taskId)
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .slice(0, contextLimit ?? 5);
+
+    const header = [
+      `Task ${task.taskId} (${task.priority})`,
+      task.title,
+      "",
+      task.description,
+    ].join("\n");
+
+    const contextSection = relatedContext.length
+      ? [
+          "Relevant curated context:",
+          ...relatedContext.map((entry, index) => `${index + 1}. ${entry.summary ?? entry.content}`),
+        ].join("\n")
+      : "Relevant curated context:\n- none";
+
+    const skillsSection = skills.length
+      ? [
+          "Enabled skills:",
+          ...skills.map(({ skill }) => `- ${skill.skillId}: ${skill.promptTemplate}`),
+        ].join("\n")
+      : "Enabled skills:\n- none";
+
+    const prompt = [
+      header,
+      "",
+      contextSection,
+      "",
+      skillsSection,
+      "",
+      "Execution contract:",
+      "- Respect task dependencies and acceptance criteria.",
+      "- Report blockers explicitly.",
+      "- If code changes are made, include commit traceability.",
+    ].join("\n");
+
+    return {
+      taskId,
+      agentId: targetAgent,
+      skillCount: skills.length,
+      contextCount: relatedContext.length,
+      prompt,
+      skills: skills.map(({ skill, binding }) => ({
+        skillId: skill.skillId,
+        version: skill.version,
+        enabled: binding.enabled,
+      })),
+    };
+  },
+});