@tulip-systems/create-app 0.11.1

package/dist/templates/code/src/server/agents/operations/instructions.ts

@@ -0,0 +1,99 @@
+export const instructions = `# Operations Agent
+
+Je bent de operations- en delivery analytics-specialist voor de Tulip admin workspace. Je helpt met tijdsbesteding, projectbelasting, initiatiefgezondheid, effort-vs-scope, bottlenecks en operationele samenvattingen.
+
+Je belangrijkste doel is om meetbare werkdata om te zetten naar praktische inzichten zonder cijfers te verzinnen of causale conclusies te trekken die niet uit de data volgen.
+
+## Kernprincipes
+
+- Gebruik tools voor alle numerieke claims over uren, tijd, story points, voortgang en workload.
+- Benoem altijd de periode waarop tijdsanalyses betrekking hebben.
+- Maak onderscheid tussen gemeten feiten, interpretaties en aannames.
+- Geef compacte inzichten en concrete vervolgstappen.
+- Stel maximaal één gerichte verduidelijkingsvraag wanneer de periode, klant, project of initiatief essentieel maar onduidelijk is.
+- Voer geen mutaties uit. Deze agent analyseert alleen.
+- Gebruik Nederlands tenzij de gebruiker of hoofdassistent in een andere taal werkt.
+
+## Beschikbare Tools
+
+### \`search_delivery_records\`
+
+Gebruik deze tool om klanten, projecten, initiatieven of taken te vinden wanneer de gebruiker een naam, project key of omschrijving noemt.
+
+### \`get_project_context\`
+
+Gebruik deze tool wanneer projectcontext nodig is om tijd of voortgang juist te interpreteren.
+
+### \`summarize_time_entries\`
+
+Gebruik deze tool voor tijdsanalyses per klant, project, medewerker, taak of datum.
+
+Gebruik deze tool wanneer de gebruiker vraagt naar:
+
+- meeste tijd
+- uren per klant/project/medewerker/taak
+- workload of focus
+- tijdsbesteding deze week/maand/periode
+- operationele samenvatting op basis van tijdregistratie
+
+### \`get_initiative_health\`
+
+Gebruik deze tool voor initiatiefgezondheid, voortgang, story points, effort, top taken op uren en effort-vs-story-points.
+
+Gebruik deze tool wanneer de gebruiker vraagt naar:
+
+- initiatiefstatus of gezondheid
+- delivery risico's binnen een initiatief
+- voortgang op basis van story points
+- taken die veel tijd kosten
+- effort-vs-scope analyse
+
+## Analyse Workflow
+
+- Bepaal eerst wat de gebruiker wil meten: tijd, voortgang, workload, risico of samenvatting.
+- Bepaal de relevante scope: periode, klant, project, initiatief, medewerker of taak.
+- Zoek records met \`search_delivery_records\` wanneer de scope niet eenduidig is.
+- Roep de passende analytics-tool aan.
+- Vat de belangrijkste cijfers samen.
+- Geef interpretatie alleen waar de data dit ondersteunt.
+- Sluit af met één tot drie praktische vervolgstappen.
+
+## Tijdsanalyse Regels
+
+- Vermeld altijd totaaluren naast totalSeconds wanneer je cijfers presenteert.
+- Als de gebruiker geen periode noemt, gebruik de standaardperiode van de tool en benoem die expliciet.
+- Vergelijk groepen eerlijk: noem aantallen entries wanneer nuttig.
+- Wijs op ontbrekende of niet-afgesloten tijdregistraties wanneer relevant, maar verzin geen impact.
+
+## Initiatiefgezondheid Regels
+
+- Beoordeel gezondheid op basis van voortgang, open story points, tijdsbesteding en opvallende taken.
+- Label risico's voorzichtig: \`laag\`, \`gemiddeld\`, \`hoog\` of \`onbekend\`.
+- Een taak met veel uren is niet automatisch een probleem; benoem dat als interpretatie.
+- Als story points ontbreken, baseer voortgang niet op story points zonder dit te melden.
+
+## Antwoordstijl
+
+- Begin met de kernconclusie.
+- Gebruik bullets voor cijfers, inzichten en vervolgstappen.
+- Wees kort, maar geef voldoende context om het inzicht te vertrouwen.
+- Vermijd interne toolnamen in het eindantwoord, tenzij de gebruiker technische details vraagt.
+- Benoem onzekerheid expliciet wanneer data ontbreekt of scope ambigu is.
+
+## Antwoordpatronen
+
+Voor tijdsanalyses:
+
+- Periode en scope
+- Totaaluren
+- Topgroepen of verdeling
+- Opvallende observaties
+- Vervolgstap
+
+Voor initiatiefgezondheid:
+
+- Gezondheidsinschatting
+- Voortgang en effort
+- Belangrijkste risico's of bottlenecks
+- Taken die aandacht vragen
+- Vervolgstap`;

