@tulip-systems/create-app 0.11.1

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

@@ -0,0 +1,162 @@
+import "server-cli-only";
+
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { asc, eq, ilike, or } 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";
+
+const deliveryRecordSchema = z.object({
+  id: z.string(),
+  type: z.enum(["customer", "project", "initiative", "task"]),
+  label: z.string(),
+  status: z.string().nullable(),
+  parentId: z.string().nullable(),
+  parentLabel: z.string().nullable(),
+});
+
+export const searchDeliveryRecords = defineTool({
+  name: "search_delivery_records",
+  title: "Search Delivery Records",
+  description:
+    "Search customers, projects, initiatives, and tasks before planning delivery work or creating project records.",
+  inputSchema: z.object({
+    query: z
+      .string()
+      .trim()
+      .min(1)
+      .describe("Customer, project, initiative, task, or key to search for."),
+    limit: z
+      .number()
+      .int()
+      .min(1)
+      .max(10)
+      .default(5)
+      .describe("Maximum records to return per type."),
+  }),
+  outputSchema: z.object({
+    query: z.string(),
+    customers: z.array(deliveryRecordSchema),
+    projects: z.array(deliveryRecordSchema),
+    initiatives: z.array(deliveryRecordSchema),
+    tasks: z.array(deliveryRecordSchema),
+    total: z.number(),
+  }),
+  async execute(input) {
+    const query = input.query.trim();
+    const likeQuery = `%${query}%`;
+
+    const [customerRows, projectRows, initiativeRows, taskRows] = await Promise.all([
+      db
+        .select({ id: customers.id, label: customers.name })
+        .from(customers)
+        .where(
+          or(
+            ilike(customers.name, likeQuery),
+            ilike(customers.tradeName, likeQuery),
+            ilike(customers.email, likeQuery),
+            ilike(customers.website, likeQuery),
+          ),
+        )
+        .orderBy(asc(customers.name))
+        .limit(input.limit),
+      db
+        .select({
+          id: projects.id,
+          label: projects.title,
+          key: projects.key,
+          status: projects.status,
+          customerId: customers.id,
+          customerName: customers.name,
+        })
+        .from(projects)
+        .leftJoin(customers, eq(projects.customerId, customers.id))
+        .where(or(ilike(projects.title, likeQuery), ilike(projects.key, likeQuery)))
+        .orderBy(asc(projects.title))
+        .limit(input.limit),
+      db
+        .select({
+          id: initiatives.id,
+          label: initiatives.title,
+          status: initiatives.status,
+          projectId: projects.id,
+          projectTitle: projects.title,
+        })
+        .from(initiatives)
+        .leftJoin(projects, eq(initiatives.projectId, projects.id))
+        .where(ilike(initiatives.title, likeQuery))
+        .orderBy(asc(initiatives.title))
+        .limit(input.limit),
+      db
+        .select({
+          id: tasks.id,
+          label: tasks.title,
+          code: tasks.code,
+          status: tasks.status,
+          projectId: projects.id,
+          projectTitle: projects.title,
+        })
+        .from(tasks)
+        .leftJoin(projects, eq(tasks.projectId, projects.id))
+        .where(or(ilike(tasks.title, likeQuery), ilike(tasks.code, likeQuery)))
+        .orderBy(asc(tasks.title))
+        .limit(input.limit),
+    ]);
+
+    const customerResults = customerRows.map((record) => ({
+      ...record,
+      type: "customer" as const,
+      status: null,
+      parentId: null,
+      parentLabel: null,
+    }));
+    const projectResults = projectRows.map((record) => ({
+      id: record.id,
+      type: "project" as const,
+      label: `${record.key} · ${record.label}`,
+      status: record.status,
+      parentId: record.customerId,
+      parentLabel: record.customerName,
+    }));
+    const initiativeResults = initiativeRows.map((record) => ({
+      id: record.id,
+      type: "initiative" as const,
+      label: record.label,
+      status: record.status,
+      parentId: record.projectId,
+      parentLabel: record.projectTitle,
+    }));
+    const taskResults = taskRows.map((record) => ({
+      id: record.id,
+      type: "task" as const,
+      label: `${record.code} · ${record.label}`,
+      status: record.status,
+      parentId: record.projectId,
+      parentLabel: record.projectTitle,
+    }));
+
+    return {
+      query,
+      customers: customerResults,
+      projects: projectResults,
+      initiatives: initiativeResults,
+      tasks: taskResults,
+      total:
+        customerResults.length +
+        projectResults.length +
+        initiativeResults.length +
+        taskResults.length,
+    };
+  },
+});
+
+export const searchDeliveryRecordsTool = resolveAgentTool(searchDeliveryRecords, {
+  permissions: ["customer:view", "project:view", "initiative:view", "task:view"],
+  ui: {
+    label: "Search delivery records",
+    icon: "search",
+  },
+});

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

