@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/server/agents/delivery/tools/bulk_create_tasks/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { ListPlus } from "lucide-react";
+import type { bulkCreateTasks } from "./tool.server";
+
+export const bulkCreateTasksToolClient = defineToolClient<typeof bulkCreateTasks>({
+  toolName: "bulk_create_tasks",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Taken aanmaken"
+      icon={<ListPlus className="size-3.5" />}
+      labels={{
+        input: "Takenplan",
+        output: "Aangemaakte taken",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/delivery/tools/bulk_create_tasks/tool.server.ts

@@ -0,0 +1,137 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { convertMarkdownToEditorContent } from "@tulip-systems/editor";
+import { desc, eq } from "drizzle-orm";
+import z from "zod";
+import { initiatives } from "@/app/admin/initiatives/_lib/schema";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { extractTaskCodeSQL, generateTaskCode } from "@/app/admin/tasks/_lib/helpers";
+import { tasks } from "@/app/admin/tasks/_lib/schema";
+import { taskStatusSchema } from "@/app/admin/tasks/_lib/validators";
+import { db } from "@/server/db/init";
+
+const taskInputSchema = z.object({
+  title: z.string().trim().min(1),
+  description: z.string().trim().min(1).optional(),
+  status: taskStatusSchema.default("backlog"),
+  priority: z.number().int().min(1).max(5).default(3),
+  storyPoints: z.number().int().min(1).max(21).optional(),
+});
+
+export const bulkCreateTasks = defineTool({
+  name: "bulk_create_tasks",
+  title: "Bulk Create Tasks",
+  description:
+    "Create multiple delivery tasks for a project initiative. Use only after the user approves the task plan.",
+  inputSchema: z.object({
+    projectId: z.string().uuid(),
+    initiativeId: z.string().uuid(),
+    tasks: z.array(taskInputSchema).min(1).max(20),
+  }),
+  outputSchema: z.object({
+    tasks: z.array(
+      z.object({
+        id: z.string(),
+        code: z.string(),
+        title: z.string(),
+        status: z.string(),
+        priority: z.number(),
+        storyPoints: z.number().nullable(),
+        projectId: z.string(),
+        initiativeId: z.string(),
+      }),
+    ),
+  }),
+  async execute(input) {
+    const [[project], [initiative]] = await Promise.all([
+      db
+        .select({ id: projects.id, key: projects.key })
+        .from(projects)
+        .where(eq(projects.id, input.projectId)),
+      db
+        .select({ id: initiatives.id, projectId: initiatives.projectId })
+        .from(initiatives)
+        .where(eq(initiatives.id, input.initiativeId)),
+    ]);
+
+    if (!project) {
+      throw new ORPCError("NOT_FOUND", { message: "Project niet gevonden" });
+    }
+    if (!initiative) {
+      throw new ORPCError("NOT_FOUND", { message: "Initiatief niet gevonden" });
+    }
+    if (initiative.projectId !== input.projectId) {
+      throw new ORPCError("BAD_REQUEST", {
+        message: "Initiatief hoort niet bij dit project",
+      });
+    }
+
+    const [[lastTask], [lastCode]] = await Promise.all([
+      db
+        .select({ index: tasks.index })
+        .from(tasks)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(tasks.index))
+        .limit(1),
+      db
+        .select({ lastNumber: extractTaskCodeSQL(tasks.code) })
+        .from(tasks)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(desc(extractTaskCodeSQL(tasks.code)))
+        .limit(1),
+    ]);
+
+    const startIndex = (lastTask?.index ?? 0) + 1;
+    const lastNumber = lastCode?.lastNumber ?? 0;
+    const values = input.tasks.map((task, index) => ({
+      projectId: input.projectId,
+      initiativeId: input.initiativeId,
+      title: task.title,
+      description: task.description ? convertMarkdownToEditorContent(task.description) : undefined,
+      status: task.status,
+      priority: task.priority,
+      storyPoints: task.storyPoints,
+      code: generateTaskCode(project.key, lastNumber + index),
+      index: startIndex + index,
+    }));
+
+    const createdTasks = await db.insert(tasks).values(values).returning({
+      id: tasks.id,
+      code: tasks.code,
+      title: tasks.title,
+      status: tasks.status,
+      priority: tasks.priority,
+      storyPoints: tasks.storyPoints,
+      projectId: tasks.projectId,
+      initiativeId: tasks.initiativeId,
+    });
+
+    if (createdTasks.length === 0) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Taken konden niet worden aangemaakt",
+      });
+    }
+
+    return { tasks: createdTasks };
+  },
+});
+
+export const bulkCreateTasksTool = resolveAgentTool(bulkCreateTasks, {
+  permissions: ["task:create"],
+  confirmation: {
+    required: true,
+    title: "Create tasks?",
+    description: "Review the generated task plan before creating tasks.",
+  },
+  audit: {
+    action: "task.bulk_create",
+    resource: "task",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create tasks",
+    icon: "list-plus",
+  },
+});

