Added an AI help link to the CLI

Author: matt-aitken

.changeset/red-chairs-begin.md

@@ -0,0 +1,5 @@
+---
+"trigger.dev": patch
+---
+
+Added AI assistance link when you have build errors

apps/webapp/app/routes/projects.$projectRef.ai-help.ts

@@ -0,0 +1,52 @@
+import { type LoaderFunctionArgs, redirect } from "@remix-run/server-runtime";
+import { z } from "zod";
+import { prisma } from "~/db.server";
+import { env } from "~/env.server";
+import { logger } from "~/services/logger.server";
+import { requireUserId } from "~/services/session.server";
+import { v3EnvironmentPath, v3ProjectPath, v3TestPath } from "~/utils/pathBuilder";
+
+const ParamsSchema = z.object({
+  projectRef: z.string(),
+});
+
+export async function loader({ params, request }: LoaderFunctionArgs) {
+  const userId = await requireUserId(request);
+
+  const validatedParams = ParamsSchema.parse(params);
+
+  const project = await prisma.project.findFirst({
+    where: {
+      externalRef: validatedParams.projectRef,
+      organization: {
+        members: {
+          some: {
+            userId,
+          },
+        },
+      },
+    },
+    include: {
+      organization: true,
+    },
+  });
+
+  if (!project) {
+    return new Response("Not found", { status: 404 });
+  }
+
+  const url = new URL(request.url);
+  const query = url.searchParams.get("q");
+
+  if (!query) {
+    return new Response("No query", { status: 404 });
+  }
+
+  const newUrl = new URL(
+    v3EnvironmentPath({ slug: project.organization.slug }, { slug: project.slug }, { slug: "dev" }),
+    env.LOGIN_ORIGIN
+  );
+  newUrl.searchParams.set("aiHelp", query);
+
+  return redirect(newUrl.toString());
+}

packages/cli-v3/src/build/bundle.ts

@@ -51,6 +51,15 @@ export type BundleResult = {
   stop: (() => Promise<void>) | undefined;
 };
 