@@ -0,0 +1,18 @@
+import "server-cli-only";
+
+import { ToolLoopAgent } from "ai";
+import { openrouter } from "../../../app/admin/assistant/_lib/providers";
+import { instructions } from "./instructions";
+import { createDriveFolderTool } from "./tools/create_drive_folder/tool.server";
+import { getDriveFolderContextTool } from "./tools/get_drive_folder_context/tool.server";
+import { searchDriveNodesTool } from "./tools/search_drive_nodes/tool.server";
+
+export const knowledgeAgent = new ToolLoopAgent({
+  model: openrouter("google/gemini-2.5-pro"),
+  instructions,
+  tools: {
+    search_drive_nodes: searchDriveNodesTool,
+    get_drive_folder_context: getDriveFolderContextTool,
+    create_drive_folder: createDriveFolderTool,
+  },
+});

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

@@ -0,0 +1,96 @@
+export const instructions = `# Knowledge Agent
+
+Je bent de knowledge- en Drive-specialist voor de Tulip admin workspace. Je helpt met bestanden, folders, projectdocumentatie, kennisstructuur en het organiseren van Drive-inhoud.
+
+Je belangrijkste doel is om gebruikers snel naar de juiste documenten of folders te brengen, zonder bestanden te verzinnen of ongewenste wijzigingen in Drive te maken.
+
+## Kernprincipes
+
+- Gebruik Drive-tools voor alle feitelijke claims over folders en bestanden.
+- Maak onderscheid tussen gevonden Drive-data, interpretatie en ontbrekende informatie.
+- Stel maximaal één gerichte verduidelijkingsvraag wanneer namespace, folder, klant of project onduidelijk is.
+- Maak folders alleen wanneer de gebruiker expliciet om creatie vraagt.
+- Verplaats, archiveer, herstel of verwijder niets. Deze agent mag alleen zoeken, context ophalen en folders aanmaken.
+- Verzin nooit bestandsnamen, folderstructuren, links of uitgevoerde acties.
+- Gebruik Nederlands tenzij de gebruiker of hoofdassistent in een andere taal werkt.
+
+## Drive Namespaces
+
+- \`global\`: algemene gedeelde Drive-ruimte.
+- \`projects\`: projectdocumentatie en projectfolders.
+
+Gebruik \`projects\` wanneer de gebruiker project-, klant- of delivery-documentatie noemt. Gebruik \`global\` voor algemene kennis of wanneer geen projectcontext bestaat.
+
+## Beschikbare Tools
+
+### \`search_drive_nodes\`
+
+Gebruik deze tool om folders en bestanden te zoeken op naam binnen een Drive namespace.
+
+Gebruik deze tool wanneer:
+
+- de gebruiker een document, folder, klant of project noemt
+- je moet controleren of een folder al bestaat
+- je een folder-id nodig hebt voor context of foldercreatie
+
+### \`get_drive_folder_context\`
+
+Gebruik deze tool om de inhoud van een folder of namespace-root te bekijken, inclusief breadcrumbs en directe children.
+
+Gebruik deze tool wanneer:
+
+- de gebruiker vraagt wat er in een folder staat
+- je moet bepalen waar een nieuwe folder hoort
+- zoekresultaten niet genoeg context geven
+
+### \`create_drive_folder\`
+
+Gebruik deze tool alleen wanneer:
+- de gebruiker expliciet vraagt om een folder aan te maken
+- de namespace duidelijk is
+- de foldernaam duidelijk is
+- de parent/root locatie duidelijk is
+- je eerst hebt gecontroleerd of er geen duidelijke bestaande folder is
+
+## Folder Creation Workflow
+
+Volg deze volgorde strikt:
+
+- Bepaal namespace: \`projects\` of \`global\`.
+- Zoek of de folder al bestaat met \`search_drive_nodes\`.
+- Als er een duidelijke bestaande folder is, maak niets aan; geef de match terug en vraag wat de gebruiker wil doen.
+- Bepaal parent-folder. Gebruik root alleen als de gebruiker dat bedoelt of er geen betere parent bestaat.
+- Maak de folder alleen wanneer de gebruiker expliciet om creatie vraagt of akkoord gaf.
+- Na creatie: vat foldernaam, namespace, parent en link samen.
+
+## Antwoordstijl
+
+- Begin met de uitkomst: gevonden, niet gevonden, of aangemaakt.
+- Gebruik bullets voor matches, folderinhoud en vervolgstappen.
+- Noem links wanneer beschikbaar.
+- Benoem onzekerheid wanneer zoekresultaten breed of ambigu zijn.
+- Vermijd interne toolnamen in het eindantwoord, tenzij de gebruiker technische details vraagt.
+
+## Antwoordpatronen
+
+Voor zoekvragen:
+
+- Gevonden matches
+- Type: folder of file
+- Locatie/context
+- Link indien beschikbaar
+- Volgende stap
+
+Voor foldercontext:
+
+- Folder of root
+- Breadcrumbs
+- Belangrijkste children
+- Opvallende ontbrekende structuur
+
+Voor foldercreatie:
+
+- Aangemaakt of niet aangemaakt
+- Naam, locatie en namespace
+- Link indien beschikbaar
+- Aanbevolen volgende stap`;

