@lakitu/sdk 0.1.0

package/convex/cloud/workflows/compileSandbox.ts

@@ -0,0 +1,146 @@
+/**
+ * Sandbox Compiler
+ * 
+ * Manages compilation manifest for sandbox definitions.
+ */
+
+import { v } from "convex/values";
+import { query, internalMutation } from "../_generated/server";
+
+// ============================================
+// Manifest Management
+// ============================================
+
+/** Save compilation manifest */
+export const saveManifest = internalMutation({
+  args: {
+    version: v.string(),
+    manifest: v.array(v.object({
+      type: v.string(),
+      name: v.string(),
+      path: v.string(),
+    })),
+  },
+  handler: async (ctx, args) => {
+    // Clear old entries for this version
+    const existing = await ctx.db
+      .query("compiledSandbox")
+      .withIndex("by_version", (q) => q.eq("version", args.version))
+      .collect();
+    
+    for (const entry of existing) {
+      await ctx.db.delete(entry._id);
+    }
+    
+    // Insert new entries
+    for (const item of args.manifest) {
+      await ctx.db.insert("compiledSandbox", {
+        version: args.version,
+        type: item.type as "tool" | "skill" | "agent" | "service",
+        name: item.name,
+        r2Key: item.path,
+        contentHash: "",
+        createdAt: Date.now(),
+      });
+    }
+    
+    return { saved: args.manifest.length };
+  },
+});
+
+/** Get the latest compiled manifest */
+export const getManifest = query({
+  args: {
+    version: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    if (args.version) {
+      return await ctx.db
+        .query("compiledSandbox")
+        .withIndex("by_version", (q) => q.eq("version", args.version!))
+        .collect();
+    }
+    
+    // Get latest version
+    const latest = await ctx.db
+      .query("compiledSandbox")
+      .order("desc")
+      .first();
+    
+    if (!latest) return [];
+    
+    return await ctx.db
+      .query("compiledSandbox")
+      .withIndex("by_version", (q) => q.eq("version", latest.version))
+      .collect();
+  },
+});
+
+/** Get manifest version info */
+export const getLatestVersion = query({
+  args: {},
+  handler: async (ctx) => {
+    const latest = await ctx.db
+      .query("compiledSandbox")
+      .order("desc")
+      .first();
+    
+    return latest?.version ?? null;
+  },
+});
+
+// ============================================
+// Custom Tools Queries
+// ============================================
+
+/** List custom tools (for compilation) */
+export const listCustomTools = query({
+  args: {},
+  handler: async (ctx) => {
+    return await ctx.db
+      .query("customTools")
+      .filter((q) => q.eq(q.field("enabled"), true))
+      .collect();
+  },
+});
+
+/** Get tool implementation for a custom tool */
+export const getToolImplementation = query({
+  args: { toolId: v.string() },
+  handler: async (ctx, args) => {
+    const tool = await ctx.db
+      .query("customTools")
+      .withIndex("by_toolId", (q) => q.eq("toolId", args.toolId))
+      .first();
+    
+    return tool?.implementation || null;
+  },
+});
+
+// ============================================
+// Built-in Metadata Queries (deprecated - metadata now in Lakitu)
+// ============================================
+
+/** Get all built-in tool metadata */
+export const getBuiltInTools = query({
+  args: {},
+  handler: async () => [],
+});
+
+/** Get all built-in skill metadata */
+export const getBuiltInSkills = query({
+  args: {},
+  handler: async () => [],
+});
+
+/** Get all built-in deliverable metadata */
+export const getBuiltInDeliverables = query({
+  args: {},
+  handler: async () => [],
+});
+
+/** Get all agent definitions */
+export const getAgents = query({
+  args: {},
+  handler: async () => [],
+});

package/convex/cloud/workflows/crudBoard.ts