package/dist/templates/code/src/server/agents/delivery/tools/create_initiative/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { Milestone } from "lucide-react";
+import type { createInitiative } from "./tool.server";
+
+export const createInitiativeToolClient = defineToolClient<typeof createInitiative>({
+  toolName: "create_initiative",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Initiatief aanmaken"
+      icon={<Milestone className="size-3.5" />}
+      labels={{
+        input: "Initiatiefgegevens",
+        output: "Aangemaakt initiatief",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/delivery/tools/create_initiative/tool.server.ts

@@ -0,0 +1,97 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { eq } from "drizzle-orm";
+import z from "zod";
+import { initiatives } from "@/app/admin/initiatives/_lib/schema";
+import { initiativeStatusSchema } from "@/app/admin/initiatives/_lib/validators";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { db } from "@/server/db/init";
+
+const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD.");
+
+export const createInitiative = defineTool({
+  name: "create_initiative",
+  title: "Create Initiative",
+  description:
+    "Create a project initiative or delivery phase. Use only after the user approves initiative creation.",
+  inputSchema: z.object({
+    projectId: z.string().uuid(),
+    title: z.string().trim().min(1),
+    status: initiativeStatusSchema.default("planned"),
+    budget: z
+      .string()
+      .regex(/^\d+(\.\d{1,2})?$/)
+      .optional(),
+    startDate: dateSchema.optional(),
+    deadline: dateSchema.optional(),
+  }),
+  outputSchema: z.object({
+    initiative: z.object({
+      id: z.string(),
+      projectId: z.string(),
+      title: z.string(),
+      status: z.string(),
+      budget: z.string().nullable(),
+      startDate: z.string().nullable(),
+      deadline: z.string().nullable(),
+    }),
+  }),
+  async execute(input) {
+    const [project] = await db
+      .select({ id: projects.id })
+      .from(projects)
+      .where(eq(projects.id, input.projectId));
+
+    if (!project) {
+      throw new ORPCError("NOT_FOUND", { message: "Project niet gevonden" });
+    }
+
+    const [initiative] = await db
+      .insert(initiatives)
+      .values({
+        projectId: input.projectId,
+        title: input.title,
+        status: input.status,
+        budget: input.budget,
+        startDate: input.startDate,
+        deadline: input.deadline,
+      })
+      .returning({
+        id: initiatives.id,
+        projectId: initiatives.projectId,
+        title: initiatives.title,
+        status: initiatives.status,
+        budget: initiatives.budget,
+        startDate: initiatives.startDate,
+        deadline: initiatives.deadline,
+      });
+
+    if (!initiative) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Initiatief kon niet worden aangemaakt",
+      });
+    }
+
+    return { initiative };
+  },
+});
+
+export const createInitiativeTool = resolveAgentTool(createInitiative, {
+  permissions: ["initiative:create"],
+  confirmation: {
+    required: true,
+    title: "Create initiative?",
+    description: "Review the project and initiative title before creating a delivery phase.",
+  },
+  audit: {
+    action: "initiative.create",
+    resource: "initiative",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create initiative",
+    icon: "milestone",
+  },
+});

package/dist/templates/code/src/server/agents/delivery/tools/create_project/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { FolderPlus } from "lucide-react";
+import type { createProject } from "./tool.server";
+
+export const createProjectToolClient = defineToolClient<typeof createProject>({
+  toolName: "create_project",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Project aanmaken"
+      icon={<FolderPlus className="size-3.5" />}
+      labels={{
+        input: "Projectgegevens",
+        output: "Aangemaakt project",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/delivery/tools/create_project/tool.server.ts

@@ -0,0 +1,90 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { convertMarkdownToEditorContent } from "@tulip-systems/editor";
+import { eq } from "drizzle-orm";
+import z from "zod";
+import { customers } from "@/app/admin/customers/_lib/schema";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { projectKeySchema, projectStatusSchema } from "@/app/admin/projects/_lib/validators";
+import { db } from "@/server/db/init";
+
+const projectOutputSchema = z.object({
+  id: z.string(),
+  key: z.string(),
+  title: z.string(),
+  status: z.string(),
+  customerId: z.string(),
+});
+
+export const createProject = defineTool({
+  name: "create_project",
+  title: "Create Project",
+  description:
+    "Create a new delivery project for an existing customer. Use only after the user approves project creation.",
+  inputSchema: z.object({
+    customerId: z.string().uuid(),
+    key: projectKeySchema.describe("Short uppercase project key, for example ACME or ACME-APP."),
+    title: z.string().trim().min(1),
+    status: projectStatusSchema.default("planned"),
+    notes: z.string().trim().min(1).optional().describe("Optional markdown project notes."),
+  }),
+  outputSchema: z.object({ project: projectOutputSchema }),
+  async execute(input) {
+    const [[customer], [existingProject]] = await Promise.all([
+      db.select({ id: customers.id }).from(customers).where(eq(customers.id, input.customerId)),
+      db.select({ id: projects.id }).from(projects).where(eq(projects.key, input.key)),
+    ]);
+
+    if (!customer) {
+      throw new ORPCError("NOT_FOUND", { message: "Klant niet gevonden" });
+    }
+    if (existingProject) {
+      throw new ORPCError("CONFLICT", { message: "Project key bestaat al" });
+    }
+
+    const [project] = await db
+      .insert(projects)
+      .values({
+        customerId: input.customerId,
+        key: input.key,
+        title: input.title,
+        status: input.status,
+        notes: input.notes ? convertMarkdownToEditorContent(input.notes) : undefined,
+      })
+      .returning({
+        id: projects.id,
+        key: projects.key,
+        title: projects.title,
+        status: projects.status,
+        customerId: projects.customerId,
+      });
+
+    if (!project) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", {
+        message: "Project kon niet worden aangemaakt",
+      });
+    }
+
+    return { project };
+  },
+});
+
+export const createProjectTool = resolveAgentTool(createProject, {
+  permissions: ["project:create"],
+  confirmation: {
+    required: true,
+    title: "Create project?",
+    description: "Review the customer, project key, and title before creating a project.",
+  },
+  audit: {
+    action: "project.create",
+    resource: "project",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create project",
+    icon: "folder-plus",
+  },
+});

package/dist/templates/code/src/server/agents/delivery/tools/get_project_context/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { FolderKanban } from "lucide-react";
+import type { getProjectContext } from "./tool.server";
+
+export const getProjectContextToolClient = defineToolClient<typeof getProjectContext>({
+  toolName: "get_project_context",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Projectcontext ophalen"
+      icon={<FolderKanban className="size-3.5" />}
+      labels={{
+        input: "Project",
+        output: "Context",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/delivery/tools/get_project_context/tool.server.ts

@@ -0,0 +1,107 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { asc, eq } from "drizzle-orm";
+import z from "zod";
+import { customers } from "@/app/admin/customers/_lib/schema";
+import { initiatives } from "@/app/admin/initiatives/_lib/schema";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { tasks } from "@/app/admin/tasks/_lib/schema";
+import { db } from "@/server/db/init";
+
+export const getProjectContext = defineTool({
+  name: "get_project_context",
+  title: "Get Project Context",
+  description: "Get a compact project summary with customer, initiatives, and recent tasks.",
+  inputSchema: z.object({
+    projectId: z.string().uuid(),
+    taskLimit: z.number().int().min(1).max(30).default(15),
+  }),
+  outputSchema: z.object({
+    project: z.object({
+      id: z.string(),
+      key: z.string(),
+      title: z.string(),
+      status: z.string(),
+      customerId: z.string(),
+      customerName: z.string(),
+    }),
+    initiatives: z.array(
+      z.object({
+        id: z.string(),
+        title: z.string(),
+        status: z.string(),
+        deadline: z.string().nullable(),
+      }),
+    ),
+    tasks: z.array(
+      z.object({
+        id: z.string(),
+        code: z.string(),
+        title: z.string(),
+        status: z.string(),
+        storyPoints: z.number().nullable(),
+        initiativeId: z.string(),
+      }),
+    ),
+  }),
+  async execute(input) {
+    const [project] = await db
+      .select({
+        id: projects.id,
+        key: projects.key,
+        title: projects.title,
+        status: projects.status,
+        customerId: customers.id,
+        customerName: customers.name,
+      })
+      .from(projects)
+      .innerJoin(customers, eq(projects.customerId, customers.id))
+      .where(eq(projects.id, input.projectId));
+
+    if (!project) {
+      throw new ORPCError("NOT_FOUND", { message: "Project niet gevonden" });
+    }
+
+    const [initiativeRows, taskRows] = await Promise.all([
+      db
+        .select({
+          id: initiatives.id,
+          title: initiatives.title,
+          status: initiatives.status,
+          deadline: initiatives.deadline,
+        })
+        .from(initiatives)
+        .where(eq(initiatives.projectId, input.projectId))
+        .orderBy(asc(initiatives.status), asc(initiatives.title)),
+      db
+        .select({
+          id: tasks.id,
+          code: tasks.code,
+          title: tasks.title,
+          status: tasks.status,
+          storyPoints: tasks.storyPoints,
+          initiativeId: tasks.initiativeId,
+        })
+        .from(tasks)
+        .where(eq(tasks.projectId, input.projectId))
+        .orderBy(asc(tasks.status), asc(tasks.index))
+        .limit(input.taskLimit),
+    ]);
+
+    return {
+      project,
+      initiatives: initiativeRows,
+      tasks: taskRows,
+    };
+  },
+});
+
+export const getProjectContextTool = resolveAgentTool(getProjectContext, {
+  permissions: ["project:view", "initiative:view", "task:view"],
+  ui: {
+    label: "Get project context",
+    icon: "folder-kanban",
+  },
+});

package/dist/templates/code/src/server/agents/delivery/tools/search_delivery_records/tool.client.tsx

@@ -0,0 +1,22 @@
+"use client";
+
+import { ToolCallCard } from "@tulip-systems/ai/chat/client";
+import { defineToolClient } from "@tulip-systems/ai/tools/client";
+import { Search } from "lucide-react";
+import type { searchDeliveryRecords } from "./tool.server";
+
+export const searchDeliveryRecordsToolClient = defineToolClient<typeof searchDeliveryRecords>({
+  toolName: "search_delivery_records",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Delivery records zoeken"
+      icon={<Search className="size-3.5" />}
+      labels={{
+        input: "Zoekopdracht",
+        output: "Gevonden records",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});