@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/review/runner.js

@@ -0,0 +1,255 @@
+import { createHash } from 'crypto';
+import fs from 'fs';
+import { logger } from '../../core/logging.js';
+import { escapeRegExp } from '../../core/regexp.js';
+import { runMultiFocusReviewEngine } from './engines/multi-focus.js';
+import { getEnabledReviewModels } from './engines/shared.js';
+import {} from './engines/types.js';
+import { buildAnnotatedDiff, buildDiffSection } from './diff.js';
+import { buildMultiFocusSharedPrompt } from './multi-focus-prompt.js';
+import { loadStandardsSection } from './prompt.js';
+import { isReviewModePilotRepository, runReviewModePass } from './review-mode.js';
+const REVIEW_GUIDANCE_FILES = ['AGENTS.md', 'CLAUDE.md', 'GEMINI.md'];
+const MASKED_PR_AUTHOR_LABEL = 'PR author';
+const OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH = 96;
+function getGuidanceFilePresence(workspaceDir) {
+    return Object.fromEntries(REVIEW_GUIDANCE_FILES.map((fileName) => [
+        fileName,
+        fs.existsSync(`${workspaceDir}/${fileName}`),
+    ]));
+}
+function maskPrAuthorInConversation(prConversation, prAuthor) {
+    const normalizedPrAuthor = prAuthor.trim();
+    if (!prConversation || !normalizedPrAuthor || normalizedPrAuthor === 'unknown') {
+        return prConversation;
+    }
+    const authorLinePattern = new RegExp(`(^- Author:\\s*)${escapeRegExp(normalizedPrAuthor)}(?=\\s*$)`, 'gim');
+    return {
+        ...prConversation,
+        promptText: prConversation.promptText.replace(authorLinePattern, `$1${MASKED_PR_AUTHOR_LABEL}`),
+    };
+}
+function buildEnginePrompt({ input, diffSection, truncated, standardsSection, prConversation, }) {
+    const sharedPromptArgs = {
+        repoOwner: input.owner,
+        repoName: input.repo,
+        prNumber: input.prNumber,
+        prTitle: input.prTitle,
+        prBody: input.prBody,
+        prConversation,
+        prAuthor: 'unknown',
+        baseRef: input.baseBranch,
+        headRef: input.branch,
+        diffSection,
+        truncated,
+        standardsSection,
+    };
+    return {
+        prompt: buildMultiFocusSharedPrompt(sharedPromptArgs),
+    };
+}
+function getMissingRequiredReviewModels(availableModels, requiredReviewModels = []) {
+    return requiredReviewModels.filter((model) => !availableModels.includes(model));
+}
+function toOpenRouterSessionSegment(value, fallback) {
+    const normalized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, OPENROUTER_SESSION_REPO_SEGMENT_MAX_LENGTH);
+    return normalized || fallback;
+}
+export function buildOpenRouterReviewSessionId({ owner, repo, prNumber, prompt, }) {
+    const repoSegment = toOpenRouterSessionSegment(`${owner}-${repo}`, 'repo');
+    const promptHash = createHash('sha256').update(prompt).digest('hex').slice(0, 32);
+    return `doistbot-review-${repoSegment}-pr-${prNumber}-${promptHash}`;
+}
+export async function runSharedReview(input) {
+    const { annotatedFiles, lineLookup } = buildAnnotatedDiff(input.files);
+    if (annotatedFiles.length === 0) {
+        logger.info('No diff generated, skipping review');
+        return {
+            status: 'skipped',
+            reason: 'no_diff',
+            availableModels: [],
+            metricModels: [],
+            providerFailures: [],
+        };
+    }
+    const { diffSection, truncated } = buildDiffSection(annotatedFiles);
+    if (!diffSection.trim()) {
+        logger.info('Diff section empty, skipping review');
+        return {
+            status: 'skipped',
+            reason: 'empty_diff',
+            availableModels: [],
+            metricModels: [],
+            providerFailures: [],
+        };
+    }
+    const configuredAvailableModels = getEnabledReviewModels(input.apiKeys, input.reviewModelsEnabled);
+    if (configuredAvailableModels.length === 0) {
+        logger.error('No enabled review models with API keys are available, skipping review', {
+            review_models_enabled: input.reviewModelsEnabled,
+            review_focuses_enabled: input.reviewFocusesEnabled,
+        });
+        return {
+            status: 'skipped',
+            reason: 'no_models',
+            availableModels: [],
+            metricModels: [...input.reviewModelsEnabled],
+            mode: 'multi_focus',
+            providerFailures: [],
+        };
+    }
+    const missingRequiredModels = getMissingRequiredReviewModels(configuredAvailableModels, input.requiredReviewModels);
+    if (missingRequiredModels.length > 0) {
+        logger.error('Required review models with API keys are unavailable, skipping review', {
+            review_models_enabled: input.reviewModelsEnabled,
+            review_focuses_enabled: input.reviewFocusesEnabled,
+            available_models: configuredAvailableModels,
+            missing_required_models: missingRequiredModels,
+        });
+        return {
+            status: 'skipped',
+            reason: 'no_models',
+            availableModels: configuredAvailableModels,
+            metricModels: [...input.reviewModelsEnabled],
+            mode: 'multi_focus',
+            providerFailures: [],
+        };
+    }
+    const prConversationPromise = input.loadPrConversation?.() ?? Promise.resolve(undefined);
+    const prConversation = maskPrAuthorInConversation(await prConversationPromise, input.prAuthor);
+    const standardsSection = loadStandardsSection();
+    const { prompt } = buildEnginePrompt({
+        input,
+        diffSection,
+        truncated,
+        standardsSection,
+        prConversation,
+    });
+    logger.info('Review prompt prepared', {
+        engine: 'multi_focus',
+        prompt_length: prompt.length,
+        pr_body_length: input.prBody.trim().slice(0, 4000).length,
+        pr_conversation_length: prConversation?.promptText.trim().length ?? 0,
+        diff_length: diffSection.length,
+        standards_length: standardsSection.length,
+        annotated_files_count: annotatedFiles.length,
+        files_in_pr_count: input.files.length,
+        diff_truncated: truncated,
+        guidance_files: getGuidanceFilePresence(input.workspaceDir),
+    });
+    input.onProgress?.({ type: 'prompt_prepared', fileCount: annotatedFiles.length });
+    const engineContext = {
+        owner: input.owner,
+        repo: input.repo,
+        prNumber: input.prNumber,
+        workspaceDir: input.workspaceDir,
+        apiKeys: input.apiKeys,
+        reviewModelsEnabled: input.reviewModelsEnabled,
+        ...(input.reviewModelsByFocus ? { reviewModelsByFocus: input.reviewModelsByFocus } : {}),
+        ...(input.geminiFallbackFocuses
+            ? { geminiFallbackFocuses: input.geminiFallbackFocuses }
+            : {}),
+        ...(input.reviewSummaryModel ? { reviewSummaryModel: input.reviewSummaryModel } : {}),
+        openRouterSessionId: buildOpenRouterReviewSessionId({
+            owner: input.owner,
+            repo: input.repo,
+            prNumber: input.prNumber,
+            prompt,
+        }),
+    };
+    const reviewModeContext = isReviewModePilotRepository(input.owner, input.repo)
+        ? input.reviewMode
+        : undefined;
+    if (reviewModeContext)
+        input.onProgress?.({ type: 'review_mode' });
+    const [{ review, availableModels, metricModels, mode, providerFailures }, reviewModeResult] = await Promise.all([
+        runMultiFocusReviewEngine({
+            ctx: engineContext,
+            prompt,
+            standardsSection,
+            lineLookup,
+            prTitle: input.prTitle,
+            prBody: input.prBody,
+            lowPriorityFindingPlacement: input.lowPriorityFindingPlacement,
+            enabledFocuses: input.reviewFocusesEnabled,
+            onProgress: input.onProgress,
+        }),
+        reviewModeContext
+            ? runReviewModePass({
+                owner: input.owner,
+                repo: input.repo,
+                prTitle: input.prTitle,
+                prBody: input.prBody,
+                conversation: prConversation?.promptText,
+                files: input.files,
+                diff: diffSection,
+                diffTruncated: truncated,
+                apiKeys: input.apiKeys,
+                reviewModelsEnabled: input.reviewModelsEnabled,
+                reviewSummaryModel: input.reviewSummaryModel,
+                workspaceDir: input.workspaceDir,
+                context: reviewModeContext,
+            })
+            : undefined,
+    ]);
+    if (availableModels.length === 0) {
+        logger.error('No enabled review models with API keys are available, skipping review', {
+            review_models_enabled: input.reviewModelsEnabled,
+        });
+        return {
+            status: 'skipped',
+            reason: 'no_models',
+            availableModels,
+            metricModels,
+            mode,
+            providerFailures,
+        };
+    }
+    if (!review) {
+        logger.warn('Review returned no results, skipping');
+        return {
+            status: 'skipped',
+            reason: 'no_review',
+            availableModels,
+            metricModels,
+            mode,
+            providerFailures,
+        };
+    }
+    if (!review.summary.trim() && review.comments.length === 0) {
+        logger.warn('Review returned empty content, skipping');
+        return {
+            status: 'skipped',
+            reason: 'empty_review',
+            availableModels,
+            metricModels,
+            mode,
+            providerFailures,
+        };
+    }
+    if (reviewModeResult) {
+        review.reviewMode = reviewModeResult.classification;
+        if (reviewModeResult.note) {
+            review.summary = `${review.summary.trim()}\n\n${reviewModeResult.note}`.trim();
+        }
+    }
+    logger.info('Review completed', {
+        engine: 'multi_focus',
+        mode,
+        comments_count: review.comments.length,
+    });
+    input.onProgress?.({ type: 'formatting_results' });
+    return {
+        status: 'reviewed',
+        review,
+        availableModels,
+        metricModels,
+        mode,
+        providerFailures,
+    };
+}