package/dist/templates/code/src/server/agents/operations/tools/get_initiative_health/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 { HeartPulse } from "lucide-react";
+import type { getInitiativeHealth } from "./tool.server";
+
+export const getInitiativeHealthToolClient = defineToolClient<typeof getInitiativeHealth>({
+  toolName: "get_initiative_health",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Initiatiefgezondheid analyseren"
+      icon={<HeartPulse className="size-3.5" />}
+      labels={{
+        input: "Initiatief",
+        output: "Gezondheidsanalyse",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/operations/tools/get_initiative_health/tool.server.ts

@@ -0,0 +1,256 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { and, asc, desc, eq, inArray, isNotNull, sql } from "drizzle-orm";
+import z from "zod";
+import { employees } from "@/app/admin/employees/_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 { timeEntries } from "@/app/admin/time/_lib/schema";
+import { db } from "@/server/db/init";
+import { users } from "@/server/db/schema";
+
+const taskStatusValues = ["backlog", "todo", "in_progress", "in_review", "done"] as const;
+
+export const getInitiativeHealth = defineTool({
+  name: "get_initiative_health",
+  title: "Get Initiative Health",
+  description:
+    "Analyze initiative health using story points, logged time, top tasks by hours, and effort-vs-story-points.",
+  inputSchema: z.object({
+    initiativeId: z.string().uuid(),
+    topTaskLimit: z.number().int().min(1).max(10).default(5),
+  }),
+  outputSchema: z.object({
+    initiative: z.object({
+      id: z.string(),
+      title: z.string(),
+      status: z.string(),
+      projectId: z.string(),
+      projectTitle: z.string(),
+      deadline: z.string().nullable(),
+    }),
+    health: z.object({
+      riskLevel: z.enum(["low", "medium", "high", "unknown"]),
+      progressPercent: z.number().nullable(),
+      totalSeconds: z.number(),
+      totalHours: z.number(),
+      totalStoryPoints: z.number(),
+      doneStoryPoints: z.number(),
+      openStoryPoints: z.number(),
+    }),
+    storyPointsByStatus: z.array(z.object({ status: z.string(), totalStoryPoints: z.number() })),
+    hoursByEmployee: z.array(
+      z.object({
+        employeeId: z.string(),
+        employeeName: z.string(),
+        totalSeconds: z.number(),
+        totalHours: z.number(),
+      }),
+    ),
+    topTasksByHours: z.array(
+      z.object({
+        taskId: z.string(),
+        taskCode: z.string(),
+        taskTitle: z.string(),
+        storyPoints: z.number().nullable(),
+        totalSeconds: z.number(),
+        totalHours: z.number(),
+      }),
+    ),
+    effortVsStoryPoints: z.array(
+      z.object({
+        taskId: z.string(),
+        taskCode: z.string(),
+        taskTitle: z.string(),
+        storyPoints: z.number(),
+        totalSeconds: z.number(),
+        totalHours: z.number(),
+        hoursPerStoryPoint: z.number(),
+      }),
+    ),
+  }),
+  async execute(input) {
+    const [initiative] = await db
+      .select({
+        id: initiatives.id,
+        title: initiatives.title,
+        status: initiatives.status,
+        projectId: projects.id,
+        projectTitle: projects.title,
+        deadline: initiatives.deadline,
+      })
+      .from(initiatives)
+      .innerJoin(projects, eq(initiatives.projectId, projects.id))
+      .where(eq(initiatives.id, input.initiativeId));
+
+    if (!initiative) {
+      throw new ORPCError("NOT_FOUND", { message: "Initiatief niet gevonden" });
+    }
+
+    const totalSecondsSql = sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`;
+    const [timeTotals, storyRows, employeeRows, topTaskRows, effortRows] = await Promise.all([
+      db
+        .select({ totalSeconds: totalSecondsSql })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .where(and(eq(tasks.initiativeId, input.initiativeId), isNotNull(timeEntries.end))),
+      db
+        .select({
+          status: tasks.status,
+          totalStoryPoints: sql<number>`coalesce(sum(${tasks.storyPoints}), 0)`,
+        })
+        .from(tasks)
+        .where(
+          and(
+            eq(tasks.initiativeId, input.initiativeId),
+            inArray(tasks.status, [...taskStatusValues]),
+          ),
+        )
+        .groupBy(tasks.status),
+      db
+        .select({
+          employeeId: employees.id,
+          employeeName: users.name,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .innerJoin(employees, eq(timeEntries.employeeId, employees.id))
+        .innerJoin(users, eq(employees.userId, users.id))
+        .where(and(eq(tasks.initiativeId, input.initiativeId), isNotNull(timeEntries.end)))
+        .groupBy(employees.id, users.name)
+        .orderBy(desc(totalSecondsSql), asc(users.name)),
+      db
+        .select({
+          taskId: tasks.id,
+          taskCode: tasks.code,
+          taskTitle: tasks.title,
+          storyPoints: tasks.storyPoints,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(timeEntries)
+        .innerJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .where(and(eq(tasks.initiativeId, input.initiativeId), isNotNull(timeEntries.end)))
+        .groupBy(tasks.id, tasks.code, tasks.title, tasks.storyPoints)
+        .orderBy(desc(totalSecondsSql), asc(tasks.title))
+        .limit(input.topTaskLimit),
+      db
+        .select({
+          taskId: tasks.id,
+          taskCode: tasks.code,
+          taskTitle: tasks.title,
+          storyPoints: tasks.storyPoints,
+          totalSeconds: totalSecondsSql,
+        })
+        .from(tasks)
+        .leftJoin(timeEntries, eq(timeEntries.taskId, tasks.id))
+        .where(
+          and(
+            eq(tasks.initiativeId, input.initiativeId),
+            isNotNull(tasks.storyPoints),
+            isNotNull(timeEntries.end),
+          ),
+        )
+        .groupBy(tasks.id, tasks.code, tasks.title, tasks.storyPoints)
+        .orderBy(desc(totalSecondsSql), asc(tasks.title))
+        .limit(input.topTaskLimit),
+    ]);
+
+    const storyPointsByStatus = taskStatusValues.map((status) => ({
+      status,
+      totalStoryPoints: Number(
+        storyRows.find((row) => row.status === status)?.totalStoryPoints ?? 0,
+      ),
+    }));
+    const totalStoryPoints = storyPointsByStatus.reduce(
+      (total, row) => total + row.totalStoryPoints,
+      0,
+    );
+    const doneStoryPoints =
+      storyPointsByStatus.find((row) => row.status === "done")?.totalStoryPoints ?? 0;
+    const progressPercent =
+      totalStoryPoints > 0 ? Number(((doneStoryPoints / totalStoryPoints) * 100).toFixed(1)) : null;
+    const totalSeconds = Number(timeTotals[0]?.totalSeconds ?? 0);
+
+    return {
+      initiative,
+      health: {
+        riskLevel: getRiskLevel(progressPercent, totalSeconds, totalStoryPoints),
+        progressPercent,
+        totalSeconds,
+        totalHours: secondsToHours(totalSeconds),
+        totalStoryPoints,
+        doneStoryPoints,
+        openStoryPoints: totalStoryPoints - doneStoryPoints,
+      },
+      storyPointsByStatus,
+      hoursByEmployee: employeeRows.map((row) => {
+        const rowSeconds = Number(row.totalSeconds);
+
+        return {
+          employeeId: row.employeeId,
+          employeeName: row.employeeName,
+          totalSeconds: rowSeconds,
+          totalHours: secondsToHours(rowSeconds),
+        };
+      }),
+      topTasksByHours: topTaskRows.map((row) => {
+        const rowSeconds = Number(row.totalSeconds);
+
+        return {
+          ...row,
+          storyPoints: row.storyPoints ?? null,
+          totalSeconds: rowSeconds,
+          totalHours: secondsToHours(rowSeconds),
+        };
+      }),
+      effortVsStoryPoints: effortRows.map((row) => {
+        const rowSeconds = Number(row.totalSeconds);
+        const storyPoints = Number(row.storyPoints);
+
+        return {
+          taskId: row.taskId,
+          taskCode: row.taskCode,
+          taskTitle: row.taskTitle,
+          storyPoints,
+          totalSeconds: rowSeconds,
+          totalHours: secondsToHours(rowSeconds),
+          hoursPerStoryPoint:
+            storyPoints > 0 ? Number((rowSeconds / 3600 / storyPoints).toFixed(2)) : 0,
+        };
+      }),
+    };
+  },
+});
+
+export const getInitiativeHealthTool = resolveAgentTool(getInitiativeHealth, {
+  permissions: ["initiative:view", "time:view", "task:view"],
+  ui: {
+    label: "Get initiative health",
+    icon: "activity",
+  },
+});
+
+function secondsToHours(seconds: number) {
+  return Number((seconds / 3600).toFixed(2));
+}
+
+function getRiskLevel(
+  progressPercent: number | null,
+  totalSeconds: number,
+  totalStoryPoints: number,
+) {
+  if (progressPercent === null || totalStoryPoints === 0) {
+    return "unknown" as const;
+  }
+  if (totalSeconds > 0 && progressPercent < 25) {
+    return "high" as const;
+  }
+  if (progressPercent < 50) {
+    return "medium" as const;
+  }
+  return "low" as const;
+}

package/dist/templates/code/src/server/agents/operations/tools/summarize_time_entries/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 { ChartNoAxesColumn } from "lucide-react";
+import type { summarizeTimeEntries } from "./tool.server";
+
+export const summarizeTimeEntriesToolClient = defineToolClient<typeof summarizeTimeEntries>({
+  toolName: "summarize_time_entries",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Tijdsbesteding samenvatten"
+      icon={<ChartNoAxesColumn className="size-3.5" />}
+      labels={{
+        input: "Analyse",
+        output: "Tijdsamenvatting",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/operations/tools/summarize_time_entries/tool.server.ts

@@ -0,0 +1,195 @@
+import "server-cli-only";
+
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { and, asc, desc, eq, gte, isNotNull, lt, sql } from "drizzle-orm";
+import z from "zod";
+import { customers } from "@/app/admin/customers/_lib/schema";
+import { employees } from "@/app/admin/employees/_lib/schema";
+import { projects } from "@/app/admin/projects/_lib/schema";
+import { tasks } from "@/app/admin/tasks/_lib/schema";
+import { timeEntries } from "@/app/admin/time/_lib/schema";
+import { db } from "@/server/db/init";
+import { users } from "@/server/db/schema";
+
+const dateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Use YYYY-MM-DD.");
+const groupBySchema = z.enum(["customer", "project", "employee", "task", "date"]);
+
+export const summarizeTimeEntries = defineTool({
+  name: "summarize_time_entries",
+  title: "Summarize Time Entries",
+  description:
+    "Summarize completed time entries by customer, project, employee, task, or date for operations analytics.",
+  inputSchema: z.object({
+    groupBy: groupBySchema.default("project"),
+    startDate: dateSchema
+      .optional()
+      .describe("Inclusive period start. Defaults to first day of this month."),
+    endDate: dateSchema.optional().describe("Inclusive period end. Defaults to today."),
+    customerId: z.string().uuid().optional(),
+    projectId: z.string().uuid().optional(),
+    employeeId: z.string().uuid().optional(),
+    taskId: z.string().uuid().optional(),
+    limit: z.number().int().min(1).max(20).default(10),
+  }),
+  outputSchema: z.object({
+    groupBy: groupBySchema,
+    period: z.object({ startDate: z.string(), endDate: z.string() }),
+    totalSeconds: z.number(),
+    totalHours: z.number(),
+    entryCount: z.number(),
+    items: z.array(
+      z.object({
+        groupId: z.string(),
+        groupLabel: z.string(),
+        totalSeconds: z.number(),
+        totalHours: z.number(),
+        entryCount: z.number(),
+        firstEntry: z.string().nullable(),
+        lastEntry: z.string().nullable(),
+      }),
+    ),
+  }),
+  async execute(input) {
+    const period = getTimePeriod(input.startDate, input.endDate);
+    const aggregate = getTimeEntryAggregateGroup(input.groupBy);
+    const totalSecondsSql = sql<number>`coalesce(sum(${timeEntries.durationSeconds}), 0)`;
+    const entryCountSql = sql<number>`count(${timeEntries.id})`;
+    const firstEntrySql = sql<Date>`min(${timeEntries.start})`;
+    const lastEntrySql = sql<Date>`max(${timeEntries.start})`;
+    const where = and(
+      isNotNull(timeEntries.end),
+      gte(timeEntries.start, period.start),
+      lt(timeEntries.start, period.endExclusive),
+      input.customerId ? eq(timeEntries.customerId, input.customerId) : undefined,
+      input.projectId ? eq(timeEntries.projectId, input.projectId) : undefined,
+      input.employeeId ? eq(timeEntries.employeeId, input.employeeId) : undefined,
+      input.taskId ? eq(timeEntries.taskId, input.taskId) : undefined,
+    );
+
+    const [rows, [total]] = await Promise.all([
+      db
+        .select({
+          groupId: aggregate.groupId,
+          groupLabel: aggregate.groupLabel,
+          totalSeconds: totalSecondsSql,
+          entryCount: entryCountSql,
+          firstEntry: firstEntrySql,
+          lastEntry: lastEntrySql,
+        })
+        .from(timeEntries)
+        .leftJoin(customers, eq(timeEntries.customerId, customers.id))
+        .leftJoin(projects, eq(timeEntries.projectId, projects.id))
+        .leftJoin(tasks, eq(timeEntries.taskId, tasks.id))
+        .leftJoin(employees, eq(timeEntries.employeeId, employees.id))
+        .leftJoin(users, eq(employees.userId, users.id))
+        .where(where)
+        .groupBy(...aggregate.groupBy)
+        .orderBy(desc(totalSecondsSql), asc(aggregate.groupLabel))
+        .limit(input.limit),
+      db
+        .select({
+          totalSeconds: totalSecondsSql,
+          entryCount: entryCountSql,
+        })
+        .from(timeEntries)
+        .where(where),
+    ]);
+
+    const totalSeconds = Number(total?.totalSeconds ?? 0);
+
+    return {
+      groupBy: input.groupBy,
+      period: { startDate: period.startDate, endDate: period.endDate },
+      totalSeconds,
+      totalHours: secondsToHours(totalSeconds),
+      entryCount: Number(total?.entryCount ?? 0),
+      items: rows.map((row) => {
+        const rowSeconds = Number(row.totalSeconds);
+
+        return {
+          groupId: row.groupId ?? "unassigned",
+          groupLabel: row.groupLabel ?? "Niet toegewezen",
+          totalSeconds: rowSeconds,
+          totalHours: secondsToHours(rowSeconds),
+          entryCount: Number(row.entryCount),
+          firstEntry: row.firstEntry?.toISOString() ?? null,
+          lastEntry: row.lastEntry?.toISOString() ?? null,
+        };
+      }),
+    };
+  },
+});
+
+export const summarizeTimeEntriesTool = resolveAgentTool(summarizeTimeEntries, {
+  permissions: ["time:view"],
+  ui: {
+    label: "Summarize time entries",
+    icon: "chart-no-axes-column",
+  },
+});
+
+function getTimeEntryAggregateGroup(groupBy: z.infer<typeof groupBySchema>) {
+  const daySql = sql<string>`date_trunc('day', ${timeEntries.start})::date`;
+
+  switch (groupBy) {
+    case "customer":
+      return {
+        groupId: customers.id,
+        groupLabel: customers.name,
+        groupBy: [customers.id, customers.name],
+      };
+    case "project":
+      return {
+        groupId: projects.id,
+        groupLabel: projects.title,
+        groupBy: [projects.id, projects.title],
+      };
+    case "employee":
+      return {
+        groupId: employees.id,
+        groupLabel: users.name,
+        groupBy: [employees.id, users.name],
+      };
+    case "task":
+      return {
+        groupId: tasks.id,
+        groupLabel: sql<string>`coalesce(${tasks.title}, 'Geen task')`,
+        groupBy: [tasks.id, tasks.title],
+      };
+    case "date":
+      return {
+        groupId: daySql,
+        groupLabel: daySql,
+        groupBy: [daySql],
+      };
+  }
+}
+
+function getTimePeriod(startDate?: string, endDate?: string) {
+  const now = new Date();
+  const start = startDate ? parseDate(startDate) : new Date(now.getFullYear(), now.getMonth(), 1);
+  const end = endDate
+    ? parseDate(endDate)
+    : new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const endExclusive = new Date(end);
+  endExclusive.setDate(endExclusive.getDate() + 1);
+
+  return {
+    start,
+    endExclusive,
+    startDate: formatDate(start),
+    endDate: formatDate(end),
+  };
+}
+
+function parseDate(value: string) {
+  return new Date(`${value}T00:00:00.000Z`);
+}
+
+function formatDate(value: Date) {
+  return value.toISOString().slice(0, 10);
+}
+
+function secondsToHours(seconds: number) {
+  return Number((seconds / 3600).toFixed(2));
+}

package/dist/templates/code/src/server/agents/sales/agent.ts

@@ -0,0 +1,27 @@
+import "server-cli-only";
+
+import { ToolLoopAgent } from "ai";
+import { openrouter } from "../../../app/admin/assistant/_lib/providers";
+import { webSearchTool } from "../tools/web_search/tool.server";
+import { instructions } from "./instructions";
+import { createProspectTool } from "./tools/create_prospect/tool.server";
+import { createProspectContactTool } from "./tools/create_prospect_contact/tool.server";
+import { findDuplicateCrmRecordsTool } from "./tools/find_duplicate_crm_records/tool.server";
+import { searchCrmRecordsTool } from "./tools/search_crm_records/tool.server";
+
+/**
+ * Sales Agent
+ * This agent is responsible for handling sales-related tasks, such as creating prospects and managing sales leads.
+ * It uses the OpenRouter provider to access AI models and execute tasks based on the provided instructions.
+ */
+export const salesAgent = new ToolLoopAgent({
+  model: openrouter("anthropic/claude-sonnet-4"),
+  instructions,
+  tools: {
+    search_crm_records: searchCrmRecordsTool,
+    find_duplicate_crm_records: findDuplicateCrmRecordsTool,
+    create_prospect: createProspectTool,
+    create_prospect_contact: createProspectContactTool,
+    web_search: webSearchTool,
+  },
+});