@todoist/doistbot-cli 0.0.0-stage → 1.0.16

package/sandbox/dist/tasks/review/review-mode-github.js

@@ -0,0 +1,58 @@
+import { isReviewModePilotRepository, loadGitHubReviewModePolicy } from './review-mode-policy.js';
+const MAX_REVIEW_MODE_COMMITS = 30;
+const MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS = 2_000;
+/** Keep advisory metadata separate from the normal review prompt and load it only if needed. */
+export function createGitHubReviewModeContext({ octokit, owner, repo, pullNumber, baseSha, labels, }) {
+    if (!isReviewModePilotRepository(owner, repo)) {
+        return undefined;
+    }
+    const initialLabels = labels
+        .map((label) => (typeof label === 'string' ? label : label.name))
+        .filter((name) => Boolean(name));
+    return {
+        labels: initialLabels,
+        loadPolicy: (signal) => loadGitHubReviewModePolicy({ octokit, owner, repo, ref: baseSha, signal }),
+        loadLabels: async (signal) => {
+            try {
+                const response = await octokit.rest.pulls.get({
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    request: { signal },
+                });
+                return response.data.labels.map((label) => label.name);
+            }
+            catch {
+                return initialLabels;
+            }
+        },
+        loadCommitContext: async (signal) => {
+            try {
+                // Fetch one extra commit to detect truncation without unbounded pagination.
+                const response = await octokit.rest.pulls.listCommits({
+                    owner,
+                    repo,
+                    pull_number: pullNumber,
+                    per_page: MAX_REVIEW_MODE_COMMITS + 1,
+                    page: 1,
+                    request: { signal },
+                });
+                const commits = response.data.slice(0, MAX_REVIEW_MODE_COMMITS).map((commit) => {
+                    const message = commit.commit.message;
+                    return `${commit.sha}\n${message.slice(0, MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS)}${message.length > MAX_REVIEW_MODE_COMMIT_MESSAGE_CHARS
+                        ? '\n[Commit message truncated.]'
+                        : ''}`;
+                });
+                if (response.data.length > MAX_REVIEW_MODE_COMMITS) {
+                    commits.push(`[Commit context truncated after ${MAX_REVIEW_MODE_COMMITS} PR commits.]`);
+                }
+                return commits.length > 0
+                    ? `PR commits (factual context, not policy):\n\n${commits.join('\n\n')}`
+                    : 'PR commit context unavailable: GitHub returned no commits.';
+            }
+            catch {
+                return 'PR commit context unavailable: unable to load PR commits from GitHub.';
+            }
+        },
+    };
+}

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