package/dist/templates/code/src/server/agents/knowledge/tools/_lib/drive.ts

@@ -0,0 +1,68 @@
+import "server-cli-only";
+
+import { z } from "zod";
+import { DRIVE_NAMESPACES } from "@/app/admin/drive/_config/namespaces";
+
+export const driveNamespaceKeySchema = z.enum(["global", "projects"]);
+export type DriveNamespaceKey = z.infer<typeof driveNamespaceKeySchema>;
+
+export const driveNodeSummarySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  namespaceKey: driveNamespaceKeySchema,
+  namespace: z.string(),
+  type: z.string(),
+  subtype: z.string(),
+  contentType: z.string().nullable(),
+  parentId: z.string().nullable(),
+  readonly: z.boolean(),
+  archived: z.boolean(),
+  viewLink: z.string().nullable(),
+  updatedAt: z.string(),
+});
+
+export const driveFolderParentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  parentId: z.string().nullable(),
+  depth: z.number(),
+});
+
+export function getDriveNamespace(key: DriveNamespaceKey) {
+  return DRIVE_NAMESPACES[key].namespace;
+}
+
+export function getDriveNamespaceKey(namespace: string): DriveNamespaceKey {
+  const match = Object.values(DRIVE_NAMESPACES).find((item) => item.namespace === namespace);
+
+  return (match?.key ?? "global") as DriveNamespaceKey;
+}
+
+export function toDriveNodeSummary(node: {
+  id: string;
+  name: string;
+  namespace: string;
+  type: string;
+  subtype: string;
+  contentType: string | null;
+  parentId: string | null;
+  readonly: boolean;
+  archivedAt: Date | null;
+  links: { view: string | null };
+  updatedAt: Date;
+}) {
+  return {
+    id: node.id,
+    name: node.name,
+    namespaceKey: getDriveNamespaceKey(node.namespace),
+    namespace: node.namespace,
+    type: node.type,
+    subtype: node.subtype,
+    contentType: node.contentType,
+    parentId: node.parentId,
+    readonly: node.readonly,
+    archived: Boolean(node.archivedAt),
+    viewLink: node.links.view,
+    updatedAt: node.updatedAt.toISOString(),
+  };
+}

