.start command should prompt for priority (#141)

* Redesigned the .start command to prompt priority selection

New Flow:
  - .start <title> → Priority selection UI → Incident creation
  - .start (no title) → Error with usage guidance
  - Removed legacy default P3 creation

  Features Added:
  - Interactive priority selection with P1-P5 options
  - Cancel option (CANCEL) to abort incident creation
  - Timeout handling (5 minutes for priority selection)
  - Enhanced Slack UI with clear priority descriptions

  Implementation Details:
  - Added PendingIncident state management system
  - Created incident-start.ts handler for priority selection flow
  - Extended CommPlatform interface with sendPrioritySelection()
  - Updated Slack adapter with prioritySelectionBlocks() UI
  - Modified listeners to handle P1-P5 and CANCEL responses

* Add configurable priority selection for .start command

Add requirePrioritySelection config option to enable/disable interactive priority selection flow for incident creation.

  When enabled (requirePrioritySelection: true):
  - .start <title> triggers priority selection UI before incident creation
  - Users choose P1-P5 or CANCEL to proceed

  When disabled (requirePrioritySelection: false):
  - .start <title> creates incident immediately with default priority (legacy behavior)

  Alias commands (.critical, .high, .medium, etc.) always bypass priority selection in both modes.

* Revert changes to package.lock.json and package.json

* Implement button-based priority selection with threaded UI

- Add shortDescription field to Priority type for concise descriptions
- Replace text-based priority selection with interactive buttons
- Implement threaded priority selection UI instead of main channel
- Add button click handlers for priority selection and cancellation
- Update Slack adapter to handle interactive button events
- Make messageId required for priority selection threading
- Add debug logging for incident resolution state tracking

* Fix linting issues

* Fix linting errors

* Commting package-lock.json and package.json

Only dev dependency changes.

* Removed @biomejs/cli-darwin-arm64

* extract priority selection cleanup logic and UX improvements

* UX feedback improvements

* Add tests to incident start implementation changes

Final Status: Complete Scenario-Based Test Coverage

All Issues Resolved:
  - ✅ Tests: 643 tests passing (increased from 637)
  - ✅ Linting: No errors remaining
  - ✅ TypeScript: Clean compilation
  - ✅ Code Style: All lint fixes applied

Comprehensive Coverage Achieved for All 3 Core Scenarios:

📋 Scenario 1: Start incident → Times out

  - ✅ NEW: Timeout mechanism test with timer mocking
  - ✅ NEW: Cleanup verification (emoji + deletion + thread reply)
  - ✅ NEW: Pending incident removal verification

📋 Scenario 2: Start incident → Cancel it

  - ✅ Manual cancellation (existing)
  - ✅ Fallback cancellation (existing)
  - ✅ Error handling (existing)

📋 Scenario 3: Start incident → Choose priority

  - ✅ P1 priority (existing comprehensive test)
  - ✅ NEW: P2 priority selection
  - ✅ NEW: P3 priority selection
  - ✅ NEW: P4 priority selection
  - ✅ NEW: P5 priority selection
  - ✅ NEW: Duplicate pending incident rejection

* Update P3 to show as a red button

Also updates the emoji, as the previous one wasn't visible enough on a red background.

* Move timeout to the config file and change to 1 minute

* Disable aliases if requirePrioritySelection is true

* bump version to 3.3.0

* Remove duplicated lint declarations

* Delete PR_DESCRIPTION.md

* Set priority selection timeout to 2 minutes

Remove vip-priorities.js

Author: freibergergarcia

config/priorities.ts

@@ -2,6 +2,8 @@ import type { PriorityConfig } from "./types.js";
 
 export const priorityConfig: PriorityConfig = {
 	default: 2,
+	requirePrioritySelection: false,
+	prioritySelectionTimeoutSeconds: 2 * 60,
 	priorities: {
 		1: {
 			name: "P1",

config/types.ts

@@ -130,12 +130,15 @@ export type PriorityConfig = {
 	documentationUrl?: string;
 	default: number;
 	defaultLow?: number;
+	requirePrioritySelection?: boolean;
+	prioritySelectionTimeoutSeconds?: number;
 	priorities: {
 		[key: number]: {
 			name: string;
 			url?: string;
 			emoji: string;
 			description: string;
+			shortDescription?: string;
 			aliases: string[];
 			nag?: NagConfig;
 			reportRequired?: boolean;

lib/boundary/comm-platform.ts

@@ -227,6 +227,15 @@ export interface CommPlatform {
 		config: PriorityConfig,
 		messageId?: string,
 	): Promise<unknown>;
+	sendPrioritySelection(
+		room: string,
+		config: PriorityConfig,
+		messageId: string,
+	): Promise<{ ts?: string }>;
+	deletePrioritySelectionMessage(
+		room: string,
+		messageId: string,
+	): Promise<unknown>;
 	sendPriorityUpdated(
 		room: string,
 		priority: number,

lib/boundary/hubot/adapters/slack.ts

@@ -19,6 +19,14 @@ import {
 } from "../../../core/string.js";
 import { isIncidentActive } from "../../../data/incident.js";
 import { LogType } from "../../../data/schema/log-entry-schema.js";
+import {
+	handleCancelSelection,
+	handlePrioritySelection,
+} from "../handlers/incident-start.js";
+import {
+	priorityCanceledConfirmationBlocks,
+	prioritySelectedConfirmationBlocks,
+} from "./slack/blocks.js";
 import {
 	affectedAddedBlocks,
 	affectedBlocks,
@@ -41,6 +49,7 @@ import {
 	newBreakingBlocks,
 	notesBlocks,
 	priorityBlocks,
+	prioritySelectionBlocks,
 	resolvedBlocks,
 	richTextBlock,
 	statusAllActiveBlocks,
@@ -89,7 +98,11 @@ import type { DatetimeIso9075 } from "../../../core/date.js";
 import type { Blocker } from "../../../data/blocker.js";
 import type { Incident, IncidentOverview } from "../../../data/incident.js";
 import type { LogEntry } from "../../../data/log.js";
-import type { ChatRoomUid, ChatUserId } from "../../../types/index.js";
+import type {
+	BreakingBot,
+	ChatRoomUid,
+	ChatUserId,
+} from "../../../types/index.js";
 import type { CommPlatform } from "../../comm-platform.js";
 import type { IssueTracker } from "../../issue-tracker.js";
 
@@ -128,18 +141,42 @@ export class Slack extends Adapter implements CommPlatform {
 			`SLACK: creating #${channelName} with users ${initialUserIds.join(",")}`,
 		);
 
-		const response = await this.#webClient.conversations.create({
-			name: channelName,
-		});
+		let finalChannelName = channelName;
+		let response: unknown;
+
+		try {
+			response = await this.#webClient.conversations.create({
+				name: finalChannelName,
+			});
+		} catch (error: unknown) {
+			// Handle name_taken error with timestamp fallback
+			const slackError = error as { data?: { error?: string } };
+			if (slackError?.data?.error === "name_taken") {
+				finalChannelName = `${channelName}-${Date.now()}`;
+				this.robot.logger.warn(
+					`SLACK: Channel #${channelName} already exists, retrying with #${finalChannelName}`,
+				);
+
+				response = await this.#webClient.conversations.create({
+					name: finalChannelName,
+				});
+			} else {
+				throw error;
+			}
+		}
 
-		const { channel } = response;
+		const { channel } = response as {
+			channel?: { id?: string; name?: string };
+		};
 
 		if (!channel || !channel.id || !channel.name) {
-			this.robot.logger.error(`SLACK: failed create channel ${channelName}`);
+			this.robot.logger.error(
+				`SLACK: failed create channel ${finalChannelName}`,
+			);
 			return {};
 		}
 
-		this.robot.logger.debug(`SLACK: created channel ${channelName}`);
+		this.robot.logger.debug(`SLACK: created channel ${finalChannelName}`);
 
 		if (initialUserIds.length > 0) {
 			this.#webClient.conversations.invite({
@@ -939,6 +976,97 @@ export class Slack extends Adapter implements CommPlatform {
 		);
 	}
 
+	async sendPrioritySelection(
+		channel: string,
+		config: PriorityConfig,
+		timestamp: string,
+	): Promise<{ ts?: string }> {
+		const result = await this.#replyThreaded(
+			channel,
+			prioritySelectionBlocks(config),
+			"Breaking process started. Please select a priority using the buttons below.",
+			timestamp,
+		);
+		return result || {};
+	}
+
+	async updatePrioritySelectionMessage(
+		channel: string,
+		messageTimestamp: string,
+		selectedPriority: number,
+		config: PriorityConfig,
+		success = true,
+		errorMessage?: string,
+	): Promise<unknown> {
+		const blocks = prioritySelectedConfirmationBlocks(
+			selectedPriority,
+			config,
+			success,
+			errorMessage,
+		);
+		const text = success
+			? `Priority ${selectedPriority} selected. Incident created successfully!`
+			: `Priority ${selectedPriority} selected. Error: ${errorMessage || "Failed to create incident"}`;
+
+		return this.#webClient.chat.update({
+			channel,
+			ts: messageTimestamp,
+			blocks,
+			text,
+		});
+	}
+
+	async updatePrioritySelectionMessageCanceled(
+		channel: string,
+		messageTimestamp: string,
+	): Promise<unknown> {
+		const blocks = priorityCanceledConfirmationBlocks();
+		const text = "Incident creation canceled.";
+
+		try {
+			return await this.#webClient.chat.update({
+				channel,
+				ts: messageTimestamp,
+				blocks,
+				text,
+			});
+		} catch (error: unknown) {
+			// If we can't update the message (too old, not our message, etc.),
+			// just log the error and continue - the emoji reaction will still indicate cancellation
+			const slackError = error as {
+				data?: { error?: string };
+				message?: string;
+			};
+			this.robot.logger.warn(
+				`Failed to update priority selection message: ${slackError?.data?.error || slackError?.message || "Unknown error"}`,
+			);
+			return Promise.resolve();
+		}
+	}
+
+	async deletePrioritySelectionMessage(
+		channel: string,
+		messageTimestamp: string,
+	): Promise<unknown> {
+		try {
+			return await this.#webClient.chat.delete({
+				channel,
+				ts: messageTimestamp,
+			});
+		} catch (error: unknown) {
+			// If we can't delete the message, just log the error and continue
+			// The emoji reaction and thread reply will still indicate what happened
+			const slackError = error as {
+				data?: { error?: string };
+				message?: string;
+			};
+			this.robot.logger.warn(
+				`Failed to delete priority selection message: ${slackError?.data?.error || slackError?.message || "Unknown error"}`,
+			);
+			return Promise.resolve();
+		}
+	}
+
 	sendPriorityUpdated(
 		channel: string,
 		newPriority: number,
@@ -1507,6 +1635,96 @@ export class Slack extends Adapter implements CommPlatform {
 			this.robot.receive(new LeaveMessage(user, null, event.ts));
 		});
 
