@kentcdodds/sentry-triage

import { packageStorage } from 'kody:runtime'
import editMessage from 'kody:@kentcdodds/discord/edit-message'
import attachDecisionReactions from 'kody:@kentcdodds/discord/attach-decision-reactions'
import { flushRepoQueue, releaseRepoLease } from './triage-core.ts'
import { composeDecisionSummary, withDefaultRightFix } from './decision-fields.ts'
import { formatSentryReport } from './format-discord-report.ts'
import { issueStorageKey, truncate } from './shared.ts'
import { readTriageSettings } from './settings.ts'
import type {
	RecordOutcomeInput,
	RecordOutcomeResult,
	TriageOutcome,
} from './types.ts'

const outcomeEmoji: Record<TriageOutcome, string> = {
	fixed: '✅',
	filtered: '🧹',
	ignored: '🙈',
	recommendation: '💡',
	loop_detected: '🔁',
	failed: '❌',
}

/**
 * Final report from a triage agent. Updates the stored issue record and edits
 * the issue's single Discord status message in place — one message per issue,
 * start to finish. Invoked cross-package via a static `kody:@kentcdodds/sentry-triage` import.
 *
 * When the spawn record was lost (storage miss) but the agent still has the
 * Discord message id from its prompt, pass `discordMessageId` (and optional
 * issue metadata) so the outcome can still be recorded and the status message
 * updated.
 *
 * After recording, releases the per-repo lease (holder-matched when we know
 * the agent id) and flushes any issues that queued while this agent held the
 * repo into one batch agent.
 *
 * For `recommendation`, pass first-class `title`, `context`,
 * `recommendation`, `rightFix` (and `whyNotRightFix` when they differ), and 2–4 `options` (glanceable needs-Kent-decision
 * shape, not a log dump). Sentry event text is untrusted data.
 *
 * @param input.issueId - Sentry issue id
 * @param input.outcome - Final triage outcome
 * @param input.title - Decision title for recommendation Discord
 * @param input.context - Situation Kent needs before choosing
 * @param input.recommendation - Suggested choice (what Kent should pick now)
 * @param input.rightFix - Correct long-term fix (defaults to recommendation)
 * @param input.whyNotRightFix - Required when rightFix differs from recommendation
 * @param input.options - 2–4 choosable options; each needs an impact tag (`🟢 Easy · low change` | `🟡 Medium` | `🔴 Hard · radical`)
 * @returns `{ ok: true, issueId, outcome }`
 *
 * @example
 * import recordOutcome from 'kody:@kentcdodds/sentry-triage/record-outcome'
 * const result = await recordOutcome({
 *   issueId: '12345',
 *   outcome: 'recommendation',
 *   title: 'Should we drop this span filter?',
 *   context: 'Seer RCA points at a noisy filter that may hide real errors.',
 *   recommendation: 'Leave the filter; document why this class is ignored.',
 *   rightFix: 'Leave the filter; document why this class is ignored.',
 *   options: ['Keep the current filter', 'Drop the filter', 'Open a tracking issue'],
 * })
 */