package/dist/templates/code/src/server/agents/knowledge/tools/create_drive_folder/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 { createDriveFolder } from "./tool.server";
+
+export const createDriveFolderToolClient = defineToolClient<typeof createDriveFolder>({
+  toolName: "create_drive_folder",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Drive folder aanmaken"
+      icon={<FolderPlus className="size-3.5" />}
+      labels={{
+        input: "Foldergegevens",
+        output: "Aangemaakte folder",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/knowledge/tools/create_drive_folder/tool.server.ts

@@ -0,0 +1,69 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { z } from "zod";
+import { googleDrive } from "@/app/admin/drive/_lib/service.server";
+import {
+  driveNamespaceKeySchema,
+  driveNodeSummarySchema,
+  getDriveNamespace,
+  toDriveNodeSummary,
+} from "../_lib/drive";
+
+export const createDriveFolder = defineTool({
+  name: "create_drive_folder",
+  title: "Create Drive Folder",
+  description:
+    "Create a Google Drive folder in a configured workspace namespace. Use only after checking for existing folders and user approval.",
+  inputSchema: z.object({
+    namespaceKey: driveNamespaceKeySchema.default("projects"),
+    name: z.string().trim().min(1).max(255),
+    parentId: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Parent folder id. Omit or null for namespace root."),
+  }),
+  outputSchema: z.object({ folder: driveNodeSummarySchema }),
+  async execute(input) {
+    const namespace = getDriveNamespace(input.namespaceKey);
+
+    if (input.parentId) {
+      const parent = await googleDrive.getNodeById(input.parentId);
+
+      if (!parent || parent.namespace !== namespace) {
+        throw new ORPCError("NOT_FOUND", { message: "Parent folder niet gevonden" });
+      }
+      if (parent.type !== "folder") {
+        throw new ORPCError("BAD_REQUEST", { message: "Parent is geen folder" });
+      }
+    }
+
+    const folder = await googleDrive.createFolder({
+      namespace,
+      parentId: input.parentId ?? null,
+      name: input.name,
+    });
+
+    return { folder: toDriveNodeSummary(folder) };
+  },
+});
+
+export const createDriveFolderTool = resolveAgentTool(createDriveFolder, {
+  permissions: ["drive:create"],
+  confirmation: {
+    required: true,
+    title: "Create Drive folder?",
+    description: "Review the namespace, parent location, and folder name before creating it.",
+  },
+  audit: {
+    action: "drive.folder.create",
+    resource: "drive",
+    severity: "medium",
+  },
+  ui: {
+    label: "Create Drive folder",
+    icon: "folder-plus",
+  },
+});

package/dist/templates/code/src/server/agents/knowledge/tools/get_drive_folder_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 { FolderOpen } from "lucide-react";
+import type { getDriveFolderContext } from "./tool.server";
+
+export const getDriveFolderContextToolClient = defineToolClient<typeof getDriveFolderContext>({
+  toolName: "get_drive_folder_context",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Drive foldercontext ophalen"
+      icon={<FolderOpen className="size-3.5" />}
+      labels={{
+        input: "Folder",
+        output: "Foldercontext",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/knowledge/tools/get_drive_folder_context/tool.server.ts

@@ -0,0 +1,88 @@
+import "server-cli-only";
+
+import { ORPCError } from "@orpc/server";
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { z } from "zod";
+import { googleDrive } from "@/app/admin/drive/_lib/service.server";
+import {
+  driveFolderParentSchema,
+  driveNamespaceKeySchema,
+  driveNodeSummarySchema,
+  getDriveNamespace,
+  toDriveNodeSummary,
+} from "../_lib/drive";
+
+export const getDriveFolderContext = defineTool({
+  name: "get_drive_folder_context",
+  title: "Get Drive Folder Context",
+  description: "Inspect a Drive folder or namespace root with breadcrumbs and direct children.",
+  inputSchema: z.object({
+    namespaceKey: driveNamespaceKeySchema.default("projects"),
+    folderId: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Folder id. Omit or null to inspect namespace root."),
+    limit: z.number().int().min(1).max(30).default(15),
+  }),
+  outputSchema: z.object({
+    namespaceKey: driveNamespaceKeySchema,
+    folder: driveNodeSummarySchema.nullable(),
+    breadcrumbs: z.array(driveFolderParentSchema),
+    children: z.array(driveNodeSummarySchema),
+    totalChildren: z.number(),
+  }),
+  async execute(input) {
+    const namespace = getDriveNamespace(input.namespaceKey);
+    const folderId = input.folderId ?? null;
+
+    if (folderId) {
+      const folder = await googleDrive.getNodeWithChildren({ id: folderId, namespace });
+
+      if (!folder) {
+        throw new ORPCError("NOT_FOUND", { message: "Drive folder niet gevonden" });
+      }
+      if (folder.type !== "folder") {
+        throw new ORPCError("BAD_REQUEST", { message: "Drive node is geen folder" });
+      }
+
+      const breadcrumbs = await googleDrive.getFolderParents({ id: folderId, namespace });
+      const children = folder.children.slice(0, input.limit).map(toDriveNodeSummary);
+
+      return {
+        namespaceKey: input.namespaceKey,
+        folder: toDriveNodeSummary(folder),
+        breadcrumbs,
+        children,
+        totalChildren: folder.children.length,
+      };
+    }
+
+    const [childrenResult, breadcrumbs] = await Promise.all([
+      googleDrive.listTree({
+        pagination: { page: 0, limit: input.limit },
+        sorts: [],
+        filters: { namespace, parentId: null, isArchived: false },
+      }),
+      googleDrive.getFolderParents({ id: null, namespace }),
+    ]);
+
+    const children = childrenResult.data.map(toDriveNodeSummary);
+
+    return {
+      namespaceKey: input.namespaceKey,
+      folder: null,
+      breadcrumbs,
+      children,
+      totalChildren: children.length,
+    };
+  },
+});
+
+export const getDriveFolderContextTool = resolveAgentTool(getDriveFolderContext, {
+  permissions: ["drive:view"],
+  ui: {
+    label: "Get Drive folder context",
+    icon: "folder-open",
+  },
+});

package/dist/templates/code/src/server/agents/knowledge/tools/search_drive_nodes/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 { searchDriveNodes } from "./tool.server";
+
+export const searchDriveNodesToolClient = defineToolClient<typeof searchDriveNodes>({
+  toolName: "search_drive_nodes",
+  render: (part) => (
+    <ToolCallCard
+      part={part}
+      title="Drive zoeken"
+      icon={<Search className="size-3.5" />}
+      labels={{
+        input: "Zoekopdracht",
+        output: "Gevonden Drive-items",
+        preliminaryOutput: "Tussentijds resultaat",
+      }}
+    />
+  ),
+});

package/dist/templates/code/src/server/agents/knowledge/tools/search_drive_nodes/tool.server.ts

@@ -0,0 +1,60 @@
+import "server-cli-only";
+
+import { defineTool, resolveAgentTool } from "@tulip-systems/ai/tools/server";
+import { z } from "zod";
+import { googleDrive } from "@/app/admin/drive/_lib/service.server";
+import {
+  driveNamespaceKeySchema,
+  driveNodeSummarySchema,
+  getDriveNamespace,
+  toDriveNodeSummary,
+} from "../_lib/drive";
+
+export const searchDriveNodes = defineTool({
+  name: "search_drive_nodes",
+  title: "Search Drive Nodes",
+  description: "Search Google Drive files and folders within a configured workspace namespace.",
+  inputSchema: z.object({
+    namespaceKey: driveNamespaceKeySchema.default("projects"),
+    query: z.string().trim().min(1).describe("File, folder, project, customer, or document name."),
+    type: z.enum(["file", "folder"]).optional(),
+    parentId: z.string().nullable().optional(),
+    limit: z.number().int().min(1).max(20).default(10),
+  }),
+  outputSchema: z.object({
+    namespaceKey: driveNamespaceKeySchema,
+    query: z.string(),
+    nodes: z.array(driveNodeSummarySchema),
+    total: z.number(),
+  }),
+  async execute(input) {
+    const result = await googleDrive.listTree({
+      pagination: { page: 0, limit: input.limit },
+      sorts: [],
+      filters: {
+        namespace: getDriveNamespace(input.namespaceKey),
+        parentId: input.parentId ?? null,
+        search: input.query,
+        types: input.type ? [input.type] : undefined,
+        isArchived: false,
+      },
+    });
+
+    const nodes = result.data.map(toDriveNodeSummary);
+
+    return {
+      namespaceKey: input.namespaceKey,
+      query: input.query,
+      nodes,
+      total: nodes.length,
+    };
+  },
+});
+
+export const searchDriveNodesTool = resolveAgentTool(searchDriveNodes, {
+  permissions: ["drive:view"],
+  ui: {
+    label: "Search Drive",
+    icon: "search",
+  },
+});

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

@@ -0,0 +1,20 @@
+import "server-cli-only";
+
+import { ToolLoopAgent } from "ai";
+import { openrouter } from "../../../app/admin/assistant/_lib/providers";
+import { getProjectContextTool } from "../delivery/tools/get_project_context/tool.server";
+import { searchDeliveryRecordsTool } from "../delivery/tools/search_delivery_records/tool.server";
+import { instructions } from "./instructions";
+import { getInitiativeHealthTool } from "./tools/get_initiative_health/tool.server";
+import { summarizeTimeEntriesTool } from "./tools/summarize_time_entries/tool.server";
+
+export const operationsAgent = new ToolLoopAgent({
+  model: openrouter("openai/gpt-5-mini"),
+  instructions,
+  tools: {
+    search_delivery_records: searchDeliveryRecordsTool,
+    get_project_context: getProjectContextTool,
+    summarize_time_entries: summarizeTimeEntriesTool,
+    get_initiative_health: getInitiativeHealthTool,
+  },
+});