@@ -0,0 +1,217 @@
+/**
+ * Board Planning Workflow - AI-assisted board creation
+ * 
+ * Spawns an agent with board-manager skill to generate a plan,
+ * then executes the plan on user approval.
+ */
+
+import { v } from "convex/values";
+import { action, mutation, query, internalAction } from "../_generated/server";
+import { api, internal } from "../_generated/api";
+
+// ============================================
+// Schema
+// ============================================
+
+const boardPlanSchema = v.object({
+  title: v.string(),
+  description: v.string(),
+  stages: v.array(v.object({
+    name: v.string(),
+    type: v.union(v.literal("agent"), v.literal("human")),
+    description: v.string(),
+    skillId: v.optional(v.string()),
+    order: v.number(),
+  })),
+});
+
+// ============================================
+// Generate Plan - Spawns agent to create plan
+// ============================================
+
+export const generatePlan = action({
+  args: {
+    workspaceId: v.string(),
+    userPrompt: v.string(),
+    useOpenCode: v.optional(v.boolean()), // Feature flag for new OpenCode sandbox
+  },
+  handler: async (ctx, args) => {
+    // Use OpenCode by default for board planning (more reliable)
+    const useOpenCode = args.useOpenCode !== false;
+    
+    // Build prompt - OpenCode uses built-in file editing
+    const prompt = useOpenCode
+      ? `Create a workflow board for: ${args.userPrompt}
+
+Write a JSON file to /home/user/workspace/board_plan.json with this structure:
+{
+  "title": "Board name",
+  "description": "What this workflow accomplishes", 
+  "stages": [
+    {"name": "Stage Name", "type": "agent" or "human", "description": "What happens", "order": 0}
+  ]
+}
+
+Rules:
+- Create 3-6 stages
+- First stage: usually "human" (user provides input)
+- Middle stages: "agent" (AI automated tasks)
+- Last stage: "human" (review) or "agent" (deliver result)`
+      : args.userPrompt;
+
+    const systemPrompt = useOpenCode ? undefined : `You are CodeMode. Create workflow boards.
+
+## Rules
+- Create 3-6 stages
+- First stage: usually "human" (user input)
+- Middle: "agent" stages with relevant skills  
+- Last: "human" (review) or "agent" (deliver)
+
+Output a JSON plan with title, description, and stages array.`;
+
+    try {
+      // Start Lakitu sandbox session
+      const result = await ctx.runAction(api.workflows.sandboxConvex.startSession, {
+        projectId: args.workspaceId,
+        prompt,
+        config: {
+          model: "anthropic/claude-3.5-haiku",
+          purpose: "board-planning",
+        },
+      });
+
+      if (!result.success) {
+        return { success: false, error: result.error || "Failed to start session" };
+      }
+
+      const sessionId = result.sessionId;
+
+      // Wait for completion (poll session status)
+      let session: any = null;
+      for (let i = 0; i < 120; i++) { // 2 min max for planning
+        await new Promise(r => setTimeout(r, 1000));
+        session = await ctx.runQuery(api.workflows.sandboxConvex.getSession, { sessionId });
+
+        if (session?.status === "completed" || session?.status === "failed") {
+          break;
+        }
+      }
+
+      if (!session || session.status !== "completed") {
+        return { success: false, sessionId, error: "Timeout or session failed" };
+      }
+
+      const output = session.output as any;
+
+      // Try to parse plan from response
+      const response = output?.response || "";
+      if (response) {
+        const jsonMatch = response.match(/\{[\s\S]*"title"[\s\S]*"stages"[\s\S]*\}/);
+        if (jsonMatch) {
+          try {
+            const plan = JSON.parse(jsonMatch[0]);
+            if (plan.title && plan.stages) {
+              return { success: true, sessionId, plan };
+            }
+          } catch {}
+        }
+      }
+
+      // Try to find plan in tool call results
+      const toolCalls = output?.toolCalls || [];
+      for (const tc of toolCalls) {
+        if (tc.result && typeof tc.result === "string") {
+          const jsonMatch = tc.result.match(/\{[\s\S]*"title"[\s\S]*"stages"[\s\S]*\}/);
+          if (jsonMatch) {
+            try {
+              const plan = JSON.parse(jsonMatch[0]);
+              if (plan.title && plan.stages) {
+                return { success: true, sessionId, plan };
+              }
+            } catch {}
+          }
+        }
+      }
+
+      return {
+        success: false,
+        sessionId,
+        error: "Agent did not generate a structured plan. Please try again.",
+        debug: { response: response?.substring(0, 500), toolCalls: toolCalls?.length },
+      };
+    } catch (error: any) {
+      console.error("[generatePlan] Error:", error);
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  },
+});
+
+// ============================================
+// Execute Plan - Creates board from approved plan
+// ============================================
+
+export const executePlan = action({
+  args: {
+    workspaceId: v.string(),
+    plan: boardPlanSchema,
+  },
+  handler: async (ctx, args) => {
+    const { workspaceId, plan } = args;
+
+    try {
+      // Create board
+      const boardId = await ctx.runMutation(api.features.kanban.boards.create, {
+        workspaceId,
+        name: plan.title,
+        description: plan.description,
+      });
+
+      // Create tasks for each stage
+      const taskIds: string[] = [];
+      for (const stage of plan.stages) {
+        const taskId = await ctx.runMutation(api.features.kanban.boards.addTask, {
+          boardId,
+          name: stage.name,
+          description: stage.description,
+          stageType: stage.type,
+          skillId: stage.skillId,
+          order: stage.order,
+        });
+        taskIds.push(taskId);
+      }
+
+      return {
+        success: true,
+        boardId,
+        taskIds,
+      };
+    } catch (error: any) {
+      return {
+        success: false,
+        error: error.message,
+      };
+    }
+  },
+});
+
+// ============================================
+// Stream-based generation (for real-time UI)
+// ============================================
+
+export const streamGeneratePlan = internalAction({
+  args: {
+    workspaceId: v.string(),
+    userPrompt: v.string(),
+    planSessionId: v.string(), // For streaming updates
+  },
+  handler: async (ctx, args) => {
+    // This allows streaming updates to the UI via the session
+    return ctx.runAction(internal.workflows.create.board.generatePlan, {
+      workspaceId: args.workspaceId,
+      userPrompt: args.userPrompt,
+    });
+  },
+});

package/convex/cloud/workflows/crudKSAs.ts

@@ -0,0 +1,262 @@
+/**
+ * KSA CRUD Operations
+ *
+ * Provides queries for the KSA registry to the frontend.
+ * KSAs are defined in ksaPolicy.ts - this just exposes them.
+ */
+
+import { query } from "../_generated/server";
+import { v } from "convex/values";
+import {
+  KSA_REGISTRY,
+  CONFIG_SCHEMAS,
+  CONFIG_DEFAULTS,
+  CORE_KSAS,
+  CATEGORY_LABELS,
+  CATEGORY_DESCRIPTIONS,
+  GROUP_LABELS,
+  GROUP_DESCRIPTIONS,
+  GROUP_ICONS,
+  GROUP_ORDER,
+  getKSA,
+  getKSAsByCategory,
+  getKSAsByGroup,
+  getSkillsByGroup,
+  getKSAsByNames,
+  getDefaultKSAs,
+  getConfigSchema,
+  getConfigDefaults,
+  mergeWithDefaults,
+  searchKSAs,
+  type KSAInfo,
+  type KSACategory,
+  type KSAGroup,
+  type ConfigField,
+} from "../ksaPolicy";
+
+/**
+ * List all available KSAs.
+ */
+export const list = query({
+  args: {
+    category: v.optional(v.union(v.literal("core"), v.literal("skills"), v.literal("deliverables"))),
+  },
+  handler: async (_ctx, args): Promise<KSAInfo[]> => {
+    if (args.category) {
+      return getKSAsByCategory(args.category);
+    }
+    return KSA_REGISTRY;
+  },
+});
+
+/**
+ * Get a single KSA by name.
+ */
+export const get = query({
+  args: { name: v.string() },
+  handler: async (_ctx, args): Promise<KSAInfo | null> => {
+    return getKSA(args.name) || null;
+  },
+});
+
+/**
+ * Get multiple KSAs by names.
+ */
+export const getByNames = query({
+  args: { names: v.array(v.string()) },
+  handler: async (_ctx, args): Promise<KSAInfo[]> => {
+    return getKSAsByNames(args.names);
+  },
+});
+
+/**
+ * Get KSAs grouped by category.
+ */
+export const listGrouped = query({
+  args: {},
+  handler: async (): Promise<{
+    core: KSAInfo[];
+    skills: KSAInfo[];
+    deliverables: KSAInfo[];
+  }> => {
+    return {
+      core: getKSAsByCategory("core"),
+      skills: getKSAsByCategory("skills"),
+      deliverables: getKSAsByCategory("deliverables"),
+    };
+  },
+});
+
+/**
+ * Get category metadata.
+ */
+export const getCategories = query({
+  args: {},
+  handler: async (): Promise<
+    Array<{
+      id: KSACategory;
+      label: string;
+      description: string;
+      ksaCount: number;
+    }>
+  > => {
+    const categories: KSACategory[] = ["core", "skills", "deliverables"];
+    return categories.map((id) => ({
+      id,
+      label: CATEGORY_LABELS[id],
+      description: CATEGORY_DESCRIPTIONS[id],
+      ksaCount: getKSAsByCategory(id).length,
+    }));
+  },
+});
+
+/**
+ * Get the names of core KSAs (always available).
+ */
+export const getCoreKSANames = query({
+  args: {},
+  handler: async (): Promise<string[]> => {
+    return CORE_KSAS;
+  },
+});
+
+/**
+ * Get a default set of KSAs for a given purpose.
+ */
+export const getDefaultKSASet = query({
+  args: {
+    purpose: v.union(
+      v.literal("research"),
+      v.literal("content"),
+      v.literal("automation"),
+      v.literal("minimal"),
+      v.literal("all")
+    ),
+  },
+  handler: async (_ctx, args): Promise<string[]> => {
+    return getDefaultKSAs(args.purpose);
+  },
+});
+
+// ============================================================================
+// Config Schema Queries
+// ============================================================================
+
+/**
+ * Get config schema for a KSA.
+ */
+export const getKSAConfigSchema = query({
+  args: { name: v.string() },
+  handler: async (_ctx, args): Promise<Record<string, ConfigField> | null> => {
+    return getConfigSchema(args.name) || null;
+  },
+});
+
+/**
+ * Get default config for a KSA.
+ */
+export const getKSADefaults = query({
+  args: { name: v.string() },
+  handler: async (_ctx, args): Promise<Record<string, unknown> | null> => {
+    return getConfigDefaults(args.name) || null;
+  },
+});
+
+/**
+ * Get all config schemas.
+ */
+export const getAllConfigSchemas = query({
+  args: {},
+  handler: async (): Promise<Record<string, Record<string, ConfigField>>> => {
+    return CONFIG_SCHEMAS;
+  },
+});
+
+/**
+ * Merge user config with defaults for a KSA.
+ */
+export const getMergedConfig = query({
+  args: {
+    name: v.string(),
+    userConfig: v.any(),
+  },
+  handler: async (_ctx, args): Promise<Record<string, unknown>> => {
+    return mergeWithDefaults(args.name, args.userConfig || {});
+  },
+});
+
+// ============================================================================
+// Search
+// ============================================================================
+
+/**
+ * Search KSAs by keyword.
+ */
+export const search = query({
+  args: { keyword: v.string() },
+  handler: async (_ctx, args): Promise<KSAInfo[]> => {
+    return searchKSAs(args.keyword);
+  },
+});
+
+/**
+ * Get KSAs grouped for the library panel.
+ */
+export const listForLibrary = query({
+  args: {},
+  handler: async (): Promise<{
+    byCategory: {
+      core: KSAInfo[];
+      skills: KSAInfo[];
+      deliverables: KSAInfo[];
+    };
+    skillsByGroup: Record<KSAGroup, KSAInfo[]>;
+    groupOrder: KSAGroup[];
+  }> => {
+    return {
+      byCategory: {
+        core: getKSAsByCategory("core"),
+        skills: getKSAsByCategory("skills"),
+        deliverables: getKSAsByCategory("deliverables"),
+      },
+      skillsByGroup: getSkillsByGroup(),
+      groupOrder: GROUP_ORDER,
+    };
+  },
+});
+
+/**
+ * Get group metadata for skills subcategories.
+ */
+export const getGroups = query({
+  args: {},
+  handler: async (): Promise<
+    Array<{
+      id: KSAGroup;
+      label: string;
+      description: string;
+      icon: string;
+      ksaCount: number;
+    }>
+  > => {
+    return GROUP_ORDER.map((id) => ({
+      id,
+      label: GROUP_LABELS[id],
+      description: GROUP_DESCRIPTIONS[id],
+      icon: GROUP_ICONS[id],
+      ksaCount: getKSAsByGroup(id).length,
+    }));
+  },
+});
+
+/**
+ * Get KSAs by group.
+ */
+export const listByGroup = query({
+  args: {
+    group: v.literal("research"),
+  },
+  handler: async (_ctx, args): Promise<KSAInfo[]> => {
+    return getKSAsByGroup(args.group);
+  },
+});