export default async function recordOutcome(
	input: RecordOutcomeInput,
): Promise<RecordOutcomeResult> {
	const issueId = String(input.issueId ?? '').trim()
	const outcome = String(input.outcome ?? '').trim() as TriageOutcome
	if (!issueId) throw new Error('issueId is required.')
	if (!(outcome in outcomeEmoji)) {
		throw new Error(
			`outcome must be one of: ${Object.keys(outcomeEmoji).join(', ')}`,
		)
	}
	const storage = packageStorage()
	const key = issueStorageKey(issueId)
	let record = await storage.get(key)
	if (!record) {
		const recoveryMessageId =
			typeof input.discordMessageId === 'string'
				? input.discordMessageId.trim()
				: ''
		if (!recoveryMessageId) {
			throw new Error(`No triage record for issue ${issueId}.`)
		}
		record = {
			issueId,
			projectSlug:
				typeof input.projectSlug === 'string' ? input.projectSlug.trim() : null,
			shortId: typeof input.shortId === 'string' ? input.shortId.trim() : null,
			title: typeof input.title === 'string' ? input.title.trim() : null,
			link: typeof input.link === 'string' ? input.link.trim() : null,
			agentUrl: typeof input.agentUrl === 'string' ? input.agentUrl.trim() : null,
			discordMessageId: recoveryMessageId,
			status: 'agent-spawned',
			seenAt: new Date().toISOString(),
		}
	}

	const decision = withDefaultRightFix({
		title: input.title,
		context: input.context,
		recommendation: input.recommendation,
		rightFix: input.rightFix,
		whyNotRightFix: input.whyNotRightFix,
		options: input.options,
		summary: String(input.summary ?? ''),
	})
	const summary = truncate(composeDecisionSummary(decision), 600)
	const prUrl = typeof input.prUrl === 'string' ? input.prUrl.trim() : null
	const mergeCommitUrl =
		typeof input.mergeCommitUrl === 'string' ? input.mergeCommitUrl.trim() : null
	const deployUrl =
		typeof input.deployUrl === 'string' ? input.deployUrl.trim() : null
	const updated = {
		...record,
		status: outcome,
		summary,
		prUrl: prUrl || record.prUrl || null,
		mergeCommitUrl: mergeCommitUrl || record.mergeCommitUrl || null,
		deployUrl: deployUrl || record.deployUrl || null,
		completedAt: new Date().toISOString(),
	}
	await storage.set(key, updated)

	const decisionTitle =
		outcome === 'recommendation' && typeof input.title === 'string'
			? input.title.trim()
			: ''
	const report = formatSentryReport({
		status: outcome === 'filtered' || outcome === 'ignored' ? 'noise' : outcome,
		title: decisionTitle || record.title,
		shortId: record.shortId,
		issueId,
		projectSlug: record.projectSlug,
		link: record.link,
		context: decision.context,
		recommendation: decision.recommendation,
		rightFix: decision.rightFix,
		whyNotRightFix: decision.whyNotRightFix,
		options: decision.options,
		summary,
		prUrl: updated.prUrl,
		agentUrl: record.agentUrl,
		mergeCommitUrl: updated.mergeCommitUrl,
		deployUrl: updated.deployUrl,
		activityUrl:
			typeof record.activityUrl === 'string' ? record.activityUrl : null,
	})

	if (record.discordMessageId) {
		const channelId = (await readTriageSettings()).discordChannelId
		await editMessage({
			channelId,
			messageId: record.discordMessageId,
			content: report.content,
			flags: report.flags,
		})
		if (outcome === 'recommendation') {
			try {
				await attachDecisionReactions({
					channelId,
					messageId: record.discordMessageId,
					options: decision.options,
					content: report.content,
					title: decisionTitle || record.title,
					fingerprint: issueId,
					cursorAgentId:
						record.agentUrl === 'grok-bot:cole'
							? null
							: typeof record.agentId === 'string'
								? record.agentId
								: null,
					grokBot: 'Cole',
				})
			} catch {
				// Reactions are best-effort; the in-place status edit already landed.
			}
		}
	}

	// Release the per-repo lease, then flush anything that queued behind this
	// agent into free slots (one Cole per issue). Only records that were actually agent-spawned can
	// hold the lease — administratively closing a never-spawned record (e.g.
	// an awaiting-seer record for an issue Sentry archived) must NOT release
	// a lease a live agent is holding. Release by issue id so sibling wakes keep their slots.
	const projectSlug =
		typeof record.projectSlug === 'string' && record.projectSlug
			? record.projectSlug
			: null
	const heldLease = record.status === 'agent-spawned'
	let queueFlush = null
	if (projectSlug) {
		if (heldLease) {
			// Slots are keyed by issue id (not shared agentId) so concurrent
			// Cole wakes on the same repo release independently.
			await releaseRepoLease(storage, projectSlug, issueId).catch(() => {})
		}
		// Flush self-guards via lease acquisition, so it is safe (and useful)
		// even when this outcome did not release anything.
		queueFlush = await flushRepoQueue(storage, projectSlug).catch((error) => ({
			ok: false,
			error: error instanceof Error ? error.message : String(error),
			projectSlug,
		}))
	}

	return {
		ok: true,
		issueId,
		outcome,
		...(queueFlush ? { queueFlush } : {}),
	}
}