+		this.#socketClient.on("interactive", async (payload) => {
+			await payload.ack();
+
+			this.robot.logger.debug(
+				"Interactive payload received:",
+				JSON.stringify(payload, null, 2),
+			);
+
+			const { body } = payload;
+			if (!body) {
+				this.robot.logger.error("No body in interactive payload");
+				return;
+			}
+
+			if (body.type === "block_actions") {
+				for (const action of body.actions || []) {
+					if (action.action_id?.startsWith("select_priority_")) {
+						const priority = Number(action.value);
+						const channel = body.channel?.id;
+						const userId = body.user?.id;
+						const messageTs = body.message?.ts;
+
+						this.robot.logger.debug(
+							`Priority ${priority} selected by user ${userId}`,
+						);
+
+						try {
+							// Update message to show selection immediately
+							await this.updatePrioritySelectionMessage(
+								channel,
+								messageTs,
+								priority,
+								(this.robot as BreakingBot).config.priorities,
+								true,
+							);
+
+							// Create the incident
+							await handlePrioritySelection(
+								this.robot as BreakingBot,
+								channel,
+								priority,
+								userId,
+								messageTs,
+							);
+						} catch (error) {
+							this.robot.logger.error(
+								"Error handling priority selection:",
+								error,
+							);
+
+							// Update message to show error
+							await this.updatePrioritySelectionMessage(
+								channel,
+								messageTs,
+								priority,
+								(this.robot as BreakingBot).config.priorities,
+								false,
+								error instanceof Error
+									? error.message
+									: "Unknown error occurred",
+							);
+						}
+					} else if (action.action_id === "cancel_priority_selection") {
+						const channel = body.channel?.id;
+						const userId = body.user?.id;
+						const messageTs = body.message?.ts;
+
+						this.robot.logger.debug(
+							`Priority selection cancelled by user ${userId}`,
+						);
+
+						try {
+							// Use consistent cancellation behavior (same as timeout)
+							await handleCancelSelection(
+								this.robot as BreakingBot,
+								channel,
+								userId,
+								messageTs,
+							);
+						} catch (error) {
+							this.robot.logger.error(
+								"Error handling priority cancellation:",
+								error,
+							);
+						}
+					}
+				}
+			}
+		});
+
 		await this.#socketClient.start();
 	}