@fern-api/fern-api-dev 3.64.5 → 3.64.6

package/cli.cjs

@@ -1427240,7 +1427240,7 @@ var AccessTokenPosthogManager = class {
         properties: {
           ...event,
           ...event.properties,
-          version: "3.64.5",
+          version: "3.64.6",
           usingAccessToken: true
         }
       });
@@ -1427339,7 +1427339,7 @@ var UserPosthogManager = class {
       distinctId: this.userId ?? await this.getPersistedDistinctId(),
       event: "CLI",
       properties: {
-        version: "3.64.5",
+        version: "3.64.6",
         ...event,
         ...event.properties,
         usingAccessToken: false,
@@ -1432669,7 +1432669,7 @@ var TaskContextLogger = class {
   debug(...args) {
     const message = args.join(" ");
     this.context.logFileWriter.write({ taskName: this.task.name, level: LogLevel2.Debug, message });
-    if (this.enabled && this.context.logLevel === LogLevel2.Debug) {
+    if (this.shouldLogToTask(LogLevel2.Debug)) {
       if (this.task.logs == null) {
         this.task.logs = [];
       }
@@ -1432679,7 +1432679,7 @@ var TaskContextLogger = class {
   info(...args) {
     const message = args.join(" ");
     this.context.logFileWriter.write({ taskName: this.task.name, level: LogLevel2.Info, message });
-    if (this.enabled && this.context.logLevel === LogLevel2.Debug) {
+    if (this.shouldLogToTask(LogLevel2.Info)) {
       if (this.task.logs == null) {
         this.task.logs = [];
       }
@@ -1432689,7 +1432689,7 @@ var TaskContextLogger = class {
   warn(...args) {
     const message = args.join(" ");
     this.context.logFileWriter.write({ taskName: this.task.name, level: LogLevel2.Warn, message });
-    if (this.enabled) {
+    if (this.shouldLogToTask(LogLevel2.Warn)) {
       if (this.task.logs == null) {
         this.task.logs = [];
       }
@@ -1432699,7 +1432699,7 @@ var TaskContextLogger = class {
   error(...args) {
     const message = args.join(" ");
     this.context.logFileWriter.write({ taskName: this.task.name, level: LogLevel2.Error, message });
-    if (this.enabled) {
+    if (this.shouldLogToTask(LogLevel2.Error)) {
       this.collectedErrors.push(message);
       if (this.task.logs == null) {
         this.task.logs = [];
@@ -1432708,14 +1432708,27 @@ var TaskContextLogger = class {
     }
   }
   log(level, ...args) {
-    if (level === LogLevel2.Debug) {
-      this.debug(...args);
-    } else if (level === LogLevel2.Warn) {
-      this.warn(...args);
-    } else if (level === LogLevel2.Error) {
-      this.error(...args);
+    switch (level) {
+      case LogLevel2.Debug:
+        this.debug(...args);
+        break;
+      case LogLevel2.Info:
+        this.info(...args);
+        break;
+      case LogLevel2.Warn:
+        this.warn(...args);
+        break;
+      case LogLevel2.Error:
+        this.error(...args);
+        break;
     }
   }
+  /**
+   * Check if a message at the given level should be logged to the task's UI.
+   */
+  shouldLogToTask(level) {
+    return this.enabled && LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.logLevel);
+  }
 };
 
 // ../cli-v2/lib/context/adapter/TaskContextAdapter.js
@@ -1432724,7 +1432737,7 @@ var TaskContextAdapter = class {
   logger;
   constructor({ context: context2, task, logLevel = LogLevel2.Warn }) {
     if (task != null) {
-      this.logger = new TaskContextLogger({ context: context2, task });
+      this.logger = new TaskContextLogger({ context: context2, task, logLevel });
     } else {
       this.logger = createLogger2((level, ...args) => {
         if (LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(logLevel)) {
@@ -1510152,8 +1510165,16 @@ function getGeneratorNameOrThrow(generatorName, context2) {
   }
   return normalizedGeneratorName;
 }
+var GENERATOR_NAME_ALIASES = {
+  "fernapi/java-model": GeneratorName.JAVA_MODEL,
+  "fernapi/fern-typescript-node-sdk": GeneratorName.TYPESCRIPT_SDK
+};
 function normalizeGeneratorName(generatorName) {
   generatorName = addDefaultDockerOrgIfNotPresent(generatorName);
+  const aliased = GENERATOR_NAME_ALIASES[generatorName];
+  if (aliased != null) {
+    generatorName = aliased;
+  }
   if (isGeneratorName(generatorName)) {
     return generatorName;
   }
@@ -1563531,7 +1563552,7 @@ var ApiDefinitionValidator = class {
   cliVersion;
   constructor(config3) {
     this.context = config3.context;
-    this.taskContext = new TaskContextAdapter({ context: this.context });
+    this.taskContext = new TaskContextAdapter({ context: this.context, task: config3.task });
     this.cliVersion = config3.cliVersion;
   }
   /**
@@ -1563643,10 +1563664,12 @@ var ApiChecker = class {
   context;
   cliVersion;
   stream;
+  task;
   constructor(config3) {
     this.context = config3.context;
     this.cliVersion = config3.cliVersion;
     this.stream = config3.stream ?? process.stderr;
+    this.task = config3.task;
   }
   /**
    * Check APIs in the workspace and display results.
@@ -1563670,7 +1563693,8 @@ var ApiChecker = class {
     }
     const validator = new ApiDefinitionValidator({
       context: this.context,
-      cliVersion: this.cliVersion
+      cliVersion: this.cliVersion,
+      task: this.task
     });
     const allViolations = [];
     for (const apiName of apisToCheck) {
@@ -1563712,7 +1563736,7 @@ var ApiChecker = class {
   }
   writeHeader() {
     this.stream.write("\n");
-    this.stream.write(`${Icons.info} ${source_default.bold("Validating API definitions")}
+    this.stream.write(`${Icons.info} ${source_default.bold(`Validate APIs`)}
 `);
     this.stream.write("\n");
   }
@@ -1563887,6 +1563911,9 @@ var ApiChecker = class {
     }
     return `${(ms6 / 1e3).toFixed(1)}s`;
   }
+  maybePluralApis(apis) {
+    return apis.length === 1 ? "API" : "APIs";
+  }
 };
 
 // ../cli-v2/lib/commands/check/command.js
@@ -1682131,7 +1682158,12 @@ var LegacyRemoteGenerationRunner = class {
     this.invocationAdapter = new LegacyGeneratorInvocationAdapter({ context: this.context });
   }
   async run(args) {
-    const taskContext = new TaskContextAdapter({ task: args.task, context: this.context });
+    const taskContext = new TaskContextAdapter({
+      context: this.context,
+      task: args.task,
+      logLevel: LogLevel2.Info
+      // Capture INFO logs to parse git output URLs
+    });
     try {
       const generatorInvocation = await this.invocationAdapter.adapt(args.target);
       const generatorGroup = {
@@ -1682167,9 +1682199,10 @@ var LegacyRemoteGenerationRunner = class {
           success: false
         };
       }
+      const gitOutput = this.extractGitOutputFromTaskLogs(args.task);
       return {
         success: true,
-        output: absolutePathToPreview != null ? [absolutePathToPreview.toString()] : this.context.resolveTargetOutputs(args.target)
+        output: this.resolveOutput(args, gitOutput)
       };
     } catch (error49) {
       return {
@@ -1682210,6 +1682243,58 @@ var LegacyRemoteGenerationRunner = class {
     }
     return void 0;
   }
+  /**
+   * Extract git output URLs from task logs.
+   *
+   * The remote generation service logs messages like:
+   *  - "Created pull request: https://github.com/owner/repo/pull/123"
+   *  - "Created commit abc123"
+   *  - "Pushed branch: https://github.com/owner/repo/tree/branch-name"
+   *  - "Release tagged. View here: https://github.com/owner/repo/releases/tag/v1.0.0"
+   */
+  extractGitOutputFromTaskLogs(task) {
+    const gitOutput = {};
+    for (const log2 of task.logs ?? []) {
+      const prMatch = log2.message.match(/Created pull request: (.+)/);
+      if (prMatch != null) {
+        gitOutput.pullRequestUrl = prMatch[1];
+      }
+      const commitMatch = log2.message.match(/Created commit (\w+)/);
+      if (commitMatch != null) {
+        gitOutput.commitHash = commitMatch[1];
+      }
+      const branchMatch = log2.message.match(/Pushed branch: (.+)/);
+      if (branchMatch != null) {
+        gitOutput.branchUrl = branchMatch[1];
+      }
+      const releaseMatch = log2.message.match(/Release tagged\. View here: (.+)/);
+      if (releaseMatch != null) {
+        gitOutput.releaseUrl = releaseMatch[1];
+      }
+    }
+    return Object.keys(gitOutput).length > 0 ? gitOutput : void 0;
+  }
+  /**
+   * Resolve output URLs/paths for display.
+   */
+  resolveOutput(args, gitOutput) {
+    const absolutePathToPreview = this.getAbsolutePathToPreview(args);
+    if (absolutePathToPreview != null) {
+      return [absolutePathToPreview.toString()];
+    }
+    if (gitOutput != null) {
+      if (gitOutput.pullRequestUrl != null) {
+        return [gitOutput.pullRequestUrl];
+      }
+      if (gitOutput.releaseUrl != null) {
+        return [gitOutput.releaseUrl];
+      }
+      if (gitOutput.branchUrl != null) {
+        return [gitOutput.branchUrl];
+      }
+    }
+    return this.context.resolveTargetOutputs(args.target);
+  }
 };
 
 // ../cli-v2/lib/sdk/generator/GeneratorPipeline.js
@@ -1682244,6 +1682329,7 @@ var GeneratorPipeline = class {
       cliVersion: this.cliVersion
     });
     const result = await generationRunner.run({
+      task: args.task,
       target: args.target,
       apiDefinition: args.apiDefinition,
       organization: args.organization,
@@ -1682253,7 +1682339,6 @@ var GeneratorPipeline = class {
       keepContainer: args.keepContainer,
       preview: args.preview,
       outputPath: args.outputPath,
-      task: args.task,
       containerEngine: args.containerEngine
     });
     if (!result.success) {
@@ -1682282,14 +1682367,14 @@ var GeneratorPipeline = class {
       apiDefinition: args.apiDefinition,
       organization: args.organization,
       token: args.token,
+      task: args.task,
       ai: args.ai,
       audiences: args.audiences,
       version: args.version,
       shouldLogS3Url: args.shouldLogS3Url,
       preview: args.preview,
       outputPath: args.outputPath,
-      fernignorePath: args.fernignorePath,
-      task: args.task
+      fernignorePath: args.fernignorePath
     });
     if (!result.success) {
       return {
@@ -1682308,6 +1682393,8 @@ var GeneratorPipeline = class {
 
 // ../cli-v2/lib/ui/TaskGroup.js
 var TaskGroup = class _TaskGroup {
+  static MAX_DISPLAYED_LOGS_TTY = 10;
+  static URL_PATTERN = /https?:\/\/[^\s]+/;
   context;
   ttyAwareLogger;
   stream;
@@ -1682387,6 +1682474,45 @@ var TaskGroup = class _TaskGroup {
     }
     return this;
   }
+  /**
+   * Define all stages upfront so users see the full journey. All stages start as "pending".
+   */
+  setStages(taskId, stages) {
+    const task = this.tasks[taskId];
+    if (task == null) {
+      return this;
+    }
+    task.stages = stages.map((stage) => ({
+      id: stage.id,
+      status: "pending",
+      labels: stage.labels
+    }));
+    return this;
+  }
+  /**
+   * Update a stage's status by ID. The displayed label automatically changes based on the status.
+   */
+  updateStage({ taskId, stageId, status, options: options2 }) {
+    const task = this.tasks[taskId];
+    if (task == null) {
+      return this;
+    }
+    if (task.stages == null) {
+      return this;
+    }
+    const stage = task.stages.find((s9) => s9.id === stageId);
+    if (stage == null) {
+      return this;
+    }
+    stage.status = status;
+    if (options2?.detail !== void 0) {
+      stage.detail = options2.detail;
+    }
+    if (options2?.error !== void 0) {
+      stage.error = options2.error;
+    }
+    return this;
+  }
   /**
    * Called by TtyAwareLogger to get the current display.
    * This is the integration point with TtyAwareLogger.
@@ -1682449,24 +1682575,43 @@ ${source_default.dim(`Logs written to: ${logFilePath}`)}
   }
   formatTaskLine(task, spinnerFrame) {
     const name3 = source_default.bold(task.name);
-    const logLines = this.formatTaskLogs(task.logs);
+    const hasStages = task.stages != null && task.stages.length > 0;
     switch (task.status) {
-      case "pending":
+      case "pending": {
+        if (hasStages) {
+          const stageLines = this.formatTaskStages(task.stages, spinnerFrame);
+          return `${source_default.dim("\u25CB")} ${source_default.dim(name3)}${stageLines}`;
+        }
         return void 0;
+      }
       case "running": {
+        if (hasStages) {
+          const stageLines = this.formatTaskStages(task.stages, spinnerFrame, task.logs);
+          return `${spinnerFrame} ${name3}${stageLines}`;
+        }
         const step = task.currentStep != null ? `  ${source_default.dim(task.currentStep)}` : "";
-        return `${spinnerFrame} ${name3}${step}${logLines}`;
+        return `${spinnerFrame} ${name3}${step}`;
       }
       case "success": {
         const duration3 = this.formatTaskDuration(task);
+        if (hasStages) {
+          const stageLines = this.formatTaskStages(task.stages, spinnerFrame);
+          const outputLines2 = task.output != null && task.output.length > 0 ? task.output.map((output2) => `
+    ${source_default.dim("\u2192")} ${source_default.cyan(output2)}`).join("") : "";
+          return `${source_default.green("\u2713")} ${name3}${duration3}${stageLines}${outputLines2}`;
+        }
         const outputLines = task.output != null && task.output.length > 0 ? task.output.map((output2) => `
     ${source_default.dim("\u2192")} ${source_default.cyan(output2)}`).join("") : "";
-        return `${source_default.green("\u2713")} ${name3}${duration3}${logLines}${outputLines}`;
+        return `${source_default.green("\u2713")} ${name3}${duration3}${outputLines}`;
       }
       case "error": {
         const duration3 = this.formatTaskDuration(task);
+        if (hasStages) {
+          const stageLines = this.formatTaskStages(task.stages, spinnerFrame, task.logs);
+          return `${source_default.red("\u2717")} ${name3}${duration3}${stageLines}`;
+        }
         const errorLines = formatMultilineText({ text: task.error, colorFn: source_default.red.bind(source_default) });
-        return `${source_default.red("x")} ${name3}${duration3}${logLines}${errorLines}`;
+        return `${source_default.red("\u2717")} ${name3}${duration3}${errorLines}`;
       }
       case "skipped": {
         const reason = task.skipReason != null ? `skipped: ${task.skipReason}` : "skipped";
@@ -1682476,12 +1682621,92 @@ ${source_default.dim(`Logs written to: ${logFilePath}`)}
         assertNever2(task.status);
     }
   }
-  static MAX_DISPLAYED_LOGS_TTY = 10;
-  static URL_PATTERN = /https?:\/\//i;
-  formatTaskLogs(logs) {
+  /**
+   * Format the stages for a task as indented lines. When a stage fails, logs are shown under it.
+   */
+  formatTaskStages(stages, spinnerFrame, logs) {
+    if (stages == null || stages.length === 0) {
+      return "";
+    }
+    const lines = [];
+    for (const stage of stages) {
+      const icon = this.getStageIcon(stage.status, spinnerFrame);
+      let line = `
+    ${icon} ${this.getStageLabel(stage)}`;
+      if (stage.detail != null) {
+        line += `
+        ${source_default.dim(stage.detail)}`;
+      }
+      if (stage.status === "error") {
+        const logLines = this.formatTaskLogs(logs, { baseIndent: 8 });
+        if (logLines.length > 0) {
+          line += logLines;
+        }
+        if (stage.error != null) {
+          line += `
+        ${source_default.red(stage.error)}`;
+        }
+      }
+      lines.push(line);
+    }
+    return lines.join("");
+  }
+  /**
+   * Get the appropriate icon for a stage status.
+   *
+   * Uses a static arrow (▸) for running stages to avoid visual noise
+   * from having multiple spinners (the parent task already has a spinner).
+   */
+  getStageIcon(status, _spinnerFrame) {
+    switch (status) {
+      case "pending":
+        return source_default.dim("\u25CB");
+      case "running":
+        return source_default.cyan("\u25B8");
+      case "success":
+        return source_default.green("\u2713");
+      case "error":
+        return source_default.red("\u2717");
+      case "skipped":
+        return source_default.dim("\u25CB");
+      default:
+        assertNever2(status);
+    }
+  }
+  /**
+   * Get the formatted label for a stage based on its status.
+   * Uses the appropriate label from the stage's labels map.
+   */
+  getStageLabel(stage) {
+    const label = stage.labels[stage.status] ?? stage.labels.pending;
+    switch (stage.status) {
+      case "pending":
+        return source_default.dim(label);
+      case "running":
+        return source_default.cyan(label);
+      case "success":
+        return label;
+      case "error":
+        return source_default.red(label);
+      case "skipped":
+        return source_default.dim(label);
+      default:
+        assertNever2(stage.status);
+    }
+  }
+  /**
+   * Format task logs for display.
+   *
+   * @param logs - The logs to format
+   * @param options - Formatting options
+   * @param options.baseIndent - Number of spaces for base indentation (default: 8 for stage nesting)
+   */
+  formatTaskLogs(logs, options2) {
     if (logs == null || logs.length === 0) {
       return "";
     }
+    const baseIndent = options2?.baseIndent ?? 8;
+    const indentStr = " ".repeat(baseIndent);
     const shouldLimit = this.context.isTTY;
     const filteredLogs = shouldLimit ? logs.filter((log2) => log2.level !== "debug" || !_TaskGroup.URL_PATTERN.test(log2.message)) : logs;
     const logsToShow = shouldLimit && filteredLogs.length > _TaskGroup.MAX_DISPLAYED_LOGS_TTY ? filteredLogs.slice(-_TaskGroup.MAX_DISPLAYED_LOGS_TTY) : filteredLogs;
@@ -1682493,19 +1682718,23 @@ ${source_default.dim(`Logs written to: ${logFilePath}`)}
           const message = shouldLimit ? this.truncateMessage(log2.message, maxMessageLength) : log2.message;
           const icon = source_default.dim("\u2022");
           return `
-    ${icon} ${source_default.dim(message)}`;
+${indentStr}${icon} ${source_default.dim(message)}`;
         }
         case "warn":
           return formatMultilineText({
             text: log2.message,
             colorFn: source_default.yellow.bind(source_default),
-            icon: source_default.yellow("\u26A0")
+            icon: source_default.yellow("\u26A0"),
+            baseIndent,
+            continuationIndent: baseIndent + 2
           });
         case "error":
           return formatMultilineText({
             text: log2.message,
             colorFn: source_default.red.bind(source_default),
-            icon: source_default.red("\u2717")
+            icon: source_default.red("\u2717"),
+            baseIndent,
+            continuationIndent: baseIndent + 2
           });
         default:
           assertNever2(log2.level);
@@ -1682513,20 +1682742,16 @@ ${source_default.dim(`Logs written to: ${logFilePath}`)}
     }).join("");
     if (hiddenCount > 0) {
       return `
-    ${source_default.dim(`... ${hiddenCount} earlier logs hidden ...`)}${formattedLogs}`;
+${indentStr}${source_default.dim(`... ${hiddenCount} earlier logs hidden ...`)}${formattedLogs}`;
     }
     return formattedLogs;
   }
   /**
    * Maximum characters for a log message line in TTY mode.
-   * This prevents terminal line wrapping which breaks the paint/clear cycle.
-   *
-   * Account for: box prefix "│ " (2) + indent "    " (4) + icon + space "• " (2) = 8 chars
-   * Use 72 chars for message to stay under 80 col, or scale with terminal width.
    */
   getMaxLogMessageLength() {
     const terminalWidth = this.stream.columns ?? 80;
-    return Math.max(40, terminalWidth - 12);
+    return Math.max(40, terminalWidth - 16);
   }
   truncateMessage(message, maxLength) {
     const sanitized = message.replace(/[\r\n]+/g, " ").trim();
@@ -1682565,6 +1682790,171 @@ ${source_default.dim(`Logs written to: ${logFilePath}`)}
   }
 };
 
+// ../cli-v2/lib/ui/TaskStageController.js
+var TaskStageController = class {
+  taskGroup;
+  taskId;
+  stageId;
+  constructor({ taskGroup, taskId, stageId }) {
+    this.taskGroup = taskGroup;
+    this.taskId = taskId;
+    this.stageId = stageId;
+  }
+  start(detail) {
+    this.taskGroup.updateStage({
+      taskId: this.taskId,
+      stageId: this.stageId,
+      status: "running",
+      options: { detail }
+    });
+  }
+  complete(detail) {
+    this.taskGroup.updateStage({
+      taskId: this.taskId,
+      stageId: this.stageId,
+      status: "success",
+      options: { detail }
+    });
+  }
+  fail(error49) {
+    this.taskGroup.updateStage({
+      taskId: this.taskId,
+      stageId: this.stageId,
+      status: "error"
+    });
+    const task = this.taskGroup.getTask(this.taskId);
+    if (task == null) {
+      return;
+    }
+    this.taskGroup.updateTask({
+      id: this.taskId,
+      update: { status: "error", error: error49 }
+    });
+  }
+};
+
+// ../cli-v2/lib/sdk/task/SdkTask.js
+var SdkTask = class {
+  id;
+  taskGroup;
+  stage;
+  constructor({ id: id2, taskGroup }) {
+    this.id = id2;
+    this.taskGroup = taskGroup;
+    this.stage = {
+      validation: new TaskStageController({ taskId: id2, taskGroup, stageId: "validation" }),
+      generator: new TaskStageController({ taskId: id2, taskGroup, stageId: "generator" }),
+      output: new TaskStageController({ taskId: id2, taskGroup, stageId: "output" })
+    };
+  }
+  /**
+   * Get the underlying Task object for this SdkTask.
+   */
+  getTask() {
+    const task = this.taskGroup.getTask(this.id);
+    if (task == null) {
+      throw new Error(`Internal error; task '${this.id}' does not exist`);
+    }
+    return task;
+  }
+  /** Mark the task as running */
+  start(currentStep) {
+    this.taskGroup.updateTask({
+      id: this.id,
+      update: { status: "running", currentStep }
+    });
+  }
+  /** Mark the task as successfully completed */
+  complete(output2) {
+    this.taskGroup.updateTask({
+      id: this.id,
+      update: { status: "success", output: output2 }
+    });
+  }
+  /** Mark the task as failed */
+  fail(error49) {
+    this.taskGroup.updateTask({
+      id: this.id,
+      update: { status: "error", error: error49 }
+    });
+  }
+};
+
+// ../cli-v2/lib/sdk/task/SdkTaskGroup.js
+var SdkTaskGroup = class {
+  taskGroup;
+  tasks = {};
+  defaultStages = [
+    {
+      id: "validation",
+      labels: {
+        pending: "Validate API",
+        running: "Validating API...",
+        success: "Validated API"
+      }
+    },
+    {
+      id: "generator",
+      labels: {
+        pending: "Run generator",
+        running: "Running generator...",
+        success: "Generator completed"
+      }
+    },
+    {
+      id: "output",
+      labels: {
+        pending: "Write output",
+        running: "Writing output...",
+        success: "Wrote output"
+      }
+    }
+  ];
+  constructor({ context: context2 }) {
+    this.tasks = {};
+    this.taskGroup = new TaskGroup({ context: context2 });
+  }
+  addTask({ id: id2, name: name3, stageOverrides }) {
+    const displayName = name3 ?? id2;
+    this.taskGroup.addTask({ id: id2, name: displayName });
+    const stages = this.buildStages(stageOverrides);
+    this.taskGroup.setStages(id2, stages);
+    const task = new SdkTask({ taskGroup: this.taskGroup, id: id2 });
+    this.tasks[id2] = task;
+    return task;
+  }
+  getTask(id2) {
+    return this.tasks[id2];
+  }
+  async start(header) {
+    await this.taskGroup.start(header);
+  }
+  finish({ successMessage, errorMessage }) {
+    return this.taskGroup.complete({
+      successMessage,
+      errorMessage
+    });
+  }
+  /**
+   * Build stage definitions, merging any overrides with defaults.
+   */
+  buildStages(overrides) {
+    if (overrides == null) {
+      return this.defaultStages;
+    }
+    return this.defaultStages.map((stage) => {
+      const override = overrides[stage.id];
+      if (override == null) {
+        return stage;
+      }
+      return {
+        ...stage,
+        labels: { ...stage.labels, ...override }
+      };
+    });
+  }
+};
+
 // ../cli-v2/lib/commands/sdk/generate/command.js
 var GenerateCommand = class {
   async handle(context2, args) {
@@ -1682597,53 +1682987,46 @@ var GenerateCommand = class {
     });
     const token = args.local ? void 0 : await context2.getTokenOrPrompt();
     const runtime = args.local ? "local" : "remote";
-    const taskGroup = new TaskGroup({ context: context2 });
-    const skippedTargets = targets2.filter((t2) => checkResult.invalidApis.has(t2.api));
-    for (const target of skippedTargets) {
+    const taskGroup = new SdkTaskGroup({ context: context2 });
+    for (const target of targets2) {
+      const stageOverrides = target.output.git != null ? {
+        output: this.getGitOutputStageLabels(target.output.git.mode ?? "pr")
+      } : void 0;
       taskGroup.addTask({
         id: target.name,
         name: target.name,
-        status: "skipped",
-        skipReason: `API '${target.api}' has errors`
-      });
-    }
-    for (const target of validTargets) {
-      taskGroup.addTask({
-        id: target.name,
-        name: target.name
+        stageOverrides
       });
     }
+    const sdkInitialism = this.maybePluralSdks(targets2);
     await taskGroup.start({
-      title: "Generating SDKs",
+      title: `Generating ${sdkInitialism}`,
       subtitle: `org: ${workspace.sdks.org}`
     });
-    await Promise.all(validTargets.map(async (target) => {
+    await Promise.all(targets2.map(async (target) => {
+      const task = taskGroup.getTask(target.name);
+      if (task == null) {
+        throw new Error(`Internal error; task '${target.name}' not found`);
+      }
+      task.start();
+      task.stage.validation.start();
       const apiDefinition = workspace.apis[target.api];
       if (apiDefinition == null) {
-        const message = `API '${target.api}' not found in workspace`;
-        taskGroup.updateTask({
-          id: target.name,
-          update: { status: "error", error: message }
-        });
+        task.stage.validation.fail(`API not found in workspace`);
         return;
       }
-      const task = taskGroup.getTask(target.name);
-      if (task == null) {
-        throw new Error(`Internal error; task '${target.name}' not found`);
+      if (checkResult.invalidApis.has(target.api)) {
+        task.stage.validation.fail(`API is invalid`);
+        return;
       }
-      taskGroup.updateTask({
-        id: target.name,
-        update: {
-          status: "running",
-          currentStep: `${target.image}:${target.version}`
-        }
-      });
+      task.stage.validation.complete();
+      task.stage.generator.start();
       const pipelineResult = await pipeline5.run({
         organization: workspace.org,
         ai: workspace.ai,
-        task,
         target,
         apiDefinition,
+        task: task.getTask(),
         audiences: this.parseAudiences(args.audience),
         runtime,
         containerEngine: args["container-engine"] ?? "docker",
@@ -1682654,31 +1683037,35 @@ var GenerateCommand = class {
         version: args.version
       });
       if (!pipelineResult.success) {
-        taskGroup.updateTask({
-          id: target.name,
-          update: {
-            status: "error",
-            error: pipelineResult.error
-          }
-        });
+        task.stage.generator.fail(pipelineResult.error);
         return;
       }
-      taskGroup.updateTask({
-        id: target.name,
-        update: {
-          status: "success",
-          output: pipelineResult.output
-        }
-      });
+      task.stage.generator.complete();
+      task.stage.output.complete();
+      task.complete(pipelineResult.output);
     }));
-    const summary = taskGroup.complete({
-      successMessage: `Successfully generated ${this.maybePluralSdks(validTargets)}`,
-      errorMessage: `Failed to generate ${this.maybePluralSdks(validTargets)}`
+    const summary = taskGroup.finish({
+      successMessage: `Successfully generated ${sdkInitialism}`,
+      errorMessage: `Failed to generate ${sdkInitialism}`
     });
     if (summary.failedCount > 0) {
       throw CliError.exit();
     }
   }
+  validateArgs(args) {
+    if (args.output != null && !args.preview) {
+      throw new Error("The --output flag can only be used with --preview");
+    }
+    if (args["container-engine"] != null && !args.local) {
+      throw new Error("The --container-engine flag can only be used with --local");
+    }
+    if (args.group != null && args.target != null) {
+      throw new Error("The --group and --target flags cannot be used together");
+    }
+    if (args.group == null && args.target == null) {
+      throw new Error("A --target or --group must be specified");
+    }
+  }
   getTargets({ workspace, groupName, targetName }) {
     const targets2 = workspace.sdks != null ? this.filterTargetsByGroup(workspace.sdks.targets, groupName) : [];
     if (targetName != null) {
@@ -1682696,9 +1683083,6 @@ var GenerateCommand = class {
     }
     return targets2;
   }
-  /**
-   * Filter targets by group name. If no group is specified, returns all targets.
-   */
   filterTargetsByGroup(targets2, groupName) {
     if (groupName == null) {
       return targets2;
@@ -1682714,23 +1683098,33 @@ var GenerateCommand = class {
       audiences
     };
   }
-  validateArgs(args) {
-    if (args.output != null && !args.preview) {
-      throw new Error("The --output flag can only be used with --preview");
-    }
-    if (args["container-engine"] != null && !args.local) {
-      throw new Error("The --container-engine flag can only be used with --local");
-    }
-    if (args.group != null && args.target != null) {
-      throw new Error("The --group and --target flags cannot be used together");
-    }
-    if (args.group == null && args.target == null) {
-      throw new Error("A --target or --group must be specified");
-    }
-  }
   maybePluralSdks(targets2) {
     return targets2.length === 1 ? "SDK" : "SDKs";
   }
+  getGitOutputStageLabels(mode) {
+    switch (mode) {
+      case "push":
+        return {
+          pending: "Push to repository",
+          running: "Pushing to repository...",
+          success: "Pushed to repository"
+        };
+      case "release":
+        return {
+          pending: "Create release",
+          running: "Creating release...",
+          success: "Created release"
+        };
+      case "pr":
+        return {
+          pending: "Create pull request",
+          running: "Creating pull request...",
+          success: "Created pull request"
+        };
+      default:
+        assertNever2(mode);
+    }
+  }
 };
 function addGenerateCommand(cli) {
   const cmd = new GenerateCommand();
@@ -1713625,7 +1714019,7 @@ var CliContext = class {
     if (false) {
       this.logger.error("CLI_VERSION is not defined");
     }
-    return "3.64.5";
+    return "3.64.6";
   }
   getCliName() {
     if (false) {
@@ -1714384,7 +1714778,13 @@ async function loadAndUpdateGenerators({
         );
       }
       const generatorName = generator.get("name");
-      const normalizedGeneratorName = getGeneratorNameOrThrow(generatorName, context2);
+      const normalizedGeneratorName = normalizeGeneratorName(generatorName);
+      if (normalizedGeneratorName == null) {
+        context2.logger.warn(
+          `Skipping unrecognized generator: ${generatorName}. The generator will not be upgraded.`
+        );
+        continue;
+      }
       const normalizedGeneratorFilter = generatorFilter != null ? addDefaultDockerOrgIfNotPresent(generatorFilter) : void 0;
       if (normalizedGeneratorFilter != null && normalizedGeneratorName !== normalizedGeneratorFilter) {
         context2.logger.debug(
@@ -1716739,7 +1717139,7 @@ var import_path56 = __toESM(require("path"), 1);
 var LOCAL_STORAGE_FOLDER4 = ".fern-dev";
 var LOGS_FOLDER_NAME = "logs";
 function getCliSource() {
-  const version7 = "3.64.5";
+  const version7 = "3.64.6";
   return `cli@${version7}`;
 }
 var DebugLogger = class {

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.64.5",
+  "version": "3.64.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fern-api/fern.git",