package/sandbox/dist/tasks/review/severity.js

@@ -0,0 +1,5 @@
+const SEVERITY_PATTERN = /\[P([0-3])\]/i;
+export function parseSeverity(body) {
+    const match = body.match(SEVERITY_PATTERN);
+    return match ? `P${match[1]}` : null;
+}

package/sandbox/dist/tasks/review/summary-model.js

@@ -0,0 +1,271 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { WORKSPACE_DIR } from '../../core/environment.js';
+import { logger } from '../../core/logging.js';
+import { DEFAULT_GEMINI_FLASH_MODEL, DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS, invokePiPrompt, PI_PROVIDER_BY_DOISTBOT_PROVIDER, } from '../../core/pi.js';
+import { genAiProviderName, withPhase } from '../../core/tracing.js';
+import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { extractJsonCandidatesFromResponse } from '../../providers/helpers.js';
+const REVIEW_SUMMARY_TIMEOUT_MS = 5 * 60 * 1000;
+const DEFAULT_REVIEW_SUMMARY_THINKING_LEVEL = 'medium';
+// One model span per summary attempt; a fallback chain emits one span per model.
+const SUMMARY_PHASE = 'review.summary';
+const DIFF_SIDE = {
+    LEFT: 'LEFT',
+    RIGHT: 'RIGHT',
+};
+function getWorkspaceDir() {
+    return WORKSPACE_DIR;
+}
+function getReviewSummaryModelNameForLog({ provider, piProviderId, modelName, }) {
+    if (modelName) {
+        return modelName;
+    }
+    const resolvedPiProviderId = piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[provider];
+    return ((resolvedPiProviderId === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[provider] : undefined) ??
+        DEFAULT_PI_MODELS[provider]);
+}
+export function buildGeminiFlashReviewSummaryModel(credential) {
+    if (credential === undefined) {
+        return undefined;
+    }
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return undefined;
+    }
+    return {
+        provider: 'gemini',
+        credential,
+        modelName: DEFAULT_GEMINI_FLASH_MODEL,
+    };
+}
+function failedReviewSummaryRequest({ reason, error, timedOut, durationMs, outputChars, }) {
+    return {
+        status: 'failed',
+        reason,
+        ...(error ? { error } : {}),
+        ...(timedOut !== undefined ? { timedOut } : {}),
+        ...(durationMs !== undefined ? { durationMs } : {}),
+        ...(outputChars !== undefined ? { outputChars } : {}),
+    };
+}
+function getRequestFailureReason(result) {
+    if (result.timedOut) {
+        return 'timeout';
+    }
+    return result.error.toLowerCase().includes('did not produce an assistant response')
+        ? 'no_assistant_response'
+        : 'request_failed';
+}
+export async function requestReviewSummary({ credential, provider = 'zai', modelName, prompt, workspaceDir, }) {
+    const resolvedCredential = resolveReviewProviderCredential(credential);
+    if (!resolvedCredential) {
+        return failedReviewSummaryRequest({ reason: 'missing_credential' });
+    }
+    const resolvedModelName = modelName ?? resolvedCredential.modelName;
+    const logModelName = getReviewSummaryModelNameForLog({
+        provider,
+        piProviderId: resolvedCredential.piProviderId,
+        modelName: resolvedModelName,
+    });
+    // Span wraps the actual model invoke (after the credential check), so a
+    // missing-credential config error returns before any span and never shows a fake model attempt.
+    return withPhase(SUMMARY_PHASE, {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': genAiProviderName(provider),
+        'gen_ai.request.model': logModelName,
+    }, async (span) => {
+        const result = await runReviewSummaryRequest({
+            provider,
+            resolvedCredential,
+            resolvedModelName,
+            logModelName,
+            prompt,
+            workspaceDir,
+        });
+        if (result.status === 'failed') {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: result.error ?? result.reason,
+            });
+        }
+        return result;
+    });
+}
+async function runReviewSummaryRequest({ provider, resolvedCredential, resolvedModelName, logModelName, prompt, workspaceDir, }) {
+    try {
+        const thinkingLevel = provider === 'zai' ? 'high' : DEFAULT_REVIEW_SUMMARY_THINKING_LEVEL;
+        logger.info('Review summary model request', {
+            provider,
+            modelName: logModelName,
+            promptLength: prompt.length,
+            timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
+            thinkingLevel,
+        });
+        const result = await invokePiPrompt({
+            provider,
+            apiKey: resolvedCredential.apiKey,
+            ...(resolvedCredential.piProviderId
+                ? { piProviderId: resolvedCredential.piProviderId }
+                : {}),
+            ...(resolvedModelName ? { modelName: resolvedModelName } : {}),
+            prompt,
+            cwd: workspaceDir ?? getWorkspaceDir(),
+            timeoutMs: REVIEW_SUMMARY_TIMEOUT_MS,
+            capabilityPreset: 'read-only',
+            thinkingLevel,
+        });
+        if (!result.ok) {
+            const reason = getRequestFailureReason(result);
+            logger.warn('Review summary model request failed', {
+                reason,
+                provider,
+                modelName: logModelName,
+                error: result.error,
+                timedOut: result.timedOut,
+                durationMs: result.durationMs,
+                promptLength: prompt.length,
+            });
+            return failedReviewSummaryRequest({
+                reason,
+                error: result.error,
+                timedOut: result.timedOut,
+                durationMs: result.durationMs,
+            });
+        }
+        const output = result.output;
+        if (!output?.trim()) {
+            return failedReviewSummaryRequest({
+                reason: 'empty_output',
+                durationMs: result.durationMs,
+                outputChars: output?.length ?? 0,
+            });
+        }
+        const jsonCandidates = extractJsonCandidatesFromResponse(output);
+        if (jsonCandidates.length === 0) {
+            logger.warn('Review summary model output missing JSON', {
+                provider,
+                modelName: logModelName,
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'missing_json',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        let parsed;
+        let parsedSuccessfully = false;
+        let parseError;
+        for (const jsonCandidate of jsonCandidates) {
+            try {
+                parsed = JSON.parse(jsonCandidate);
+                parsedSuccessfully = true;
+                break;
+            }
+            catch (error) {
+                parseError = error;
+            }
+        }
+        if (!parsedSuccessfully) {
+            logger.warn('Review summary model output contained invalid JSON', {
+                provider,
+                modelName: logModelName,
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+            return failedReviewSummaryRequest({
+                reason: 'invalid_json',
+                error: parseError instanceof Error ? parseError.message : String(parseError),
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        if (!parsed || typeof parsed !== 'object') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        const summaryResult = parsed;
+        if (typeof summaryResult.summary !== 'string') {
+            return failedReviewSummaryRequest({
+                reason: 'invalid_schema',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        if (!summaryResult.summary.trim()) {
+            return failedReviewSummaryRequest({
+                reason: 'empty_summary',
+                durationMs: result.durationMs,
+                outputChars: output.length,
+            });
+        }
+        logger.info('Review summary model response', {
+            provider,
+            modelName: logModelName,
+            durationMs: result.durationMs,
+            outputChars: output.length,
+            summaryChars: summaryResult.summary.trim().length,
+        });
+        return {
+            status: 'succeeded',
+            summary: summaryResult.summary,
+            comments: Array.isArray(summaryResult.comments) ? summaryResult.comments : [],
+            durationMs: result.durationMs,
+            outputChars: output.length,
+        };
+    }
+    catch (error) {
+        logger.error('Review summary model request or parsing failed', {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return failedReviewSummaryRequest({
+            reason: 'request_failed',
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+export function sanitizeInlineComments(comments, lineLookup) {
+    if (!Array.isArray(comments)) {
+        return [];
+    }
+    const sanitized = [];
+    for (const comment of comments) {
+        const filePath = typeof comment.path === 'string' ? comment.path.trim() : '';
+        const line = Number(comment.line);
+        let side = typeof comment.side === 'string'
+            ? comment.side.toUpperCase()
+            : DIFF_SIDE.RIGHT;
+        const body = typeof comment.body === 'string' ? comment.body.trim() : '';
+        if (!filePath || !Number.isInteger(line) || !body) {
+            continue;
+        }
+        if (side !== DIFF_SIDE.LEFT && side !== DIFF_SIDE.RIGHT) {
+            logger.warn('Invalid side for comment, defaulting to RIGHT', {
+                filePath,
+                line,
+                side,
+            });
+            side = DIFF_SIDE.RIGHT;
+        }
+        const fileLines = lineLookup.get(filePath);
+        if (!fileLines) {
+            continue;
+        }
+        const validLines = side === DIFF_SIDE.LEFT ? fileLines.old : fileLines.new;
+        if (!validLines.has(line)) {
+            continue;
+        }
+        sanitized.push({
+            path: filePath,
+            line,
+            side,
+            body,
+        });
+    }
+    return sanitized;
+}

package/sandbox/dist/tasks/review/thinking-level.js

@@ -0,0 +1,14 @@
+export function getReviewThinkingLevel(model) {
+    switch (model) {
+        case 'deepseek':
+            return 'high';
+        case 'openai':
+            return 'xhigh';
+        case 'grok':
+            return 'high';
+        case 'zai':
+            return 'high';
+        case 'gemini':
+            return 'high';
+    }
+}

package/sandbox/dist/tasks/review/translation-review-policy.js

@@ -0,0 +1,37 @@
+const ENGLISH_SOURCE_FIRST_REPOSITORIES = new Set([
+    'todoist/todoist-web',
+    'todoist/todoist-android',
+    'todoist/todoist-ios',
+    'todoist/todoist-electron',
+    'todoist/todoist-macos',
+]);
+export function usesEnglishSourceFirstTranslations(repoOwner, repoName) {
+    return ENGLISH_SOURCE_FIRST_REPOSITORIES.has(`${repoOwner}/${repoName}`.toLowerCase().replace(/^doist\//, 'todoist/'));
+}
+export function buildTranslationReviewGuidance(repoOwner, repoName) {
+    if (!usesEnglishSourceFirstTranslations(repoOwner, repoName)) {
+        return '';
+    }
+    return `## Repository-specific Translation Workflow
+
+This repository uses an English-source-first workflow: feature PRs change the English source strings, automation sends them to the repository's translation service, and translated locale files arrive through a later automated sync.
+
+- Do not create a finding or summary note merely because translated locale files or generated locale bundles are unchanged in the feature PR.
+- Do not ask the author to pull, update, generate, or commit translations manually. If the PR description already mentions the translation-service follow-up, including Transifex, do not repeat it.
+- Continue to report concrete i18n implementation errors introduced by the diff, such as incorrect translation API or gettext usage, broken interpolation placeholders, pluralization or context mistakes, and patterns that prevent source-string extraction.`;
+}
+export function isTranslationSyncOnlyFinding(repoOwner, repoName, finding) {
+    return (usesEnglishSourceFirstTranslations(repoOwner, repoName) &&
+        finding.translationResolution === 'automated_sync_resolves');
+}
+export function filterTranslationSyncOnlyFindings({ repoOwner, repoName, findings, }) {
+    const keptFindings = [];
+    const droppedFindings = [];
+    for (const finding of findings) {
+        const destination = isTranslationSyncOnlyFinding(repoOwner, repoName, finding)
+            ? droppedFindings
+            : keptFindings;
+        destination.push(finding);
+    }
+    return { findings: keptFindings, droppedFindings };
+}

package/sandbox/dist/tasks/review/types.js

@@ -0,0 +1 @@
+export {};

package/sandbox/dist/tasks/review-slice-plan/context.js

@@ -0,0 +1,66 @@
+import { ReviewHygieneDecisionKind, ReviewHygieneExclusionReason, ReviewHygieneReasonCode, } from 'doistbot-async-routing-contracts';
+import { parseBaseContext, requiredEnv } from '../../core/environment.js';
+export function parseReviewSlicePlanContext(env = process.env) {
+    const dryRun = env.DRY_RUN?.toLowerCase() === 'true';
+    return {
+        ...parseBaseContext(env),
+        baseBranch: requiredEnv('BASE_BRANCH', env),
+        headSha: requiredEnv('HEAD_SHA', env),
+        runId: requiredEnv('SLICE_PLAN_RUN_ID', env),
+        reviewHygiene: parseReviewHygieneDecision(requiredEnv('REVIEW_HYGIENE_DECISION', env)),
+        geminiApiKey: requiredEnv('GEMINI_API_KEY', env),
+        ...(dryRun
+            ? { dryRun: true }
+            : { dryRun: false, commsAlertKey: requiredEnv('COMMS_ALERT_KEY', env) }),
+    };
+}
+function parseReviewHygieneDecision(serialized) {
+    let value;
+    try {
+        value = JSON.parse(serialized);
+    }
+    catch (error) {
+        throw new Error(`Invalid REVIEW_HYGIENE_DECISION JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isRecord(value)) {
+        throw new Error('Invalid REVIEW_HYGIENE_DECISION: expected an object');
+    }
+    if (value.kind !== ReviewHygieneDecisionKind.Warn &&
+        value.kind !== ReviewHygieneDecisionKind.Block) {
+        throw new Error('Invalid REVIEW_HYGIENE_DECISION: expected warn or block');
+    }
+    if (!isReviewHygieneStats(value.stats) ||
+        !Array.isArray(value.reasons) ||
+        !value.reasons.every(isReviewHygieneReason)) {
+        throw new Error('Invalid REVIEW_HYGIENE_DECISION: missing stats or reasons');
+    }
+    if (value.exclusionSummary !== undefined &&
+        !isReviewHygieneExclusionSummary(value.exclusionSummary)) {
+        throw new Error('Invalid REVIEW_HYGIENE_DECISION: invalid exclusion summary');
+    }
+    return value;
+}
+function isReviewHygieneReason(value) {
+    return (isRecord(value) &&
+        Object.values(ReviewHygieneReasonCode).includes(value.code) &&
+        isFiniteNumber(value.actual) &&
+        isFiniteNumber(value.limit));
+}
+function isReviewHygieneExclusionSummary(value) {
+    return (isRecord(value) &&
+        ['files', 'additions', 'deletions', 'changedLines', 'reviewLoadLines'].every((key) => isFiniteNumber(value[key])) &&
+        Array.isArray(value.reasons) &&
+        value.reasons.every((reason) => Object.values(ReviewHygieneExclusionReason).includes(reason)));
+}
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function isReviewHygieneStats(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    return ['additions', 'deletions', 'changedFiles', 'changedLines', 'reviewLoadLines'].every((key) => isFiniteNumber(value[key]));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}