+export class BundleError extends Error {
+  constructor(
+    message: string,
+    public readonly issues?: esbuild.Message[]
+  ) {
+    super(message);
+  }
+}
+
 export async function bundleWorker(options: BundleOptions): Promise<BundleResult> {
   const { resolvedConfig } = options;
 
@@ -129,7 +138,7 @@ export async function bundleWorker(options: BundleOptions): Promise<BundleResult
     await currentContext.watch();
     result = await initialBuildResultPromise;
     if (result.errors.length > 0) {
-      throw new Error("Failed to build");
+      throw new BundleError("Failed to build", result.errors);
     }
 
     stop = async function () {

packages/cli-v3/src/cli/common.ts

@@ -9,6 +9,7 @@ import { outro } from "@clack/prompts";
 import { chalkError } from "../utilities/cliOutput.js";
 import { CLOUD_API_URL } from "../consts.js";
 import { readAuthConfigCurrentProfileName } from "../utilities/configFiles.js";
+import { BundleError } from "../build/bundle.js";
 
 export const CommonCommandOptions = z.object({
   apiUrl: z.string().optional(),
@@ -54,7 +55,7 @@ export async function wrapCommandAction<T extends z.AnyZodObject, TResult>(
   schema: T,
   options: unknown,
   action: (opts: z.output<T>) => Promise<TResult>
-): Promise<TResult> {
+): Promise<TResult | undefined> {
   return await tracer.startActiveSpan(name, async (span) => {
     try {
       const parsedOptions = schema.safeParse(options);
@@ -86,6 +87,8 @@ export async function wrapCommandAction<T extends z.AnyZodObject, TResult>(
         outro("Operation cancelled");
       } else if (e instanceof SkipCommandError) {
         // do nothing
+      } else if (e instanceof BundleError) {
+        process.exit();
       } else {
         recordSpanException(span, e);
 

packages/cli-v3/src/commands/dev.ts

@@ -1,7 +1,12 @@
 import { ResolvedConfig } from "@trigger.dev/core/v3/build";
 import { Command } from "commander";
 import { z } from "zod";
-import { CommonCommandOptions, commonOptions, wrapCommandAction } from "../cli/common.js";
+import {
+  CommonCommandOptions,
+  commonOptions,
+  SkipLoggingError,
+  wrapCommandAction,
+} from "../cli/common.js";
 import { watchConfig } from "../config.js";
 import { DevSessionInstance, startDevSession } from "../dev/devSession.js";
 import { chalkError } from "../utilities/cliOutput.js";
@@ -12,6 +17,7 @@ import { getProjectClient, LoginResultOk } from "../utilities/session.js";
 import { login } from "./login.js";
 import { updateTriggerPackages } from "./update.js";
 import { createLockFile } from "../dev/lock.js";
+import { BundleError } from "../build/bundle.js";
 
 const DevCommandOptions = CommonCommandOptions.extend({
   debugOtel: z.boolean().default(false),

packages/cli-v3/src/dev/devOutput.ts

@@ -8,6 +8,7 @@ import {
 import { TaskRunError, TaskRunErrorCodes } from "@trigger.dev/core/v3/schemas";
 import { DevCommandOptions } from "../commands/dev.js";
 import {
+  aiHelpLink,
   chalkError,
   chalkGrey,
   chalkLink,
@@ -24,6 +25,7 @@ import {
 import { eventBus, EventBusEventArgs } from "../utilities/eventBus.js";
 import { logger } from "../utilities/logger.js";
 import { Socket } from "socket.io-client";
+import { BundleError } from "../build/bundle.js";
 
 export type DevOutputOptions = {
   name: string | undefined;
@@ -45,6 +47,23 @@ export function startDevOutput(options: DevOutputOptions) {
     logger.log(chalkGrey("○ Building background worker…"));
   };
 
+  const buildFailed = (...[target, error]: EventBusEventArgs<"buildFailed">) => {
+    const errorText = error instanceof Error ? error.message : "Unknown error";
+    const stack = error instanceof Error ? error.stack : undefined;
+
+    let issues: string[] = [];
+
+    if (error instanceof BundleError) {
+      issues = error.issues?.map((issue) => `${issue.text} (${issue.location?.file})`) ?? [];
+    }
+
+    aiHelpLink({
+      dashboardUrl,
+      project: config.project,
+      query: `Build failed:\n ${errorText}\n${issues.join("\n")}\n${stack}`,
+    });
+  };
+
   const workerSkipped = () => {
     logger.log(chalkGrey("○ No changes detected, skipping build…"));
   };
@@ -83,12 +102,18 @@ export function startDevOutput(options: DevOutputOptions) {
     ...[buildManifest, error]: EventBusEventArgs<"backgroundWorkerIndexingError">
   ) => {
     if (error instanceof TaskIndexingImportError) {
+      let errorText = "";
       for (const importError of error.importErrors) {
         prettyError(
           `Could not import ${importError.file}`,
           importError.stack ?? importError.message
         );
+        errorText += `Could not import ${importError.file}:\n ${
+          importError.stack ?? importError.message
+        }\n`;
       }
+
+      aiHelpLink({ dashboardUrl, project: config.project, query: errorText });
     } else if (error instanceof TaskMetadataParseError) {
       const errorStack = createTaskMetadataFailedErrorStack({
         version: "v1",
@@ -97,11 +122,21 @@ export function startDevOutput(options: DevOutputOptions) {
       });
 
       prettyError(`Could not parse task metadata`, errorStack);
+      aiHelpLink({
+        dashboardUrl,
+        project: config.project,
+        query: `Could not parse task metadata:\n ${errorStack}`,
+      });
     } else {
       const errorText = error instanceof Error ? error.message : "Unknown error";
       const stack = error instanceof Error ? error.stack : undefined;
 
       prettyError(`Build failed: ${errorText}`, stack);
+      aiHelpLink({
+        dashboardUrl,
+        project: config.project,
+        query: `Build failed:\n ${errorText}\n${stack}`,
+      });
     }
   };
 
@@ -184,6 +219,7 @@ export function startDevOutput(options: DevOutputOptions) {
 
   eventBus.on("rebuildStarted", rebuildStarted);
   eventBus.on("buildStarted", buildStarted);
+  eventBus.on("buildFailed", buildFailed);
   eventBus.on("workerSkipped", workerSkipped);
   eventBus.on("backgroundWorkerInitialized", backgroundWorkerInitialized);
   eventBus.on("runStarted", runStarted);
@@ -195,6 +231,7 @@ export function startDevOutput(options: DevOutputOptions) {
   return () => {
     eventBus.off("rebuildStarted", rebuildStarted);
     eventBus.off("buildStarted", buildStarted);
+    eventBus.off("buildFailed", buildFailed);
     eventBus.off("workerSkipped", workerSkipped);
     eventBus.off("backgroundWorkerInitialized", backgroundWorkerInitialized);
     eventBus.off("runStarted", runStarted);

packages/cli-v3/src/dev/devSession.ts

@@ -24,6 +24,7 @@ import { clearTmpDirs, EphemeralDirectory, getTmpDir } from "../utilities/tempDi
 import { startDevOutput } from "./devOutput.js";
 import { startWorkerRuntime } from "./devSupervisor.js";
 import { startMcpServer, stopMcpServer } from "./mcpServer.js";
+import { aiHelpLink } from "../utilities/cliOutput.js";
 
 export type DevSessionOptions = {
   name: string | undefined;
@@ -172,24 +173,34 @@ export async function startDevSession({
   async function runBundle() {
     eventBus.emit("buildStarted", "dev");
 
-    // Use glob to find initial entryPoints
-    // Use chokidar to watch for entryPoints changes (e.g. added or removed?)
-    // When there is a change, update entryPoints and start a new build with watch: true
-    const bundleResult = await bundleWorker({
-      target: "dev",
-      cwd: rawConfig.workingDir,
-      destination: destination.path,
-      watch: true,
-      resolvedConfig: rawConfig,
-      plugins: [...pluginsFromExtensions, onEnd],
-      jsxFactory: rawConfig.build.jsx.factory,
-      jsxFragment: rawConfig.build.jsx.fragment,
-      jsxAutomatic: rawConfig.build.jsx.automatic,
-    });
+    try {
+      // Use glob to find initial entryPoints
+      // Use chokidar to watch for entryPoints changes (e.g. added or removed?)
+      // When there is a change, update entryPoints and start a new build with watch: true
+      const bundleResult = await bundleWorker({
+        target: "dev",
+        cwd: rawConfig.workingDir,
+        destination: destination.path,
+        watch: true,
+        resolvedConfig: rawConfig,
+        plugins: [...pluginsFromExtensions, onEnd],
+        jsxFactory: rawConfig.build.jsx.factory,
+        jsxFragment: rawConfig.build.jsx.fragment,
+        jsxAutomatic: rawConfig.build.jsx.automatic,
+      });
 
-    await updateBundle(bundleResult);
+      await updateBundle(bundleResult);
 
-    return bundleResult.stop;
+      return bundleResult.stop;
+    } catch (error) {
+      if (error instanceof Error) {
+        eventBus.emit("buildFailed", "dev", error);
+      } else {
+        eventBus.emit("buildFailed", "dev", new Error(String(error)));
+      }
+
+      throw error;
+    }
   }
 
   const stopBundling = await runBundle();

packages/cli-v3/src/utilities/cliOutput.ts

@@ -116,6 +116,27 @@ export function prettyWarning(header: string, body?: string, footer?: string) {
   );
 }
 
+export function aiHelpLink({
+  dashboardUrl,
+  project,
+  query,
+}: {
+  dashboardUrl: string;
+  project: string;
+  query: string;
+}) {
+  const searchParams = new URLSearchParams();
+
+  //the max length for a URL is 1950 characters
+  const clippedQuery = query.slice(0, 1950);
+
+  searchParams.set("q", clippedQuery);
+  const url = new URL(`/projects/${project}/ai-help`, dashboardUrl);
+  url.search = searchParams.toString();
+
+  log.message(chalkLink(cliLink("💡 Get a fix for this error using AI", url.toString())));
+}
+
 export function cliLink(text: string, url: string, options?: TerminalLinkOptions) {
   return terminalLink(text, url, {
     fallback: (text, url) => `${text} ${url}`,

packages/cli-v3/src/utilities/eventBus.ts

@@ -11,6 +11,7 @@ import { Socket } from "socket.io-client";
 export type EventBusEvents = {
   rebuildStarted: [BuildTarget];
   buildStarted: [BuildTarget];
+  buildFailed: [BuildTarget, Error];
   workerSkipped: [];
   backgroundWorkerInitialized: [BackgroundWorker];
   backgroundWorkerIndexingError: [BuildManifest, Error];