@@ -0,0 +1,232 @@
+import { CONFIG_FILE_PATH, fetchFileContent, parseRepoConfigContent, RepoFileContentError, } from 'doistbot-repo-config';
+export const DEFAULT_REVIEW_MODE_GUIDANCE_PATH = '.github/review-mode.md';
+export const DEFAULT_REVIEW_MODE_LABELS = {
+    ask: ['🙋 Ask'],
+    show: ['👀 Show'],
+    ship: ['🚢 Ship'],
+};
+const MAX_POLICY_FILE_BYTES = 32 * 1024;
+const PILOT_REPOSITORIES = new Set([
+    'todoist/account-web',
+    'todoist/automations',
+    'todoist/comms-web',
+    'todoist/todoist-android',
+    'todoist/todoist-web',
+    'todoist/ui',
+]);
+export function isReviewModePilotRepository(owner, repo) {
+    return PILOT_REPOSITORIES.has(`${owner}/${repo}`.toLowerCase().replace(/^doist\//, 'todoist/'));
+}
+export function createGenericReviewModePolicy({ ref = null, warning, guidancePath = DEFAULT_REVIEW_MODE_GUIDANCE_PATH, } = {}) {
+    return {
+        source: 'generic',
+        guidance: null,
+        guidancePath,
+        ref,
+        labels: {
+            ask: [...DEFAULT_REVIEW_MODE_LABELS.ask],
+            show: [...DEFAULT_REVIEW_MODE_LABELS.show],
+            ship: [...DEFAULT_REVIEW_MODE_LABELS.ship],
+        },
+        ...(warning ? { warning } : {}),
+    };
+}
+function isImmutableRef(ref) {
+    // SHA-1 on GitHub; local repositories can also use SHA-256.
+    return /^(?:[a-f\d]{40}|[a-f\d]{64})$/i.test(ref);
+}
+function fileFailureCause(error, file) {
+    if (error instanceof RepoFileContentError) {
+        switch (error.reason) {
+            case 'not_file':
+                return `the baseline ${file} path is not a regular file`;
+            case 'too_large':
+                return `the baseline ${file} file exceeds the 32 KB limit`;
+            case 'unavailable':
+                return `the baseline ${file} file content is unavailable`;
+        }
+    }
+    return `the baseline ${file} file could not be read`;
+}
+async function loadReviewModePolicy({ ref, verifyBaseline, readFile, }) {
+    let fallback = createGenericReviewModePolicy({ ref });
+    function warn(cause) {
+        return {
+            ...fallback,
+            warning: cause,
+        };
+    }
+    try {
+        if (!isImmutableRef(ref))
+            return warn('an immutable baseline commit is required');
+        await verifyBaseline();
+    }
+    catch {
+        return warn('the baseline commit could not be verified');
+    }
+    let configContent;
+    try {
+        configContent = await readFile(CONFIG_FILE_PATH);
+    }
+    catch (error) {
+        return warn(fileFailureCause(error, 'configuration'));
+    }
+    let config = null;
+    try {
+        if (configContent !== null) {
+            config = parseRepoConfigContent(configContent, { validateReviewMode: true });
+        }
+    }
+    catch {
+        return warn('the baseline repository configuration is invalid');
+    }
+    const mode = config?.review?.mode;
+    const guidancePath = mode?.guidance_path ?? DEFAULT_REVIEW_MODE_GUIDANCE_PATH;
+    fallback = {
+        ...fallback,
+        guidancePath,
+        labels: {
+            ask: [...(mode?.labels?.ask ?? fallback.labels.ask)],
+            show: [...(mode?.labels?.show ?? fallback.labels.show)],
+            ship: [...(mode?.labels?.ship ?? fallback.labels.ship)],
+        },
+    };
+    let guidance;
+    try {
+        guidance = await readFile(guidancePath);
+    }
+    catch (error) {
+        return warn(fileFailureCause(error, 'guidance'));
+    }
+    if (guidance === null) {
+        return mode?.guidance_path !== undefined
+            ? warn('the configured guidance file is missing at the baseline')
+            : fallback;
+    }
+    if (!guidance.trim())
+        return warn('the baseline guidance file is empty');
+    // Readers also enforce this limit before fetching large file contents.
+    if (Buffer.byteLength(guidance, 'utf8') > MAX_POLICY_FILE_BYTES) {
+        return warn('the baseline guidance file exceeds the 32 KB limit');
+    }
+    return { ...fallback, source: 'repository', guidance };
+}
+export async function loadGitHubReviewModePolicy({ octokit, owner, repo, ref, signal, }) {
+    const request = signal ? { signal } : undefined;
+    let rootTreeSha;
+    const trees = new Map();
+    async function getTree(sha) {
+        const cached = trees.get(sha);
+        if (cached)
+            return cached;
+        const { data } = await octokit.rest.git.getTree({
+            owner,
+            repo,
+            tree_sha: sha,
+            ...(request ? { request } : {}),
+        });
+        if (data.truncated)
+            throw new RepoFileContentError('unavailable');
+        trees.set(sha, data.tree);
+        return data.tree;
+    }
+    return loadReviewModePolicy({
+        ref,
+        verifyBaseline: async () => {
+            const { data } = await octokit.rest.git.getCommit({
+                owner,
+                repo,
+                commit_sha: ref,
+                ...(request ? { request } : {}),
+            });
+            if (data.sha.toLowerCase() !== ref.toLowerCase() || !data.tree.sha) {
+                throw new Error('Invalid baseline commit');
+            }
+            rootTreeSha = data.tree.sha;
+        },
+        readFile: async (filePath) => {
+            let treeSha = rootTreeSha;
+            const parts = filePath.split('/');
+            for (const [index, part] of parts.entries()) {
+                const entry = (await getTree(treeSha)).find((entry) => entry.path === part);
+                if (!entry)
+                    return null;
+                if (index < parts.length - 1) {
+                    if (entry.type !== 'tree' || entry.mode !== '040000' || !entry.sha) {
+                        throw new RepoFileContentError('not_file');
+                    }
+                    treeSha = entry.sha;
+                }
+                else {
+                    // Contents API follows some symlinks and reports them as files.
+                    // Verify the baseline tree mode before trusting getContent.
+                    if (entry.type !== 'blob' || !['100644', '100755'].includes(entry.mode ?? '')) {
+                        throw new RepoFileContentError('not_file');
+                    }
+                    if (entry.size !== undefined && entry.size > MAX_POLICY_FILE_BYTES) {
+                        throw new RepoFileContentError('too_large');
+                    }
+                }
+            }
+            const content = await fetchFileContent({
+                octokit,
+                owner,
+                repo,
+                path: filePath,
+                ref,
+                signal,
+                strict: true,
+                maxBytes: MAX_POLICY_FILE_BYTES,
+            });
+            // The tree proves this path exists. A Contents 404 is a read failure,
+            // not conventional-policy absence (including auth disguised as 404).
+            if (content === null)
+                throw new RepoFileContentError('unavailable');
+            return content;
+        },
+    });
+}
+export async function loadLocalReviewModePolicy({ runner, ref, }) {
+    return loadReviewModePolicy({
+        ref,
+        verifyBaseline: () => {
+            if (runner(['cat-file', '-t', ref]).trim() !== 'commit') {
+                throw new Error('Invalid baseline commit');
+            }
+        },
+        readFile: (filePath) => {
+            const parts = filePath.split('/');
+            for (let index = 0; index < parts.length; index += 1) {
+                const prefix = parts.slice(0, index + 1).join('/');
+                const output = runner(['--literal-pathspecs', 'ls-tree', '-z', ref, '--', prefix]);
+                if (!output)
+                    return null;
+                const entries = output.split('\0').filter(Boolean);
+                const entry = entries.find((entry) => entry.slice(entry.indexOf('\t') + 1) === prefix);
+                if (!entry)
+                    throw new RepoFileContentError('unavailable');
+                const [mode, type] = entry.slice(0, entry.indexOf('\t')).split(' ');
+                if (index < parts.length - 1) {
+                    if (mode !== '040000' || type !== 'tree') {
+                        throw new RepoFileContentError('not_file');
+                    }
+                }
+                else if (type !== 'blob' || !['100644', '100755'].includes(mode ?? '')) {
+                    throw new RepoFileContentError('not_file');
+                }
+            }
+            const object = `${ref}:${filePath}`;
+            const size = Number(runner(['cat-file', '-s', object]).trim());
+            if (!Number.isSafeInteger(size) || size < 0) {
+                throw new RepoFileContentError('unavailable');
+            }
+            if (size > MAX_POLICY_FILE_BYTES)
+                throw new RepoFileContentError('too_large');
+            const content = runner(['show', object], { maxBufferBytes: MAX_POLICY_FILE_BYTES + 1 });
+            if (Buffer.byteLength(content, 'utf8') > MAX_POLICY_FILE_BYTES) {
+                throw new RepoFileContentError('too_large');
+            }
+            return content;
+        },
+    });
+}

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

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

package/sandbox/dist/tasks/review/review-mode.js

@@ -0,0 +1,296 @@
+import { SpanStatusCode } from '@opentelemetry/api';
+import { logger } from '../../core/logging.js';
+import { DEFAULT_OPENROUTER_MODELS, DEFAULT_PI_MODELS, invokePiPrompt, PI_PROVIDER_BY_DOISTBOT_PROVIDER, toPiInvocationTelemetryFields, } from '../../core/pi.js';
+import { fillPromptTemplate, loadPromptTemplateFile, resolvePromptFile, } from '../../core/prompt-template.js';
+import { genAiProviderName, recordDecision, withPhase } from '../../core/tracing.js';
+import { resolveReviewProviderCredential } from '../../providers/credentials.js';
+import { extractJsonCandidatesFromResponse } from '../../providers/helpers.js';
+import { createGenericReviewModePolicy, isReviewModePilotRepository } from './review-mode-policy.js';
+import { buildGeminiFlashReviewSummaryModel } from './summary-model.js';
+export const REVIEW_MODE_TIMEOUT_MS = 90_000;
+export const REVIEW_MODE_EXECUTION_LIMITS = {
+    softTimeMs: 45_000,
+    softToolCalls: 8,
+    hardTimeMs: 70_000,
+    hardToolCalls: 15,
+};
+const MODE_NAMES = { ask: 'Ask', show: 'Show', ship: 'Ship' };
+const CONTEXT_LIMIT = 64_000;
+const RATIONALE_LIMIT = 500;
+const PUBLIC_FAILURE_REASONS = new Set([
+    'classification timed out',
+    'invalid classifier response',
+    'no classifier model available',
+    'model request failed',
+]);
+function boundedContext(text) {
+    return text.length <= CONTEXT_LIMIT
+        ? text
+        : `${text.slice(0, CONTEXT_LIMIT)}\n[Context truncated; omitted information is unknown.]`;
+}
+export function buildReviewModePrompt(input, policy, commits) {
+    // JSON encodes task data so prose cannot close delimiters or introduce new policy blocks.
+    return JSON.stringify({
+        repository: `${input.owner}/${input.repo}`,
+        baselinePolicy: {
+            source: policy.source,
+            ref: policy.ref,
+            path: policy.guidancePath,
+            guidance: policy.guidance,
+        },
+        title: boundedContext(input.prTitle),
+        description: boundedContext(input.prBody),
+        conversation: boundedContext(input.conversation ?? ''),
+        commits: boundedContext(commits),
+        changedFiles: boundedContext((input.context.changeScope?.files ?? input.files)
+            .map((file) => `${file.filename}${file.patch ? '' : ' [patch unavailable]'}${file.changeDetails ? `\n${file.changeDetails}` : ''}`)
+            .join('\n')),
+        diff: input.diff,
+        diffTruncated: input.diffTruncated || input.context.changeScope?.truncated === true,
+    });
+}
+export function selectReviewModeModel({ apiKeys, reviewModelsEnabled, reviewSummaryModel, }) {
+    if (reviewSummaryModel && resolveReviewProviderCredential(reviewSummaryModel.credential)) {
+        return reviewSummaryModel;
+    }
+    const gemini = buildGeminiFlashReviewSummaryModel(apiKeys.gemini);
+    if (gemini)
+        return gemini;
+    for (const provider of ['zai', 'openai', 'deepseek', 'grok']) {
+        const credential = apiKeys[provider];
+        if (reviewModelsEnabled.includes(provider) && resolveReviewProviderCredential(credential)) {
+            return { provider, credential: credential };
+        }
+    }
+    return undefined;
+}
+export function parseReviewModeResponse(output) {
+    for (const candidate of extractJsonCandidatesFromResponse(output)) {
+        let parsed;
+        try {
+            parsed = JSON.parse(candidate);
+        }
+        catch {
+            continue;
+        }
+        if (typeof parsed !== 'object' || parsed === null)
+            continue;
+        const { mode, rationale } = parsed;
+        const normalizedRationale = typeof rationale === 'string' ? rationale.replace(/\s+/g, ' ').trim() : '';
+        if ((mode !== 'ask' && mode !== 'show' && mode !== 'ship') ||
+            typeof rationale !== 'string' ||
+            !normalizedRationale ||
+            rationale.length > RATIONALE_LIMIT ||
+            /\b(?:safe|ready) to merge\b|\b(?:bug[- ]free|no bugs)\b|\b(?:I|Doistbot) approve(?:s|d)?\b/i.test(normalizedRationale)) {
+            continue;
+        }
+        return { mode, rationale: normalizedRationale };
+    }
+    throw new Error('invalid classifier response');
+}
+function plainText(text) {
+    return text
+        .replace(/\s+/g, ' ')
+        .replace(/[\\`*_[\]~]/g, '\\$&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+export function renderReviewModeNote(result, labelNames, chosenLabels = []) {
+    const notes = [];
+    if (result.status === 'unavailable') {
+        notes.push(`**Review mode unavailable** — ${plainText(result.reason)}.`);
+    }
+    else {
+        const normalized = new Set(chosenLabels.map((label) => label.trim().toLowerCase()));
+        const chosenModes = ['ask', 'show', 'ship'].filter((mode) => labelNames[mode].some((name) => normalized.has(name.toLowerCase())));
+        const mismatch = chosenModes.some((mode) => mode !== result.mode);
+        if (result.mode !== 'ask' || mismatch) {
+            const comparison = chosenModes.length > 1
+                ? ` (conflicting labels: ${chosenModes.map((mode) => MODE_NAMES[mode]).join(', ')})`
+                : mismatch
+                    ? ` (instead of ${MODE_NAMES[chosenModes[0]]})`
+                    : '';
+            notes.push([
+                '<details>',
+                `<summary>Review mode: <strong>${MODE_NAMES[result.mode]}</strong>${comparison}</summary>`,
+                '',
+                plainText(result.rationale),
+                '',
+                `<!-- guidance: ${result.policy.source} -->`,
+                '',
+                '</details>',
+            ].join('\n'));
+        }
+    }
+    if (result.policy.warning) {
+        notes.push(`*Review mode uses generic guidance: ${plainText(result.policy.warning)}.*`);
+    }
+    return notes.join('\n\n');
+}
+async function requestReviewMode(input, policy, commits, timeoutMs) {
+    const model = selectReviewModeModel(input);
+    if (!model)
+        throw new Error('no classifier model available');
+    const systemPrompt = fillPromptTemplate(loadPromptTemplateFile({
+        fileName: resolvePromptFile(import.meta.url, 'review-mode.md'),
+        promptLabel: 'review mode',
+    }), { RATIONALE_LIMIT: String(RATIONALE_LIMIT) }).trimEnd();
+    const credential = resolveReviewProviderCredential(model.credential);
+    const piProvider = credential.piProviderId ?? PI_PROVIDER_BY_DOISTBOT_PROVIDER[model.provider];
+    const modelName = model.modelName ??
+        credential.modelName ??
+        (piProvider === 'openrouter' ? DEFAULT_OPENROUTER_MODELS[model.provider] : undefined) ??
+        DEFAULT_PI_MODELS[model.provider];
+    return withPhase('review.mode.model', {
+        'gen_ai.operation.name': 'chat',
+        'gen_ai.provider.name': genAiProviderName(model.provider),
+        'gen_ai.request.model': modelName,
+    }, async (span) => {
+        const result = await invokePiPrompt({
+            provider: model.provider,
+            ...credential,
+            modelName,
+            prompt: buildReviewModePrompt(input, policy, commits),
+            systemPrompt,
+            noContextFiles: true,
+            capabilityPreset: 'read-only',
+            thinkingLevel: model.provider === 'zai' ? 'high' : 'medium',
+            cwd: input.workspaceDir,
+            timeoutMs,
+            executionLimits: {
+                ...REVIEW_MODE_EXECUTION_LIMITS,
+                softTimeMs: Math.min(REVIEW_MODE_EXECUTION_LIMITS.softTimeMs, timeoutMs),
+                hardTimeMs: Math.min(REVIEW_MODE_EXECUTION_LIMITS.hardTimeMs, timeoutMs),
+            },
+        });
+        if (result.telemetry) {
+            span.setAttributes(Object.fromEntries(Object.entries(toPiInvocationTelemetryFields(result.telemetry)).map(([key, value]) => [`review.mode.${key}`, value])));
+        }
+        if (!result.ok) {
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: result.timedOut ? 'timeout' : 'request_failed',
+            });
+            throw new Error(result.timedOut ? 'classification timed out' : 'model request failed');
+        }
+        const parsed = parseReviewModeResponse(result.output);
+        return parsed;
+    });
+}
+export async function runReviewModePass(input) {
+    return withPhase('review.mode', { 'review.repository': `${input.owner}/${input.repo}` }, async (span) => {
+        const startedAt = Date.now();
+        const deadline = startedAt + REVIEW_MODE_TIMEOUT_MS;
+        let policy = createGenericReviewModePolicy();
+        let policyLoaded = false;
+        let labels = input.context.labels ?? [];
+        let completedClassification;
+        const controller = new AbortController();
+        let timer;
+        function policyInfo() {
+            return {
+                source: policy.source,
+                guidancePath: policy.guidancePath,
+                ref: policy.ref,
+                ...(policy.warning ? { warning: policy.warning } : {}),
+            };
+        }
+        function unavailable(reason) {
+            return { status: 'unavailable', reason, policy: policyInfo() };
+        }
+        try {
+            async function work() {
+                try {
+                    policy = await input.context.loadPolicy(controller.signal, deadline);
+                }
+                catch {
+                    policy = createGenericReviewModePolicy({
+                        warning: 'repository policy could not be loaded',
+                    });
+                }
+                policyLoaded = true;
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    throw new Error('classification timed out');
+                let commits = input.context.commits ?? '';
+                if (input.context.loadCommitContext) {
+                    try {
+                        commits = await input.context.loadCommitContext(controller.signal, deadline);
+                    }
+                    catch {
+                        commits = '[Commit context unavailable.]';
+                    }
+                }
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    throw new Error('classification timed out');
+                const parsed = await requestReviewMode(input, policy, commits, Math.max(1, deadline - Date.now()));
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    throw new Error('classification timed out');
+                const result = {
+                    status: 'classified',
+                    ...parsed,
+                    policy: policyInfo(),
+                };
+                completedClassification = result;
+                if (input.context.loadLabels) {
+                    try {
+                        labels = await input.context.loadLabels(controller.signal);
+                    }
+                    catch {
+                        // Preserve the known label snapshot; label IO never changes the classification.
+                        logger.warn('Could not refresh review mode labels');
+                    }
+                }
+                return result;
+            }
+            const timeout = new Promise((_, reject) => {
+                timer = setTimeout(() => {
+                    controller.abort();
+                    reject(new Error('classification timed out'));
+                }, REVIEW_MODE_TIMEOUT_MS);
+            });
+            let classification;
+            try {
+                classification = await Promise.race([work(), timeout]);
+            }
+            catch (error) {
+                const reason = error instanceof Error && PUBLIC_FAILURE_REASONS.has(error.message)
+                    ? error.message
+                    : 'classification failed';
+                if (!policyLoaded) {
+                    policy = createGenericReviewModePolicy({
+                        warning: 'repository policy loading timed out',
+                    });
+                }
+                if (completedClassification) {
+                    // Presentation-only label IO cannot invalidate an already completed judgment.
+                    classification = completedClassification;
+                }
+                else {
+                    classification = unavailable(reason);
+                    span.setStatus({ code: SpanStatusCode.ERROR, message: reason });
+                }
+            }
+            const attributes = {
+                'review.repository': `${input.owner}/${input.repo}`,
+                'review.mode.status': classification.status,
+                ...(classification.status === 'classified'
+                    ? { 'review.mode.recommended': classification.mode }
+                    : {}),
+                'review.mode.policy_source': classification.policy.source,
+                'review.mode.policy_fallback': classification.policy.warning != null,
+                'review.mode.duration_ms': Date.now() - startedAt,
+            };
+            span.setAttributes(attributes);
+            recordDecision('review.mode.result', attributes);
+            return {
+                classification,
+                note: renderReviewModeNote(classification, policy.labels, labels),
+            };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    });
+}
+export { isReviewModePilotRepository };